def a_8(): qreg = qk.QuantumRegister(8) creg = qk.ClassicalRegister(3) qc = qk.QuantumCircuit(qreg, creg) # initialize qc.x(7) qc.h([0, 1, 2]) # multiplier qc.cx(2, 7) qc.cx(2, 4) inv_qft = qft.qft(3) qc.append(inv_qft, qargs=qreg[:3]) for i in range(3): qc.measure(i, i) # qc.draw(output='mpl') # plt.savefig('../presentation/20200528/figs/11circuit.pdf') return qc
def test_qasm_reset_measure(self): """counts from a qasm program with measure and reset in the middle""" qr = qiskit.QuantumRegister(3) cr = qiskit.ClassicalRegister(3) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) circuit.reset(qr[0]) circuit.cx(qr[1], qr[2]) circuit.t(qr) circuit.measure(qr[1], cr[1]) circuit.h(qr[2]) circuit.measure(qr[2], cr[2]) sim_cpp = qiskit.providers.aer.QasmSimulator() sim_py = qiskit.providers.builtinsimulators.QasmSimulatorPy() shots = 1000 result_cpp = execute(circuit, sim_cpp, shots=shots, seed=1).result() result_py = execute(circuit, sim_py, shots=shots, seed=1).result() counts_cpp = result_cpp.get_counts() counts_py = result_py.get_counts() self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.06)
def test_compile_run_remote(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): """Test Compiler and run remote. If all correct some should exists. """ provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project) backend = provider.available_backends({'simulator': True})[0] qubit_reg = qiskit.QuantumRegister(2, name='q') clbit_reg = qiskit.ClassicalRegister(2, name='c') qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) qobj = transpiler.compile(qc, backend) job = backend.run(qobj) result = job.result(timeout=20) self.assertIsInstance(result, Result)
def __init__(self, n_work, n_simulation, delta=1, g=1, dt=0.005, Emax=500): """ Input: input: n_work (int) - Number of work-qubits n_simulation (int) - Number of simulation qubits delta (float) - parameter in the one-body hamiltonian g (float) - parameter in the two-body hamiltonian dt (float) - timestep in the phase estimation algorithm Emax (float) - subtracted from the hamiltonian to yield the whole eigenvalue sprectrum. """ self.n_work = n_work self.n_simulation = n_simulation self.n_qubits = n_work + n_simulation + 1 self.qb = qk.QuantumRegister(self.n_qubits) self.cb = qk.ClassicalRegister(self.n_qubits) self.qz = qk.QuantumCircuit(self.qb, self.cb) self.delta = delta self.g = g self.dt = dt self.Emax = Emax
def test_average_data_matrix_observable(self): """Test average_data for matrix observable input.""" qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) qc = qiskit.QuantumCircuit(qr, cr, name="qc") qc.h(qr[0]) qc.cx(qr[0], qr[1]) qc.measure(qr[0], cr[0]) qc.measure(qr[1], cr[1]) shots = 10000 backend = BasicAer.get_backend("qasm_simulator") result = qiskit.execute(qc, backend, shots=shots).result() counts = result.get_counts(qc) observable = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]] mean_zz = average_data(counts=counts, observable=observable) observable = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]] mean_zi = average_data(counts, observable) observable = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]] mean_iz = average_data(counts, observable) self.assertAlmostEqual(mean_zz, 1, places=1) self.assertAlmostEqual(mean_zi, 0, places=1) self.assertAlmostEqual(mean_iz, 0, places=1)
def test_compile_two_run_remote(self, qe_token, qe_url): """Test Compiler and run two circuits. If all correct some should exists. """ register(qe_token, qe_url) backend = available_backends({'local': False, 'simulator': True})[0] backend = get_backend(backend) qubit_reg = qiskit.QuantumRegister(2, name='q') clbit_reg = qiskit.ClassicalRegister(2, name='c') qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra") qc_extra.measure(qubit_reg, clbit_reg) qobj = transpiler.compile([qc, qc_extra], backend, seed=TestCompiler.seed) job = backend.run(qobj) result = job.result() self.assertIsInstance(result, Result)
def test_mapping_already_satisfied(self): """Test compiler doesn't change circuit already matching backend coupling """ backend = FakeBackEnd() qr = qiskit.QuantumRegister(16) cr = qiskit.ClassicalRegister(16) qc = qiskit.QuantumCircuit(qr, cr) qc.h(qr[1]) qc.x(qr[2]) qc.x(qr[3]) qc.x(qr[4]) qc.cx(qr[1], qr[2]) qc.cx(qr[2], qr[3]) qc.cx(qr[3], qr[4]) qc.cx(qr[3], qr[14]) qc.measure(qr, cr) qobj = transpiler.compile(qc, backend) compiled_ops = qobj.experiments[0].instructions for operation in compiled_ops: if operation.name == 'cx': self.assertIn(operation.qubits, backend.configuration['coupling_map'])
def test_snapshot(self): """snapshot a bell state in the middle of circuit""" basis_gates = ['cx', 'u1', 'u2', 'u3', 'snapshot'] qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) circuit.snapshot('3') circuit.cx(qr[0], qr[1]) circuit.h(qr[1]) sim = qiskit.providers.aer.StatevectorSimulator() result = execute(circuit, sim, basis_gates=basis_gates).result() # TODO: rely on Result.get_statevector() postprocessing rather than manual snapshots = result.data(0)['snapshots']['statevector']['3'] snapshot = format_statevector(snapshots[0]) target = [0.70710678 + 0.j, 0. + 0.j, 0. + 0.j, 0.70710678 + 0.j] fidelity = state_fidelity(snapshot, target) self.assertGreater( fidelity, self._desired_fidelity, "snapshot has low fidelity{0:.2g}.".format(fidelity))
def test_mapping_already_satisfied(self): """Test compiler doesn't change circuit already matching backend coupling """ backend = FakeBackEnd() q = qiskit.QuantumRegister(16) c = qiskit.ClassicalRegister(16) qc = qiskit.QuantumCircuit(q, c) qc.h(q[1]) qc.x(q[2]) qc.x(q[3]) qc.x(q[4]) qc.cx(q[1], q[2]) qc.cx(q[2], q[3]) qc.cx(q[3], q[4]) qc.cx(q[3], q[14]) qc.measure(q, c) qobj = transpiler.compile(qc, backend) compiled_ops = qobj['circuits'][0]['compiled_circuit']['operations'] for op in compiled_ops: if op['name'] == 'cx': self.assertIn(op['qubits'], backend.configuration['coupling_map'])
def test_average_data_dict_observable(self): """Test average_data for dictionary observable input""" qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) qc = qiskit.QuantumCircuit(qr, cr, name="qc") qc.h(qr[0]) qc.cx(qr[0], qr[1]) qc.measure(qr[0], cr[0]) qc.measure(qr[1], cr[1]) shots = 10000 backend = BasicAer.get_backend('qasm_simulator') result = qiskit.execute(qc, backend, shots=shots).result() counts = result.get_counts(qc) observable = {"00": 1, "11": 1, "01": -1, "10": -1} mean_zz = average_data(counts=counts, observable=observable) observable = {"00": 1, "11": -1, "01": 1, "10": -1} mean_zi = average_data(counts, observable) observable = {"00": 1, "11": -1, "01": -1, "10": 1} mean_iz = average_data(counts, observable) self.assertAlmostEqual(mean_zz, 1, places=1) self.assertAlmostEqual(mean_zi, 0, places=1) self.assertAlmostEqual(mean_iz, 0, places=1)
def run(): qr =qk.QuantumRegister(3) cr = qk.ClassicalRegister(3) qc= qk.QuantumCircuit(qr,cr) #Creating the Hadamard State qc.h(qr[0]) qc.h(qr[1]) # Circuit for I(theta) starts here #qc.x(qr[0]) #qc.x(qr[1]) angles = [pi/2, 0, pi/2, 0] #pi/4=0.7853 qc.cu3(angles[0],0,0,qr[0],qr[2]) qc.cx(qr[0],qr[1]) qc.cu3(-angles[0],0,0,qr[1],qr[2]) qc.cx(qr[0],qr[1]) qc.cu3(angles[0],0,0,qr[0],qr[2]) ### qc.barrier(qr) qc.measure(qr,cr) # In[41]: backend_sim = Aer.get_backend('qasm_simulator') job_sim = execute(qc, backend_sim, shots=10000) result_sim = job_sim.result() # In[42]: counts = result_sim.get_counts(qc) print(counts) ### """
def not_gate(input_bit): q = qiskit.QuantumRegister(1) # a qubit to encode and manipulate the input c = qiskit.ClassicalRegister(1) # a bit to store the output qc = qiskit.QuantumCircuit(q, c) # initialize the bit with respect to the input bit if input_bit == '1': qc.x(q[0]) # execute NOT qc.x(0) # extract output qc.measure(q[0], c[0]) # run the circuit job = qiskit.execute(qc, backend, shots=1) output = list(job.result().get_counts().keys())[0] return output
def test_execute_remote(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): """Test Execute remote. If all correct some should exists. """ provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project) backend = provider.available_backends({'simulator': True})[0] qubit_reg = qiskit.QuantumRegister(2) clbit_reg = qiskit.ClassicalRegister(2) qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg) qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) job = execute(qc, backend) results = job.result() self.assertIsInstance(results, Result)
def t1_circuits(num_of_gates, gate_time, qubits): """ Generates circuit for T1 measurement. Each circuit consists of an X gate, followed by a sequence of identity gates. Args: num_of_gates (list of integers): the number of identity gates in each circuit. Must be in an increasing order. gate_time (float): time of running a single gate. qubits (list of integers): indices of the qubits whose T1 are to be measured. Returns: A list of QuantumCircuit xdata: a list of delay times """ xdata = gate_time * num_of_gates qr = qiskit.QuantumRegister(max(qubits) + 1) cr = qiskit.ClassicalRegister(len(qubits)) circuits = [] for circ_index, circ_length in enumerate(num_of_gates): circ = qiskit.QuantumCircuit(qr, cr) circ.name = 't1circuit_' + str(circ_index) + '_0' for _, qubit in enumerate(qubits): circ.x(qr[qubit]) circ = pad_id_gates(circ, qr, qubit, circ_length) circ.barrier(qr) for qind, qubit in enumerate(qubits): circ.measure(qr[qubit], cr[qind]) circuits.append(circ) return circuits, xdata
def test_noise(self): """turn on a pauli x noise for qubits 0 and 2""" qr = qiskit.QuantumRegister(3) cr = qiskit.ClassicalRegister(3) circuit = qiskit.QuantumCircuit(qr, cr) circuit.iden(qr[0]) circuit.noise(0) circuit.iden(qr[1]) circuit.noise(1) circuit.iden(qr[2]) circuit.measure(qr, cr) config = { 'noise_params': { 'id': {'p_pauli': [1.0, 0.0, 0.0]} } } sim = Aer.get_backend('qasm_simulator') shots = 1000 result = execute(circuit, sim, config=config, shots=shots).result() counts = result.get_counts() target = {'101': shots} self.assertEqual(counts, target)
def test_qasm(self, qe_token, qe_url): """counts from a GHZ state""" qiskit.IBMQ.use_account(qe_token, qe_url) qr = qiskit.QuantumRegister(3) cr = qiskit.ClassicalRegister(3) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) circuit.cx(qr[1], qr[2]) circuit.measure(qr, cr) sim_cpp = 'local_qasm_simulator_cpp' sim_py = 'local_qasm_simulator_py' sim_ibmq = 'ibmq_qasm_simulator' shots = 2000 result_cpp = execute(circuit, sim_cpp, shots=shots).result() result_py = execute(circuit, sim_py, shots=shots).result() result_ibmq = execute(circuit, sim_ibmq, shots=shots).result() counts_cpp = result_cpp.get_counts() counts_py = result_py.get_counts() counts_ibmq = result_ibmq.get_counts() self.assertDictAlmostEqual(counts_cpp, counts_py, shots*0.05) self.assertDictAlmostEqual(counts_py, counts_ibmq, shots*0.05)
def test_to_qiskit_assign_qregs_and_cregs(qreg_sizes, measure, flip_creg): nbits = sum(qreg_sizes) cirq_circuit = cirq.testing.random_circuit( nbits, n_moments=5, op_density=1, random_state=10 ) if measure: cirq_circuit.append(cirq.measure_each(*cirq_circuit.all_qubits())) qregs = [qiskit.QuantumRegister(s) for s in qreg_sizes] cregs = [qiskit.ClassicalRegister(s) for s in qreg_sizes] if flip_creg: cregs = cregs[::-1] qiskit_circuit = to_qiskit(cirq_circuit, qregs=qregs, cregs=cregs) assert qiskit_circuit.qregs == qregs assert qiskit_circuit.cregs == cregs cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(from_qiskit(qiskit_circuit)), cirq.unitary(cirq_circuit), atol=1e-5, )
def test_qasm(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): """counts from a GHZ state""" register(QE_TOKEN, QE_URL, hub, group, project) q = qiskit.QuantumRegister(3) c = qiskit.ClassicalRegister(3) circ = qiskit.QuantumCircuit(q, c) circ.h(q[0]) circ.cx(q[0], q[1]) circ.cx(q[1], q[2]) circ.measure(q, c) sim_cpp = 'local_qasm_simulator_cpp' sim_py = 'local_qasm_simulator_py' sim_ibmq = 'ibmq_qasm_simulator' shots = 2000 result_cpp = execute(circ, sim_cpp, shots=shots).result() result_py = execute(circ, sim_py, shots=shots).result() result_ibmq = execute(circ, sim_ibmq, shots=shots).result() counts_cpp = result_cpp.get_counts() counts_py = result_py.get_counts() counts_ibmq = result_ibmq.get_counts() self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.05) self.assertDictAlmostEqual(counts_py, counts_ibmq, shots * 0.05)
def test_compile_remote(self, QE_TOKEN, QE_URL): """Test Compiler remote. If all correct some should exists. """ provider = IBMQProvider(QE_TOKEN, QE_URL) backend = lowest_pending_jobs( provider.available_backends({ 'local': False, 'simulator': False })) qubit_reg = qiskit.QuantumRegister(2, name='q') clbit_reg = qiskit.ClassicalRegister(2, name='c') qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) qobj = qiskit._compiler.compile(qc, backend) # FIXME should test against the qobj when defined self.assertEqual(len(qobj), 3)
def __init__(self, dag_circuit, parameters, initial_mapping): """ :param dag_circuit: :param parameters: :param initial_mapping: """ """ The resulting circuit has a maximum number of qubits of the NISQ chip """ self.quantum_reg = qiskit.QuantumRegister(parameters["nisq_qubits"], "q") self.classic_reg = qiskit.ClassicalRegister(parameters["nisq_qubits"], "c") ''' Current logical qubit position on physical qubits ''' """ Returns an int-to-int map: logical qubit @ physical qubit map There is something similar in Coupling, but I am not using it """ self.pos_circuit_to_phys = {} for circ_qubit in range(dag_circuit.num_qubits()): # configuration[i] = nrq - 1 - i # qubit i@i self.pos_circuit_to_phys[circ_qubit] = initial_mapping[ circ_qubit] # qubit i@i # print("current circ2phys: ", self.pos_circuit_to_phys) """ The reverse dictionary of current_positions """ self.pos_phys_to_circuit = { k: -1 for k in range(parameters["nisq_qubits"]) } for k, v in self.pos_circuit_to_phys.items(): self.pos_phys_to_circuit[v] = k
def to_qiskit(self): """Converts the circuit to a qiskit QuantumCircuit object.""" qiskit_circuit = qiskit.QuantumCircuit() # New qiskit circuit object qreg = None creg = None if ( self.qubits != None and self.qubits != [] ): # If there are qubits in the circuit, add them to the new qiskit circuit max_qindex = max([q.index for q in self.qubits]) qreg = qiskit.QuantumRegister(max_qindex + 1, "q") creg = qiskit.ClassicalRegister(max_qindex + 1, "c") qiskit_circuit.add_register(qreg) qiskit_circuit.add_register(creg) if self.gates != None: for gate in self.gates: qiskit_gate_data = gate.to_qiskit( qreg, creg ) # provide the gate conversion with the associated QuantumRegister N = len( qiskit_gate_data ) # total number of entries in the list (which is 3x the number of elementary gates) if N % 3 != 0: raise ValueError( "The number of entries in qiskit_gate_data is {} which is not a multiple of 3".format( N ) ) for index in np.linspace(0, N - 3, N // 3): qiskit_circuit.append( qiskit_gate_data[int(index)], qargs=qiskit_gate_data[int(index) + 1], cargs=qiskit_gate_data[int(index) + 2], ) return qiskit_circuit
def test_basic_reordering(self, qe_token, qe_url): """a simple reordering within a 2-qubit register""" sim, real = self._get_backends(qe_token, qe_url) if not sim or not real: raise unittest.SkipTest('no remote device available') qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.measure(qr[0], cr[1]) circuit.measure(qr[1], cr[0]) shots = 2000 qobj_real = compile(circuit, real) qobj_sim = compile(circuit, sim) result_real = real.run(qobj_real).result(timeout=600) result_sim = sim.run(qobj_sim).result(timeout=600) counts_real = result_real.get_counts() counts_sim = result_sim.get_counts() self.log.info(counts_real) self.log.info(counts_sim) threshold = 0.1 * shots self.assertDictAlmostEqual(counts_real, counts_sim, threshold)
def tensored_calib_circ_creation(): """ create tensored measurement calibration circuits and a GHZ state circuit for the tests Returns: QuantumCircuit: the tensored measurement calibration circuit list[list[int]]: the mitigation pattern QuantumCircuit: ghz circuit with 5 qubits (3 are used) """ mit_pattern = [[2], [4, 1]] qr = qiskit.QuantumRegister(5) # Generate the calibration circuits meas_calibs, mit_pattern = tensored_meas_cal(mit_pattern, qr=qr) cr = qiskit.ClassicalRegister(3) ghz_circ = qiskit.QuantumCircuit(qr, cr) ghz_circ.h(mit_pattern[0][0]) ghz_circ.cx(mit_pattern[0][0], mit_pattern[1][0]) ghz_circ.cx(mit_pattern[0][0], mit_pattern[1][1]) ghz_circ.measure(mit_pattern[0][0], cr[0]) ghz_circ.measure(mit_pattern[1][0], cr[1]) ghz_circ.measure(mit_pattern[1][1], cr[2]) return meas_calibs, mit_pattern, ghz_circ
def create_circuit_one_create(run_sequential_experiment=False, list_of_cnots=[]): qr = qiskit.QuantumRegister(14) cr = qiskit.ClassicalRegister(14) qc = qiskit.QuantumCircuit(qr, cr) ones = [4, 5, 6, 11, 12, 13] for q in ones: qc.x(qr[q]) qc.barrier() for gate in list_of_cnots: qs = gate.replace("CX", "").split("_") qc.cx(qr[int(qs[0])], qr[int(qs[1])]) if run_sequential_experiment: qc.barrier() qc.barrier() # for i in [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13]: for i in range(14): qc.measure(qr[i], cr[i]) return qc
def task_1_2(): """ Fitting of q2 to the random state in q1. """ n_qubits = 5 # Number of qubits per one state n_qubit_state = int((n_qubits - 1) / 2) # p1 = θ, p2 = ϕ, p3 = λ, p4 = θ, ... u_params = get_u_params(n_qubits) qreg_q = qk.QuantumRegister(n_qubits, 'q') creg_c = qk.ClassicalRegister(1, 'c') circuit = qk.QuantumCircuit(qreg_q, creg_c) build_t2_circ(circuit, qreg_q, creg_c, n_qubit_state, u_params) result = sciopt.differential_evolution(err, bounds=[(0, 2 * np.pi)] * 3 * int(n_qubits / 2), args=(circuit, u_params), maxiter=15) tmp_circ = circuit.bind_parameters( {u_params[i]: result.x[i] for i in range(3 * int(n_qubits / 2))}) print('SWAP test after optimization: P(q0 = 0) = {}'.format( swap_test(tmp_circ))) print('Parameters of U3-gates:') for i in range(n_qubit_state): print('q{}: θ = {}, ϕ = {}, λ = {}'.format(i + n_qubit_state + 1, result.x[3 * i], result.x[3 * i + 1], result.x[3 * i + 2]))
def append_measurements(circ, measurements): """ Assumes creator returns an instance of the relevant circuit""" num_classical = len(measurements.replace('1','')) if num_classical > 0: cr = qk.ClassicalRegister(num_classical, 'classical') circ.add_register(cr) ct_m = 0 ct_q = 0 for basis in measurements: if basis == 'z': circ.measure(ct_q, ct_m) ct_m+=1 elif basis == 'x': circ.u3(pi/2, 0, 0, ct_q) circ.measure(ct_q, ct_m) ct_m+=1 elif basis == 'y': circ.u3(pi/2, -pi/2, -pi/2, ct_q) circ.measure(ct_q, ct_m) ct_m+=1 elif basis == '1': pass ct_q+=1 return circ
def test_execute_two_remote(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): """Test execute two remote. If all correct some should exists. """ register(QE_TOKEN, QE_URL, hub, group, project) backend = available_backends({'local': False, 'simulator': True})[0] backend = get_backend(backend) qubit_reg = qiskit.QuantumRegister(2) clbit_reg = qiskit.ClassicalRegister(2) qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg) qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg) qc_extra.measure(qubit_reg, clbit_reg) job = execute([qc, qc_extra], backend) results = job.result() self.assertIsInstance(results, Result)
def qv_circuits(qubit_lists=None, ntrials=1, qr=None, cr=None): """ Return a list of square quantum volume circuits (depth=width) The qubit_lists is specified as a list of qubit lists. For each set of qubits, circuits the depth as the number of qubits in the list are generated Args: qubit_lists (list): list of list of qubits to apply qv circuits to. Assume the list is ordered in increasing number of qubits ntrials (int): number of random iterations qr (QuantumRegister): quantum register to act on (if None one is created) cr (ClassicalRegister): classical register to measure to (if None one is created) Returns: tuple: A tuple of the type (``circuits``, ``circuits_nomeas``) wheere: ``circuits`` is a list of lists of circuits for the qv sequences (separate list for each trial) and `` circuitss_nomeas`` is the same circuits but with no measurements for the ideal simulation """ circuits = [[] for e in range(ntrials)] circuits_nomeas = [[] for e in range(ntrials)] # get the largest qubit number out of all the lists (for setting the # register) depth_list = [len(l) for l in qubit_lists] # go through for each trial for trial in range(ntrials): # go through for each depth in the depth list for depthidx, depth in enumerate(depth_list): n_q_max = np.max(qubit_lists[depthidx]) qr = qiskit.QuantumRegister(int(n_q_max + 1), 'qr') qr2 = qiskit.QuantumRegister(int(depth), 'qr') cr = qiskit.ClassicalRegister(int(depth), 'cr') qc = qiskit.QuantumCircuit(qr, cr) qc2 = qiskit.QuantumCircuit(qr2, cr) qc.name = 'qv_depth_%d_trial_%d' % (depth, trial) qc2.name = qc.name # build the circuit for _ in range(depth): # Generate uniformly random permutation Pj of [0...n-1] perm = np.random.permutation(depth) # For each pair p in Pj, generate Haar random SU(4) for k in range(int(np.floor(depth / 2))): unitary = random_unitary(4) pair = int(perm[2 * k]), int(perm[2 * k + 1]) qc.append(unitary, [ qr[qubit_lists[depthidx][pair[0]]], qr[qubit_lists[depthidx][pair[1]]] ]) qc2.append(unitary, [qr2[pair[0]], qr2[pair[1]]]) # append an id to all the qubits in the ideal circuits # to prevent a truncation error in the statevector # simulators qc2.u1(0, qr2) circuits_nomeas[trial].append(qc2) # add measurement for qind, qubit in enumerate(qubit_lists[depthidx]): qc.measure(qr[qubit], cr[qind]) circuits[trial].append(qc) return circuits, circuits_nomeas
def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None, device=None, *args, **kwargs): """ Parameters ---------- abstract_circuit: QCircuit: the circuit to be compiled to qiskit. variables: dict: variables to compile the circuit with qubit_map: dictionary: a qubit map which maps the abstract qubits in the abstract_circuit to the qubits on the backend there is no need to initialize the corresponding backend types the dictionary should simply be {int:int} (preferred) or {int:name} if None the default will map to qubits 0 ... n_qubits -1 in the backend noise: noise to apply to the circuit. device: device on which to (perhaps, via emulation) execute the circuit. args kwargs """ self.op_lookup = { 'I': (lambda c: c.iden), 'X': (lambda c: c.x, lambda c: c.cx, lambda c: c.ccx), 'Y': (lambda c: c.y, lambda c: c.cy, lambda c: c.ccy), 'Z': (lambda c: c.z, lambda c: c.cz, lambda c: c.ccz), 'H': (lambda c: c.h, lambda c: c.ch, lambda c: c.cch), 'Rx': (lambda c: c.rx, lambda c: c.mcrx), 'Ry': (lambda c: c.ry, lambda c: c.mcry), 'Rz': (lambda c: c.rz, lambda c: c.mcrz), 'Phase': (lambda c: c.u1, lambda c: c.cu1), 'SWAP': (lambda c: c.swap, lambda c: c.cswap), } self.resolver = {} self.tq_to_pars = {} self.counter = 0 if qubit_map is None: n_qubits = len(abstract_circuit.qubits) else: n_qubits = max(qubit_map.values()) + 1 self.q = qiskit.QuantumRegister(n_qubits, "q") self.c = qiskit.ClassicalRegister(n_qubits, "c") super().__init__(abstract_circuit=abstract_circuit, variables=variables, noise=noise, device=device, qubit_map=qubit_map, *args, **kwargs) self.classical_map = self.make_classical_map(qubit_map=self.qubit_map) if noise != None: self.noise_lookup = { 'phase damp': qiskitnoise.phase_damping_error, 'amplitude damp': qiskitnoise.amplitude_damping_error, 'bit flip': get_bit_flip, 'phase flip': get_phase_flip, 'phase-amplitude damp': qiskitnoise.phase_amplitude_damping_error, 'depolarizing': qiskitnoise.depolarizing_error } if isinstance(noise, str): if noise == 'device': if device is not None: self.noise_model = qiskitnoise.NoiseModel.from_backend( self.device) else: raise TequilaException( 'cannot get device noise without specifying a device!' ) else: raise TequilaException( 'The only allowed string for noise is \'device\'; recieved {}. Please try again!' .format(str(noise))) else: nm = self.noise_model_converter(noise) self.noise_model = nm else: self.noise_model = None if len(self.tq_to_pars.keys()) is None: self.pars_to_tq = None self.resolver = None else: self.pars_to_tq = {v: k for k, v in self.tq_to_pars.items()} self.resolver = { k: to_float(v(variables)) for k, v in self.pars_to_tq.items() }
''' TOKEN = '4cb909509e365586e960d3b82179adee139035eae0c2c6f21b307e9b4bbb89e6339df2a481ae239a9eb3389530be03e2840e97edcde1de45f5da075bfdf553a4' qk.IBMQ.save_account(TOKEN, overwrite=True) qk.IBMQ.load_account() ''' `n` is the number of Qubits needed to generate a a random number between 0 and 2^n - 1 ''' n = 3 ''' Creating a Quantum Register with `n` Qubits and `n` Classical Bits where n=3 ''' q = qk.QuantumRegister(n) c = qk.ClassicalRegister(n) qc = qk.QuantumCircuit(q, c) ''' Applying a Hadamard Gate on the n Qubits to get a final bitstring of size n The bitstring will be converted to a decimal number (integer) between 0 and 2^3 - 1 (7) ''' for i in range(n): qc.h(i) qc.measure(q, c) # The backend simulator available to me backend = qk.IBMQ.get_provider().get_backend('ibmqx2') new_job = qk.execute(qc, backend, shots=1)