def load_ibm_account(self): IBMQ.save_account(self.ibm_set['token']) IBMQ.load_account() self.provider = IBMQ.get_provider("ibm-q")
import cv2 import matplotlib.pyplot as plt import numpy as np from qiskit import BasicAer, IBMQ from utils.rand_gen import random_gen ########### Calling Quantum Computer###### api_file = open("API_token.txt", "r") api_key = "" if api_file.mode == 'r': api_key = api_file.read() #print("API_key: ", api_key) IBMQ.save_account(api_key) provider = IBMQ.load_account() backend = provider.get_backend('ibmq_essex') #select which machine ########################################## #backend = BasicAer.get_backend("qasm_simulator") #simulator q_gen = random_gen(1, backend) class Tile(): def __init__(self, img, idx): self.img = img self.idx = idx self.neighbors = {
def loadAccount(): from qiskit import IBMQ IBMQ.save_account(open('token.txt', 'r').read()) IBMQ.load_account()
def bernstein(error_correct=False): API_TOKEN = '7cf33cd2f0d7044af8518c33321fa74d7380d3ba58d08b271404e8226aa1f5490818ba86e1635f89e6c3cfbf10aa091ff04c1f5ff61f0f391ed780b4484e0b18' # initialize qiskit IBMQ.save_account(API_TOKEN) provider = IBMQ.load_account() print(provider.backends()) backend = provider.backends.ibmq_16_melbourne # initialize qubits with architecture in mind qubits = [cirq.GridQubit(0, 5), cirq.GridQubit(1, 4),\ cirq.GridQubit(0, 6), cirq.GridQubit(2, 5),\ cirq.GridQubit(2, 3), cirq.GridQubit(1, 5),\ cirq.GridQubit(3, 4), cirq.GridQubit(2, 4)] if error_correct: error_qubits = [cirq.GridQubit(3, 4), cirq.GridQubit(3, 3),\ cirq.GridQubit(3, 2), cirq.GridQubit(4, 3)] # construct circuit circuit = cirq.Circuit() # error correction setup. error correct qubit (2,3) if error_correct: circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])]) # hadamards circuit.append([cirq.H(q) for q in qubits]) # turn helper qubit to 1 circuit.append([cirq.Z(qubits[7])]) # oracle circuit.append([cirq.CNOT(qubits[1], qubits[7])]) circuit.append([cirq.CNOT(qubits[3], qubits[7])]) circuit.append([cirq.CNOT(qubits[4], qubits[7])]) circuit.append([cirq.CNOT(qubits[6], qubits[7])]) # hadamards circuit.append([cirq.H(q) for q in qubits[:-1]]) # error detection and correction if error_correct: circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(error_qubits[1], error_qubits[2])]) circuit.append([cirq.SWAP(error_qubits[3], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(error_qubits[0], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[1], error_qubits[3])]) circuit.append( [cirq.measure(error_qubits[2]), cirq.measure(error_qubits[3])]) circuit.append( [cirq.CCNOT(qubits[2], error_qubits[1], error_qubits[0])]) # measure circuit.append([cirq.measure(q) for q in qubits[:-1]]) # export to qasm qasm_str = circuit.to_qasm() # import qiskit from qasm qiskit_circuit = qiskitqc.from_qasm_str(qasm_str) # run qiskit transpiled = transpile(qiskit_circuit, backend) qobj = assemble(transpiled, backend, shots=100) job = backend.run(qobj) print(job.job_id()) result = job.result() counts = result.get_counts() delayed_result = backend.retrieve_job(job.job_id()).result() delayed_counts = delayed_result.get_counts() print(counts) print(delayed_counts) return requests.post(url, json=job_payload)
def test_load_from_disk(token): IBMQ.save_account(token) dev = IBMQDevice(wires=1) assert dev.provider.credentials.is_ibmq() IBMQ.delete_account()
# coding: utf-8 # In[2]: import warnings from qiskit.tools.jupyter import * from qiskit import IBMQ from qiskit import assemble from qiskit import pulse from qiskit.pulse import pulse_lib import numpy as np import matplotlib.pyplot as plt # This is my token! IBMQ.save_account('dc42f3bec0eb08d5702e81cdac45ee0278fedd659670e4acf130480e6851d50145d0669c91070c225ad916d237351200edb6ba79ed944e21c3b3a89e30fc00db') warnings.filterwarnings('ignore') IBMQ.load_account() # # Pick your favorite (not busy) Backend # In[3]: # Try again using Johannesbourg!!! provider = IBMQ.get_provider(hub='ibm-q-csic',group='internal') backend = provider.get_backend('ibmq_johannesburg') backend_config = backend.configuration() assert backend_config.open_pulse, "Backend doesn't support OpenPulse"
from qiskit.aqua.components.optimizers import SPSA from qiskit.aqua.components.variational_forms import RY from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.optimization.ising.common import sample_most_likely from qiskit import QuantumCircuit, execute, Aer, IBMQ from qiskit.compiler import transpile, assemble from qiskit.tools.jupyter import * from qiskit.visualization import * import webbrowser import logging from qiskit.aqua import set_qiskit_aqua_logging from qiskit import IBMQ IBMQ.save_account('(INSERT IBMQ KEY HERE)', overwrite=True) IBMQ.load_account() import networkx as nx # Ding the distance matrix locations = [ "135 Overlea Blvd, North York, ON M3C 1B3", "1040 Broadview Ave, Toronto, ON M4K 2S2", "4 Astor Ave, East York, ON M4G 3M2", "455 Cosburn Ave, East York, ON M4J 2N2", "1500 Woodbine Ave, East York, ON M4C 4G9" ] coordinates = [] for i in locations: coordinates.append(
def __init__(self, factor): self.factor = factor storedAccount = IBMQ.stored_account() if storedAccount == None or storedAccount == {}: IBMQ.save_account(token) self.__provider = IBMQ.load_account()
from qiskit import Aer, IBMQ, execute from qiskit.providers.aer import noise from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister from qiskit.tools.visualization import plot_histogram from qiskit.tools.monitor import job_monitor from qiskit import IBMQ from sympy.physics.continuum_mechanics.beam import matplotlib IBMQ.save_account('a5718e05677118aa192e1baac686bb764972b28ff18f673b8bffbb6834fe874227f0c794da513898589645b757366711e1f3681e70ec2f3c74197df9bc0f8ef7') IBMQ.load_accounts() IBMQ.backends() device = IBMQ.get_backend('ibmq_16_melbourne') properties = device.properties() coupling_map = device.configuration().coupling_map # Construct quantum circuit # qr = QuantumRegister(3, 'qr') # cr = ClassicalRegister(3, 'cr') # circ = QuantumCircuit(qr, cr) # circ.h(qr[0]) # circ.cx(qr[0], qr[1]) # circ.cx(qr[1], qr[2]) # circ.measure(qr, cr)
from qiskit import IBMQ IBMQ.save_account('Your_token_there', overwrite=True) """ Программа для инициализации токена на сайте IBM. """
def __init__( self, backend_name: str, hub: Optional[str] = None, group: Optional[str] = None, project: Optional[str] = None, monitor: bool = True, ): """A backend for running circuits on remote IBMQ devices. The provider arguments of `hub`, `group` and `project` can be specified here as parameters or set in the config file using :py:meth:`pytket.extensions.qiskit.set_ibmq_config`. This function can also be used to set the IBMQ API token. :param backend_name: Name of the IBMQ device, e.g. `ibmqx4`, `ibmq_16_melbourne`. :type backend_name: str :param hub: Name of the IBMQ hub to use for the provider. If None, just uses the first hub found. Defaults to None. :type hub: Optional[str], optional :param group: Name of the IBMQ group to use for the provider. Defaults to None. :type group: Optional[str], optional :param project: Name of the IBMQ project to use for the provider. Defaults to None. :type project: Optional[str], optional :param monitor: Use the IBM job monitor. Defaults to True. :type monitor: bool, optional :raises ValueError: If no IBMQ account is loaded and none exists on the disk. """ super().__init__() self._pytket_config = QiskitConfig.from_default_config_file() if not IBMQ.active_account(): if IBMQ.stored_account(): IBMQ.load_account() else: if self._pytket_config.ibmq_api_token is not None: IBMQ.save_account(self._pytket_config.ibmq_api_token) else: raise NoIBMQAccountError() provider_kwargs = {} provider_kwargs["hub"] = hub if hub else self._pytket_config.hub provider_kwargs[ "group"] = group if group else self._pytket_config.group provider_kwargs[ "project"] = project if project else self._pytket_config.project try: if any(x is not None for x in provider_kwargs.values()): provider = IBMQ.get_provider(**provider_kwargs) else: provider = IBMQ.providers()[0] except qiskit.providers.ibmq.exceptions.IBMQProviderError as err: logging.warn( ("Provider was not specified enough, specify hub," "group and project correctly (check your IBMQ account).")) raise err self._backend: "_QiskIBMQBackend" = provider.get_backend(backend_name) self._config: "QasmBackendConfiguration" = self._backend.configuration( ) self._gate_set: Set[OpType] # simulator i.e. "ibmq_qasm_simulator" does not have `supported_instructions` # attribute self._gate_set = _tk_gate_set(self._backend) self._mid_measure = self._config.simulator or self._config.multi_meas_enabled self._legacy_gateset = OpType.SX not in self._gate_set if self._legacy_gateset: if not self._gate_set >= { OpType.U1, OpType.U2, OpType.U3, OpType.CX }: raise NotImplementedError( f"Gate set {self._gate_set} unsupported") self._rebase_pass = RebaseIBM() else: if not self._gate_set >= { OpType.X, OpType.SX, OpType.Rz, OpType.CX }: raise NotImplementedError( f"Gate set {self._gate_set} unsupported") self._rebase_pass = RebaseCustom( {OpType.CX}, Circuit(2).CX(0, 1), {OpType.X, OpType.SX, OpType.Rz}, _tk1_to_x_sx_rz, ) if hasattr(self._config, "max_experiments"): self._max_per_job = self._config.max_experiments else: self._max_per_job = 1 self._characterisation: Dict[str, Any] = process_characterisation( self._backend) self._device = Device( self._characterisation.get("NodeErrors", {}), self._characterisation.get("EdgeErrors", {}), self._characterisation.get("Architecture", Architecture([])), ) self._monitor = monitor self._MACHINE_DEBUG = False
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister # from qiskit import execute from qiskit import IBMQ # token_string = 'abc123...321cba' IBMQ.save_account('abc123...321cba') # Sets a Quantum Register with n qubits qr = QuantumRegister(3) # this case - 3 qubits # Setup a Classical Register with n bits cr = ClassicalRegister(3) # 3 bits # In order to have a Quantum Circuit circuit = QuantumCircuit(qr, cr) # Quantum gate: CNOT # Controlled NOT gate from qubit 0 to qubit 1 circuit.cx(qr[0], qr[1]) print('You setup your Controlled NOT gate, now go solve challenging problems!')
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister from qiskit import BasicAer from qiskit import execute from qiskit import IBMQ # Solo es preciso la primera vez IBMQ.save_account("3c999a701a95c71f427401a4fae986b7eae6a2366e45126fc15ad970849a0d98f0eff6d72b8edfdaf402101541b5076caef0c582d43b4bed78864a6121a400cc") IBMQ.load_accounts() quantum_register = QuantumRegister(1) classical_register = ClassicalRegister(1) circuit = QuantumCircuit(quantum_register, classical_register) circuit.h(quantum_register[0]) circuit.measure(quantum_register, classical_register) from qiskit.tools.monitor import job_monitor from qiskit.providers.ibmq import least_busy # Antes se elegían por nombre; ahora por objeto large_enough_devices = IBMQ.backends(filters=lambda x: x.configuration().n_qubits > 4 and not x.configuration().simulator) backend = least_busy(large_enough_devices) print(backend) job_exp = execute(circuit, backend=backend, shots=1000) # Este componente no existía y había que hacer a mano tanto la gestión de los errores HTTP como de lectura job_monitor(job_exp)
from async_job.api.object_store import ObjectStore from qiskit import * from qiskit import IBMQ import json from client import QobjEncoder from qiskit.compiler import transpile, assemble from qiskit.qobj.qasm_qobj import QasmQobj as QasmQobj import os token = os.getenv('BACKEND_TOKEN') IBMQ.save_account(token) IBMQ.load_account() # Load account from disk print(IBMQ.providers()) # List all available providers provider = IBMQ.get_provider(hub='ibm-q') IBMQ.get_provider(group='open') print("The backends are:") print(provider.backends()) print("Selecting backend ibmq_qasm_simulator...") backend = provider.get_backend('ibmq_qasm_simulator') print(backend) #Asynchronous using run qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) mapped_circuit = transpile(qc, backend=backend) qobj = assemble(mapped_circuit, backend=backend, shots=1024)
'shots': 1024, 'depth': 2, 'seed': 10598, 'local': False, 'qbits': 5, 'records': 10 } if config['local']: config['server'] = 'qasm_simulator' else: config['qbits'] = servers[config['server']] data = json.load(open('data' + str(config['qbits']) + '.json', 'r')) IBMQ.save_account(config['token']) if config['local']: IBMQ.load_accounts(hub=None) feature_map = SecondOrderExpansion(feature_dimension=config['qbits'], depth=config['depth'], entanglement=config['entanglement']) qsvm = QSVM(feature_map, data["train"], data["test"]) backend = BasicAer.get_backend(config['server']) quantum_instance = QuantumInstance(backend, shots=config['shots'], seed_transpiler=config['seed']) result = qsvm.run(quantum_instance) print(result) else: IBMQ.load_accounts(hub=None) feature_map = SecondOrderExpansion(feature_dimension=config['qbits'],
from qiskit.visualization import plot_gate_map from qiskit.visualization import plot_error_map import qiskit.pulse.pulse_lib as pulse_lib from qiskit.exceptions import QiskitError #import PyQt5 #import os #import PySide2 #dirname = os.path.dirname(PySide2.__file__) #plugin_path = os.path.join(dirname, 'plugins', 'platforms') #os.environ['QT_QPA_PLATFORM_PLUGIN_PATH'] = plugin_path #from PySide2.QtWidgets import * IBMQ.save_account( 'e7b72db6919022a00d9a75557392311954b58280de131c451c9939ccb701b69a6d0d63e3fb912f086723d8cdcaf45c7f710d4c3ab1930c4df1a13768ad476202' ) IBMQ.load_account() from datetime import datetime def get_unique_backends(): """Gets the unique backends that are available. Returns: list: Unique available backends. Raises: QiskitError: No backends available. ImportError: If qiskit-ibmq-provider is not installed """
circuit.cx(0, 2) circuit.u1(pi/2, 2) circuit.cx(0,2) circuit.u1(pi/4, 1) circuit.u1(pi/8, 2) circuit.cx(1,2) circuit.u1(-pi/4,2) circuit.cx(1,2) circuit.u1(pi/4,2) circuit.h(2) circuit.measure(list(range(0,4)), list(range(0,4))) circuit.draw(output="mpl") from qiskit.tools.monitor import job_monitor from qiskit import IBMQ IBMQ.save_account("token") backend = provider.get_backend("ibmq_london") job = q.execute(circuit, backend=backend, shots=500) job_monitor(job) from qiskit.visualization import plot_histogram from matplotlib import style style.use("dark_background") # Dark theme is very cool. result = job.result() counts = result.get_counts(circuit) v = plot_histogram([counts], legend=['Device']) # Save v as png etc etc etc.
print("State vector: {}".format(statevector.real)) np.savetxt("phi_fourier.txt", statevector, fmt='%1.5f %1.5f') fig1 = plt.bar(np.arange(np.power(2, n_qubits)), np.power(statevector.real, 2)) plt.xlabel("Probabilities") plt.ylim(0, 0.01) plt.savefig("state.jpg") qc.measure(np.arange(n_qubits), np.arange(n_qubits)) num_medidas = 1500 backend1 = Aer.get_backend('qasm_simulator') result = execute(qc, backend=backend1, shots=num_medidas).result() counts = result.get_counts(qc) print("Counts: {}".format(counts)) """ IBMQ.save_account('bc0221c2c435408a718744a0e3388325cd4241375e15beefb8909a759a28201db7c6a425e8d07e09e54105e373aceccb175fa8eb46700b4db88ac50dbdc6fa84') provider = IBMQ.load_account() backend2 = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= n_qubits and not b.configuration().simulator and b.status().operational==True)) result = execute(qc, backend=backend2, shots=num_medidas).result() counts = result.get_counts(qc) print("Counts: {}".format(counts)) """ mediciones = np.zeros([num_medidas, 1]) num_medidas = 0 for medida, cantidad in counts.items(): mediciones[num_medidas:num_medidas + cantidad] = medida num_medidas += cantidad np.random.shuffle(mediciones) np.savetxt("data_fourier.txt", mediciones, fmt='%0{}i'.format(n_qubits))
import qiskit from qiskit import IBMQ IBMQ.save_account('key') qiskit.__qiskit_version__ # qiskit # python # sha256 # WeGo_Delta import hashlib y = '23dc4da786eff8147c4e72b9807785afee48bb' password = ["1004"] #binarizes def main(): thash = "1004" thashd = thash.encode() hash = hashlib.sha256(thashd) hexa = hash.hexdigest() return hexa mainHs = main() ' '.join(format(ord(x), 'b') for x in mainHs) binary = ' '.join(format(ord(x), 'b') for x in mainHs)
def qaoa(error_correct=False): API_TOKEN = '7cf33cd2f0d7044af8518c33321fa74d7380d3ba58d08b271404e8226aa1f5490818ba86e1635f89e6c3cfbf10aa091ff04c1f5ff61f0f391ed780b4484e0b18' # initialize qiskit IBMQ.save_account(API_TOKEN) provider = IBMQ.load_account() print(provider.backends()) backend = provider.backends.ibmq_16_melbourne # initialize qubits with architecture in mind qubits = [cirq.GridQubit(1, 4), cirq.GridQubit(2, 4),\ cirq.GridQubit(3, 4)] if error_correct: error_qubits = [cirq.GridQubit(3, 4), cirq.GridQubit(3, 3),\ cirq.GridQubit(3, 2), cirq.GridQubit(4, 3)] # initialize variables beta = math.pi / 2 gamma = math.pi / 2 graph = nx.Graph() graph.add_edge(0, 1) graph.add_edge(1, 2) graph.add_edge(2, 0) # construct circuit circuit = cirq.Circuit() # error correction setup. error correct qubit (2,3) if error_correct: circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])]) circuit.append([cirq.H(q) for q in qubits]) circuit.append([ cirq.ZZPowGate(exponent=2 * gamma / math.pi, global_shift=-0.5).on(qubits[0], qubits[1]) ]) circuit.append([ cirq.ZZPowGate(exponent=2 * gamma / math.pi, global_shift=-0.5).on(qubits[1], qubits[2]) ]) circuit.append([cirq.SWAP(qubits[1], qubits[2])]) circuit.append([ cirq.ZZPowGate(exponent=2 * gamma / math.pi, global_shift=-0.5).on(qubits[0], qubits[1]) ]) circuit.append([cirq.SWAP(qubits[1], qubits[2])]) circuit.append([cirq.rx(2 * beta).on_each(*qubits)]) # error detection and correction if error_correct: circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(error_qubits[1], error_qubits[2])]) circuit.append([cirq.SWAP(error_qubits[3], error_qubits[1])]) circuit.append([cirq.CNOT(qubits[2], error_qubits[1])]) circuit.append([cirq.CNOT(error_qubits[0], error_qubits[1])]) circuit.append([cirq.SWAP(error_qubits[1], error_qubits[3])]) circuit.append( [cirq.measure(error_qubits[2]), cirq.measure(error_qubits[3])]) circuit.append( [cirq.CCNOT(qubits[2], error_qubits[1], error_qubits[0])]) circuit.append([cirq.measure(*qubits)]) # export to qasm qasm_str = circuit.to_qasm() # import qiskit from qasm qiskit_circuit = qiskitqc.from_qasm_str(qasm_str) # run qiskit transpiled = transpile(qiskit_circuit, backend) qobj = assemble(transpiled, backend, shots=100) job = backend.run(qobj) print(job.job_id()) result = job.result() counts = result.get_counts() delayed_result = backend.retrieve_job(job.job_id()).result() delayed_counts = delayed_result.get_counts() print(counts) print(delayed_counts)
i = 1 # Start from 1, as it would be dictionary accessed by result state length for q_list in qubits_lists: filters[i] = generate_error_mitigation_filter(q_list, noise_model) i += 1 return filters def generate_error_mitigation_filter(q_list, noise_model): backend = get_sim_backend_from_name("qasm_simulator") qr = QuantumRegister(5) meas_cals, state_labels = complete_meas_cal(qubit_list=q_list, qr=qr) calibration_job = execute(meas_cals, backend=backend, shots=8192, noise_model=noise_model) cal_results = calibration_job.result() meas_fitter = CompleteMeasFitter(cal_results, state_labels) em_filter = meas_fitter.filter return em_filter def draw_circuit(circuit, file_name='my_circuit.png'): circuit.draw(output='mpl', filename=file_name) IBMQ.save_account(Qconfig.APItoken, overwrite=True) acc = IBMQ.load_account() acc.credentials
from decouple import config from qiskit import IBMQ from datetime import datetime def pdt(): print(datetime.now()) def interim_result_callback(job_id, interim_result): print(f"interim result: {interim_result}") IBMQ.save_account(config('IBM_API_KEY'), overwrite=True) IBMQ.load_account() IBMQ.providers() provider = IBMQ.get_provider(hub='strangeworks-hub', group='science-team', project='science-test') print(provider.backends()) if provider.has_service('runtime'): pdt() provider.runtime.pprint_programs() program = provider.runtime.program('sample-program') print(program) backend = provider.get_backend('ibmq_montreal') program_inputs = {'iterations': 3} options = {'backend_name': backend.name()} job = provider.runtime.run(program_id="sample-program",
from functions import QuantumNeuralNetwork, EffectiveDimension from qiskit.aqua import QuantumInstance from qiskit import IBMQ, Aer from qiskit.providers.aer.noise.noise_model import NoiseModel import numpy as np from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes TOKEN = 'insert token here' IBMQ.save_account(TOKEN, overwrite=True) provider = IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q-internal', group='deployed', project='default') backend_name = 'ibmq_montreal' backend_ibmq = provider.get_backend(backend_name) properties = backend_ibmq.properties() coupling_map = backend_ibmq.configuration().coupling_map noise_model = NoiseModel.from_backend(properties) layout = [3, 5, 8, 11, 14, 13, 12, 10] # might need to change qi_ibmq_noise_model = QuantumInstance(backend=Aer.get_backend('qasm_simulator'), noise_model=noise_model, optimization_level=0, shots=8000, seed_transpiler=2, initial_layout=layout) qi = qi_ibmq_noise_model compile_config = {'initial_layout': layout, 'seed_transpiler': 2, 'optimization_level': 3 } n = [1000, 2000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000, 10000000, 10000000000, 10000000000000] qubits = 8 fm = ZZFeatureMap(qubits, reps=2, entanglement='full') varform = RealAmplitudes(qubits, reps=9, entanglement='full') qnet = QuantumNeuralNetwork(fm, varform) ed = EffectiveDimension(qnet, 100, 100)
def load_IBMQ(token, hub, group, project): IBMQ.save_account(token, overwrite=True) IBMQ.load_account() provider = IBMQ.get_provider(hub=hub, group=group, project=project) return provider
# # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory # of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. # # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. """Example used in the README. In this example a Bell state is made.""" # Import Qiskit from qiskit import QuantumCircuit from qiskit import execute, IBMQ, BasicAer from qiskit.providers.ibmq import least_busy provider = IBMQ.save_account('MY_API_TOKEN', overwrite=True) # Create a Quantum Circuit qc = QuantumCircuit(2, 2) # Add a H gate on qubit 0, putting this qubit in superposition. qc.h(0) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. qc.cx(0, 1) # Add a Measure gate to see the state. qc.measure([0, 1], [0, 1]) # See a list of available local simulators print("BasicAer backends: ", BasicAer.backends()) backend_sim = BasicAer.get_backend('qasm_simulator')
# -*- coding: utf-8 -*- # @Time : 2019/1/7 9:24 # @Author : Tan Zhijie # @Email : [email protected] # @File : test01.py # @Software: PyCharm # If you want to execute your code on a quantum chip: My_token = 'f8513242b744d000bf38e991fab133505f6b8535ae48af9215f08a36c798a85446b833b7ea9045af5aea6c5a3601c5b8db43b052df88fcbce85ae833b42e4942' from qiskit import IBMQ IBMQ.save_account(My_token)
################################################################################ from __future__ import print_function import tbvaccine as tb tb.add_hook(isolate=False, show_vars=False) import numpy as np from qiskit import (IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute, transpile) ################################################################################ ################################################## ################### Token auth ################### ################################################## token_path = "../IBMQ_token" with open(token_path, "r") as file: token = file.read() IBMQ.save_account(token, overwrite=True) ################################################################################ ##################################### Main ##################################### ################################################################################ def main(): ################################################## ################## Make circuit ################## ################################################## q_alice = QuantumRegister(2, "q(alice)") q_bob = QuantumRegister(1, "q(bob)") c0 = ClassicalRegister(1) c1 = ClassicalRegister(1) c_bob = ClassicalRegister(1, "c(bob)") # c_alice = ClassicalRegister(1, "c(alice)")
# -*- coding: utf-8 -*- """ Created on Wed May 6 10:11:41 2020 @author: Ludovic """ from qiskit import * from qiskit.visualization import plot_histogram from qiskit.providers.ibmq import least_busy from qiskit import IBMQ IBMQ.save_account( 'ee21a38145df6f33181385a311fef503faacd13a50184ceb5594a846c586ce078cf8fb8f4aa2ff1f93577a38a270f19d9fa381dd5b3a3498293fd37d53f17001' ) #number of qubit nb_qubit = 3 qc = QuantumCircuit(nb_qubit) ################################# ### Step 1 ### Superposition states ################################# for i in range(0, nb_qubit, 1): qc.h(i) ################################# ### Step 2 ### Oracle #################################
tensored_meas_cal, CompleteMeasFitter, TensoredMeasFitter) from inspect import signature import sys import numpy as np import itertools import time import datetime import matplotlib.pyplot as plt import func from func import * MY_API_KEY = 'b5c51e6cadaa798d2ca5b21a97e287c2f861f054dde9ef8908feb2ff66dbcf8f6004608cb967de6edaf30ec8cf19991c09255d57bd54ae764f233b1feb4c9f52' IBMQ.save_account(MY_API_KEY) provider = IBMQ.load_account() small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits == 5 and not x.configuration().simulator) backend = least_busy(small_devices) # backend = provider.backends.ibmq_burlington simulator = Aer.get_backend('qasm_simulator') # U_f | x > | b > = | x > | b + f(x) > # preserve the state of the first n qubits # if f(x) == 0, we preserve the state of the helper qubit b # otherwise, if f(x) == 1, we invert the state of the helper qubit # U_f is just a 2^n by 2^n matrix where the "diagonal" consists of 2 by 2 blocks that are either the identity or Pauli X # the i-th diagonal block corresponds to the i-th possible n-bit input x_i to f ## it is I if f(x_i) == 0
import qiskit from qiskit import IBMQ IBMQ.save_account('18b0689cff758ba84ee019f44bfcb11e4721ff0be5bce16b73e246637bf82a5b8e9c7bf189e8b06229622d1774a372a5df841714d8836e4e971d3b24fe7a381b') IBMQ.load_account()