# Setting up the backend print("(Aer Backends)") for backend in BasicAer.backends(): print(backend.status()) qasm_simulator = BasicAer.get_backend('qasm_simulator') # Compile and run the circuit on a real device backend # See a list of available remote backends print("\n(IBMQ Backends)") for backend in provider.backends(): print(backend.status()) try: # select least busy available device and execute. least_busy_device = least_busy(provider.backends(simulator=False)) except: print("All devices are currently unavailable.") print("Running on current least busy device: ", least_busy_device) # Transpile the circuits to make them compatible with the experimental backend [qc1_new, qc2_new] = transpile(circuits=[qc1, qc2], backend=least_busy_device) print("Bell circuit before transpile:") print(qc1) print("Bell circuit after transpile:") print(qc1_new) print("Superposition circuit before transpile:") print(qc2) print("Superposition circuit after transpile:")
def test_retrieve_job_error(self, provider): """Test retrieving an invalid job.""" backends = provider.backends(simulator=False) backend = least_busy(backends) self.assertRaises(IBMQBackendError, backend.retrieve_job, 'BAD_JOB_ID')
# running the job job_sim = execute([qc1, qc2], BasicAer.get_backend('qasm_simulator')) sim_result = job_sim.result() # Show the results print(sim_result.get_counts(qc1)) print(sim_result.get_counts(qc2)) # see a list of available remote backends print("\n(IBMQ Backends)") print(IBMQ.backends()) # Compile and run on a real device backend try: # select least busy available device and execute. least_busy_device = least_busy(IBMQ.backends(simulator=False)) print("Running on current least busy device: ", least_busy_device) # running the job job_exp = execute([qc1, qc2], backend=least_busy_device, shots=1024, max_credits=10) job_monitor(job_exp) exp_result = job_exp.result() # Show the results print(exp_result.get_counts(qc1)) print(exp_result.get_counts(qc2)) except:
def test_filter_least_busy(self, qe_token, qe_url): """Test filtering by least busy function""" IBMQ.enable_account(qe_token, qe_url) backends = IBMQ.backends() filtered_backends = least_busy(backends) self.assertTrue(filtered_backends)
simulator = Aer.get_backend('qasm_simulator') # Execute and get counts result = execute(circ, simulator, shots=simulator.configuration().max_shots).result() counts = result.get_counts(circ) display( plot_histogram(counts, title='Simulated counts for ' + str(n_gates) + ' SWAP gates.')) print("Simulated SWAP counts:", counts) input("Press enter to run on an IBM Q backend...\n") # Import the least busy backend from qiskit.providers.ibmq import least_busy backend = least_busy(provider.backends(operational=True, simulator=False)) print("Least busy backend:", backend) # Execute and get counts job = execute(circ, backend, shots=backend.configuration().max_shots) job_monitor(job) nisq_result = job.result() nisq_counts = nisq_result.get_counts(circ) print("NISQ SWAP counts:", nisq_counts) display( plot_histogram(nisq_counts, title='Counts for ' + str(n_gates) + ' SWAP gates on ' + str(backend))) input("Press enter to transpile the circuit...\n") # Comparing the circuit with the transpiled circuit
circuit.h(1) circuit.cx(1,2) circuit.barrier() circuit.cx(0,1) circuit.h(0) circuit.barrier() circuit.cx(1, 2) circuit.cz(0, 2) circuit.barrier() circuit.measure([0, 1, 2], [0, 1, 2]) print(circuit) backend1 = Aer.get_backend('qasm_simulator') job1 = execute(circuit, backend=backend1, shots=1000) result1 = job1.result() measurement1 = result1.get_counts(circuit) plot_histogram(measurement1) IBMQ.save_account('bc0221c2c435408a718744a0e3388325cd4241375e15beefb8909a759a28201db7c6a425e8d07e09e54105e373aceccb175fa8eb46700b4db88ac50dbdc6fa84') provider = IBMQ.load_account() backend2 = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and not b.configuration().simulator and b.status().operational==True)) job2 = execute(circuit, backend=backend2, shots=1000) result2 = job2.result() measurement2 = result2.get_counts(circuit) plot_histogram(measurement2) plt.show()
counts = result_sim.get_counts(qc) print(counts) #Run on IBMQ from qiskit import IBMQ IBMQ.load_accounts() print("Available backends:") IBMQ.backends() from qiskit.providers.ibmq import least_busy 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("The best backend is " + backend.name()) #To run the circuit on the backend from qiskit.tools.monitor import job_monitor shots = 1024 # Number of shots to run the program (experiment); maximum is 8192 shots. max_credits = 3 # Maximum number of credits to spend on executions. job_exp = execute(qc, backend=backend, shots=shots, max_credits=max_credits) job_monitor(job_exp) result_exp = job_exp.result() counts_exp = result_exp.get_counts(qc)
def main(run_mode): # graph of city coordinates cities = np.array([[0, 0], [0, 1]]) # coordinates of the cities num_cities = len(cities) num_qubits = num_cities ** 2 # algorithm properties p = 2 # number of time steps beta = np.random.uniform(0, np.pi * 2, p) gamma = np.random.uniform(0, np.pi * 2, p) # create matrix of distances between cities distance_mat = tsp.calc_distance(cities).w # note that this method does integer distances # create mixing Hamiltonian. A city may or may not be visited in a timestep mixing_hamiltonian = reduce(lambda x, y: x + y, [pauli_x(i, 1, num_qubits) for i in range(num_qubits)]) # penalty_operators = create_weights_cost_operators(num_cities=num_cities, num_qubits=num_qubits, # dist_mat=distance_mat) penalty_operators = create_penalty_operators_for_bilocation(num_qubits=num_qubits, num_cities=num_cities, distance_mat=distance_mat) penalty_operators += create_penalty_operators_for_repetition(num_qubits=num_qubits, num_cities=num_cities, distance_mat=distance_mat) print(penalty_operators) cost_hamiltonian = penalty_operators # circuit initial state vector. All states in equal superposition init_state_vect = [1 for i in range(2 ** num_qubits)] init_state = Custom(num_qubits, state_vector=init_state_vect) # initialize quantum circuit qr = QuantumRegister(num_qubits, name='q') init_circ = init_state.construct_circuit('circuit', qr) # find optimal beta and gamma evaluate = partial(neg_evaluate_circuit, qr=qr, p=p, m_H=mixing_hamiltonian, c_H=cost_hamiltonian, init_circ=init_circ) print("Looking for optimal beta and gamma") # TODO: maybe we should use a different or faster method of finding the min? Super long even with two cities result = minimize(evaluate, np.concatenate([gamma, beta]), method='L-BFGS-B') # result = minimize(evaluate, np.concatenate([gamma, beta])) print(result) # now use the result of the gathered angles to find the answer circuit = create_circuit(qr, result['x'][:p], result['x'][p:], p, m_H=mixing_hamiltonian, c_H=cost_hamiltonian, init_circ=init_circ) if run_mode == "IBM quantum": import secrets from qiskit import IBMQ from qiskit.providers.ibmq import least_busy provider = IBMQ.enable_account(secrets.IBM_TOKEN) large_enough_devices = provider.backends(filters=lambda x: x.configuration().n_qubits > 4 and not x.configuration().simulator) backend = least_busy(large_enough_devices) print("This will be running on the IBM device " + backend.name()) else: print("Preparing to run on local simulator") backend = BasicAer.get_backend('statevector_simulator') job = execute(circuit, backend) state = np.asarray(job.result().get_statevector(circuit)) print(list_to_easier_vis(np.absolute(state)))
qc.barrier() # Measure all of the qubits in the standard basis for i in range(num_qubits): qc.measure(q[i], c[i]) ############################################################### # Set up the API and execute the program. ############################################################### try: IBMQ.load_accounts() except: print("""WARNING: There's no connection with the API for remote backends. Have you initialized a file with your personal token? For now, there's only access to local simulator backends...""") # First version: simulator sim_backend = BasicAer.get_backend('qasm_simulator') job = execute(qc, sim_backend, shots=1024) result = job.result() print('Qasm simulator : ') print(result.get_counts(qc)) # Second version: real device least_busy_device = least_busy(IBMQ.backends(simulator=False, filters=lambda x: x.configuration().n_qubits > 4)) print("Running on current least busy device: ", least_busy_device) job = execute(qc, least_busy_device, shots=1024) result = job.result() print('Physical device (%s) : ' % least_busy_device) print(result.get_counts(qc))
measure_Z.cx(qr[1], qr[3]) # We measure the circuit measure_Z.measure(qr, cr) # We add the two circuits to obtain a test result on how many possible # combinations we have and the probabilities of each combination to be # exist. These results are mearly theorethical and in a real quantum # computer, the results may vary. test_Z = qc + measure_Z # We run the circuit in the local simulator. For more information on # the simulators, please visit the Github or read the documentation. # For more, visit https://qiskit.com qk.IBMQ.load_accounts(hub=None) backend = least_busy( qk.IBMQ.backends(filters=lambda x: not x.configuration().simulator)) qjob_2 = qk.compile(test_Z, backend, shots=1024) print(qjob_2) job_2 = backend.run(qjob_2) print(job_2.status()) result_1 = job_2.result() print(result_1.get_counts(test_Z)) plot_histogram(result_1.get_counts(test_Z)).savefig("test_Z.png") # ===================================================================== # Another example where we use the same starting quantum circuit qc
import qiskit from qiskit import Aer, QuantumRegister, ClassicalRegister, QuantumCircuit, IBMQ from qiskit.providers import JobStatus from qiskit.providers.ibmq import least_busy from qiskit.exceptions import QiskitError from qiskit.compiler import transpile, assemble from Scripts.ibmq_account import account_key IBMQ.enable_account(account_key) q_device = IBMQ.backends( filters=lambda x: x.configuration().n_qubits == 5 and x.configuration( ).memory and not x.configuration().simulator) real_backend = least_busy(q_device) real_name = real_backend.name() sim_backend = Aer.get_backend('qasm_simulator') class CircuitBuilder(): def __init__(self, register_size): self.size = register_size self.qr = QuantumRegister(register_size) self.cr = ClassicalRegister(register_size) self.circuit = QuantumCircuit(self.qr, self.cr) def add_operation(self, op, backend): op_name = op[0] if op_name == 'h': self.circuit.h(self.qr[op[1]]) elif op_name == 'x': self.circuit.x(self.qr[op[1]])
# Apply the quantum gates circuit.h(q[0]) circuit.cx(q[0], q[1]) # Finish off with the measurements circuit.measure(q, c) # Draw the circuit circuit.draw(output="mpl") # First, simulate the circuit simulator = Aer.get_backend('qasm_simulator') job = execute(circuit, backend=simulator, shots=1024) result = job.result() # Then, plot a histogram of the results counts = result.get_counts(circuit) plot_histogram(counts) # Next, find the least-busy IBM device lb_device = least_busy(IBMQ.backends()) # And run the circuit on that device job = execute(circuit, backend=lb_device, shots=1024) job_monitor(job) result = job.result() # Finally, plot a histogram of the results counts = result.get_counts(circuit) plot_histogram(counts)
# Authenticate for access to remote backends try: provider = IBMQ.load_account() except: print("""WARNING: No valid IBMQ credentials found on disk. You must store your credentials using IBMQ.save_account(token, url). For now, there's only access to local simulator backends...""") exit(0) # see a list of available remote backends ibmq_backends = provider.backends() print("Remote backends: ", ibmq_backends) # Compile and run the Quantum Program on a real device backend # select those with at least 2 qubits try: least_busy_device = least_busy( provider.backends(filters=lambda x: x.configuration().n_qubits >= 2, simulator=False)) except: print("All devices are currently unavailable.") print("Running on current least busy device: ", least_busy_device) #running the job job_exp = execute(qc, least_busy_device, shots=1024, max_credits=10) result_exp = job_exp.result() # Show the results print('Counts: ', result_exp.get_counts(qc))
def leastBusy(minQubits, provider): large_enough_devices = provider.backends(filters=lambda x: x.configuration( ).n_qubits > minQubits and not x.configuration().simulator) leastBusybackend = least_busy(large_enough_devices) return leastBusybackend
state = key print("The Quantum 8-ball says:") if state == '000': print('It is certain.') elif state == '001': print('Without a doubt.') elif state == '010': print('Yes - deinitely.') elif state == '011': print('Most likely.') elif state == '100': print("Don't count on it.") elif state == '101': print('My reply is no.') elif state == '110': print('Very doubtful.') else: print('Concentrate and ask again.') # Execute the job on the simulator. job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1) result = job.result().get_counts(qc) answer(result) # Execute the program on a real quantum computer. backend = least_busy(IBMQ.backends(simulator=False)) print("Running on", backend.name()) job = execute(qc, backend, shots=1) result = job.result().get_counts(qc) answer(result)
for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog if __name__ == '__main__': a = "111" b = "0" f = lambda rep: bitwise_xor(bitwise_dot(a, rep), b) prog = make_circuit(4,f) IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q') provider.backends() backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 2 and not x.configuration().simulator and x.status().operational == True)) sample_shot =8000 info = execute(prog, backend=backend, shots=sample_shot).result().get_counts() backend = FakeVigo() circuit1 = transpile(prog,backend,optimization_level=2) writefile = open("../data/startQiskit_QC2686.csv","w") print(info,file=writefile) print("results end", file=writefile) print(circuit1.__len__(),file=writefile) print(circuit1,file=writefile) writefile.close()
# Loading your IBM Q account(s) provider = IBMQ.load_account() from math import pi,sqrt import numpy as np from matplotlib import cm import matplotlib.pyplot as plt import qiskit qiskit.__qiskit_version__ # use simulator to learn more about entangled quantum states where possible sim_backend = BasicAer.get_backend('qasm_simulator') sim_shots = 8192 # use device to test entanglement device_shots = 1024 device_backend = least_busy(IBMQ.get_provider().backends(operational=True,simulator=False)) print(the backend is " + device_backend.name()) # Creating registers q = QuantumRegister(2) c = ClassicalRegister(2) # quantum circuit to make an entangled bell state bell = QuantumCircuit(q, c) bell.h(q[0]) bell.cx(q[0], q[1]) # quantum circuit to measure q in the Z basis measureZZ = QuantumCircuit(q, c) measureZZ.measure(q[0], c[0]) measureZZ.measure(q[1], c[1]) bellZZ = bell+measureZZ