def tensored_meas_cal(mit_pattern=None, qr=None, cr=None, circlabel=''): """ Return a list of calibration circuits Args: mit_pattern (list of lists of integers): Qubits to perform the measurement correction on, divided to groups according to tensors. if None and qr is given then assumed to be performed over the entire qr as one group qr (QuantumRegister): A quantum register. If none one is created cr (ClassicalRegister): A classical register. If none one is created circlabel: A string to add to the front of circuit names for unique identification Returns: A list of two QuantumCircuit objects containing the calibration circuits mit_pattern Additional Information: The returned circuits are named circlabel+cal_XXX where XXX is the basis state, e.g., cal_000 and cal_111 Pass the results of these circuits to the TensoredMeasurementFitter constructor """ if mit_pattern is None and qr is None: raise QiskitError("Must give one of mit_pattern or qr") qubits_in_pattern = [] if mit_pattern is not None: for qubit_list in mit_pattern: for qubit in qubit_list: if qubit in qubits_in_pattern: raise QiskitError("mit_pattern cannot contain \ multiple instances of the same qubit") qubits_in_pattern.append(qubit) # Create the registers if not already done if qr is None: qr = QuantumRegister(max(qubits_in_pattern) + 1) else: qubits_in_pattern = range(len(qr)) mit_pattern = [qubits_in_pattern] nqubits = len(qubits_in_pattern) # create classical bit registers if cr is None: cr = ClassicalRegister(nqubits) qubits_list_sizes = [len(qubit_list) for qubit_list in mit_pattern] nqubits = sum(qubits_list_sizes) size_of_largest_group = max([list_size for list_size in qubits_list_sizes]) largest_labels = count_keys(size_of_largest_group) state_labels = [] for largest_state in largest_labels: basis_state = '' for list_size in qubits_list_sizes: basis_state = largest_state[:list_size] + basis_state state_labels.append(basis_state) cal_circuits = [] for basis_state in state_labels: qc_circuit = QuantumCircuit(qr, cr, name='%scal_%s' % (circlabel, basis_state)) end_index = nqubits for qubit_list, list_size in zip(mit_pattern, qubits_list_sizes): start_index = end_index - list_size substate = basis_state[start_index:end_index] for qind in range(list_size): if substate[list_size - qind - 1] == '1': qc_circuit.x(qr[qubit_list[qind]]) end_index = start_index qc_circuit.barrier(qr) # add measurements end_index = nqubits for qubit_list, list_size in zip(mit_pattern, qubits_list_sizes): for qind in range(list_size): qc_circuit.measure(qr[qubit_list[qind]], cr[nqubits - (end_index - qind)]) end_index -= list_size cal_circuits.append(qc_circuit) return cal_circuits, mit_pattern
def test_circuit_depth_no_reg(self): """Test depth of no register circuits """ qc = QuantumCircuit() self.assertEqual(qc.depth(), 0)
def test_from_circuit(self): """Test initialization from a circuit.""" # random unitaries u0 = random_unitary(2).data u1 = random_unitary(2).data # add to circuit qr = QuantumRegister(2) circ = QuantumCircuit(qr) circ.unitary(u0, [qr[0]]) circ.unitary(u1, [qr[1]]) target = Statevector(np.kron(u1, u0).dot([1, 0, 0, 0])) vec = Statevector.from_instruction(circ) self.assertEqual(vec, target) # Test tensor product of 1-qubit gates circuit = QuantumCircuit(3) circuit.h(0) circuit.x(1) circuit.ry(np.pi / 2, 2) target = Statevector.from_label("000").evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test decomposition of Controlled-Phase gate lam = np.pi / 4 circuit = QuantumCircuit(2) circuit.h(0) circuit.h(1) circuit.cp(lam, 0, 1) target = Statevector.from_label("00").evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test decomposition of controlled-H gate circuit = QuantumCircuit(2) circ.x(0) circuit.ch(0, 1) target = Statevector.from_label("00").evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test custom controlled gate qc = QuantumCircuit(2) qc.x(0) qc.h(1) gate = qc.to_gate() gate_ctrl = gate.control() circuit = QuantumCircuit(3) circuit.x(0) circuit.append(gate_ctrl, range(3)) target = Statevector.from_label("000").evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test initialize instruction target = Statevector([1, 0, 0, 1j]) / np.sqrt(2) circuit = QuantumCircuit(2) circuit.initialize(target.data, [0, 1]) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test reset instruction target = Statevector([1, 0]) circuit = QuantumCircuit(1) circuit.h(0) circuit.reset(0) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target)
def test_circuit_connected_components_empty(self): """Verify num_connected_components is width for empty """ q = QuantumRegister(7, 'q') qc = QuantumCircuit(q) self.assertEqual(7, qc.num_connected_components())
def test_num_qubits_registerless_circuit(self): """Check output for circuits with direct argument for qubits. """ circ = QuantumCircuit(5) self.assertEqual(circ.num_qubits, 5)
def test_mapping_correction(self): """Test mapping works in previous failed case. """ backend = FakeRueschlikon() qr = QuantumRegister(name='qr', size=11) cr = ClassicalRegister(name='qc', size=11) circuit = QuantumCircuit(qr, cr) circuit.u3(1.564784764685993, -1.2378965763410095, 2.9746763177861713, qr[3]) circuit.u3(1.2269835563676523, 1.1932982847014162, -1.5597357740824318, qr[5]) circuit.cx(qr[5], qr[3]) circuit.u1(0.856768317675967, qr[3]) circuit.u3(-3.3911273825190915, 0.0, 0.0, qr[5]) circuit.cx(qr[3], qr[5]) circuit.u3(2.159209321625547, 0.0, 0.0, qr[5]) circuit.cx(qr[5], qr[3]) circuit.u3(0.30949966910232335, 1.1706201763833217, 1.738408691990081, qr[3]) circuit.u3(1.9630571407274755, -0.6818742967975088, 1.8336534616728195, qr[5]) circuit.u3(1.330181833806101, 0.6003162754946363, -3.181264980452862, qr[7]) circuit.u3(0.4885914820775024, 3.133297443244865, -2.794457469189904, qr[8]) circuit.cx(qr[8], qr[7]) circuit.u1(2.2196187596178616, qr[7]) circuit.u3(-3.152367609631023, 0.0, 0.0, qr[8]) circuit.cx(qr[7], qr[8]) circuit.u3(1.2646005789809263, 0.0, 0.0, qr[8]) circuit.cx(qr[8], qr[7]) circuit.u3(0.7517780502091939, 1.2828514296564781, 1.6781179605443775, qr[7]) circuit.u3(0.9267400575390405, 2.0526277839695153, 2.034202361069533, qr[8]) circuit.u3(2.550304293455634, 3.8250017126569698, -2.1351609599720054, qr[1]) circuit.u3(0.9566260876600556, -1.1147561503064538, 2.0571590492298797, qr[4]) circuit.cx(qr[4], qr[1]) circuit.u1(2.1899329069137394, qr[1]) circuit.u3(-1.8371715243173294, 0.0, 0.0, qr[4]) circuit.cx(qr[1], qr[4]) circuit.u3(0.4717053496327104, 0.0, 0.0, qr[4]) circuit.cx(qr[4], qr[1]) circuit.u3(2.3167620677708145, -1.2337330260253256, -0.5671322899563955, qr[1]) circuit.u3(1.0468499525240678, 0.8680750644809365, -1.4083720073192485, qr[4]) circuit.u3(2.4204244021892807, -2.211701932616922, 3.8297006565735883, qr[10]) circuit.u3(0.36660280497727255, 3.273119149343493, -1.8003362351299388, qr[6]) circuit.cx(qr[6], qr[10]) circuit.u1(1.067395863586385, qr[10]) circuit.u3(-0.7044917541291232, 0.0, 0.0, qr[6]) circuit.cx(qr[10], qr[6]) circuit.u3(2.1830003849921527, 0.0, 0.0, qr[6]) circuit.cx(qr[6], qr[10]) circuit.u3(2.1538343756723917, 2.2653381826084606, -3.550087952059485, qr[10]) circuit.u3(1.307627685019188, -0.44686656993522567, -2.3238098554327418, qr[6]) circuit.u3(2.2046797998462906, 0.9732961754855436, 1.8527865921467421, qr[9]) circuit.u3(2.1665254613904126, -1.281337664694577, -1.2424905413631209, qr[0]) circuit.cx(qr[0], qr[9]) circuit.u1(2.6209599970201007, qr[9]) circuit.u3(0.04680566321901303, 0.0, 0.0, qr[0]) circuit.cx(qr[9], qr[0]) circuit.u3(1.7728411151289603, 0.0, 0.0, qr[0]) circuit.cx(qr[0], qr[9]) circuit.u3(2.4866395967434443, 0.48684511243566697, -3.0069186877854728, qr[9]) circuit.u3(1.7369112924273789, -4.239660866163805, 1.0623389015296005, qr[0]) circuit.barrier(qr) circuit.measure(qr, cr) circuits = transpile(circuit, backend) self.assertIsInstance(circuits, QuantumCircuit)
""" In this example a Bell state is made. """ from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister from qiskit import execute from qiskit_qcgpu_provider import QCGPUProvider Provider = QCGPUProvider() # Create a Quantum Register with 2 qubits. q = QuantumRegister(2) # Create a Quantum Circuit with 2 Qubits qc = QuantumCircuit(q) # Add a H gate on qubit 0, putting this qubit in superposition. qc.h(q[0]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. qc.cx(q[0], q[1]) # See a list of available local simulators print("QCGPU backends: ", Provider.backends()) backend_sim = Provider.get_backend('statevector_simulator') # Compile and run the Quantum circuit on a simulator backend job_sim = execute(qc, backend_sim) result_sim = job_sim.result() # Show the results print("Simulation Results: ", result_sim)
def search(N, oracle, provider_name, backend_name, token, shots, draw, file): print("Grover's Search Algorithm Tool v.{}".format(__version__)) print("Params: N = {}, Oracle = {}, Backend = {}/{}, Shots = {}".format( N, oracle, provider_name, backend_name, shots)) controlsCount = math.ceil(math.log2(N)) controls = QuantumRegister(controlsCount, "c_qb") ancilla = QuantumRegister(1, "a_qb") target = QuantumRegister(1, "t_qb") classical = ClassicalRegister(controlsCount, "c_b") iterations = int(math.pi / 4 * math.log2(N)) print("Quantum circuit: {} qubits, {} iteration(s)".format( controlsCount + 2, iterations)) print("Building...") # Create a Quantum Circuit acting on the q register circuit = QuantumCircuit(controls, ancilla, target, classical) # State preparation # Add a H gates to contol qubits circuit.h(controls) # |-> to target qubit circuit.x(target) circuit.h(target) # Grover iterator def grover(circuit, controls, target): # Oracle binary = format(oracle, "0{}b".format(controlsCount)) for c, qubit in zip(binary, reversed(controls)): if c == '0': circuit.x(qubit) circuit.mct(controls, target[0], ancilla, mode='advanced') for c, qubit in zip(binary, reversed(controls)): if c == '0': circuit.x(qubit) # Diffuser circuit.h(controls) circuit.x(controls) circuit.mct(controls, target[0], ancilla, mode='advanced') circuit.x(controls) circuit.h(controls) # Iterations for i in range(iterations): grover(circuit, controls, target) # Measurement circuit.measure(controls, classical) # Draw quantum circuit if draw: if bool(file): f = open(file, "w+") print(circuit, file=f) f.close() else: print(circuit) # Backend # Aer if provider_name == "Aer": backend = Aer.get_backend(backend_name) # IBMQ elif provider_name == "IBMQ": account = IBMQ.stored_account() if bool(account): provider = IBMQ.load_account() else: if bool(token): provider = IBMQ.enable_account(token) else: print("Token is not provided!") exit() backend = provider.get_backend(backend_name) # Execute the quantum circuit on the qasm simulator print("Executing...") job = execute(circuit, backend, shots=shots) # Wait results i = 0 while True: time.sleep(1) status = job.status() print("({}) {}".format(i, status)) i = i + 1 if status in JOB_FINAL_STATES: if status == JobStatus.ERROR: print("Error:", job.error_message()) exit() else: break # Get results from the job result = job.result() #print("\nResults:", result) # Find max counts max = 0 state = "" for k, v in result.get_counts(circuit).items(): if v > max: max = v state = k num = int(state, 2) print("Answer: {}, State: '{}', {} times".format(num, state, max)) return num
from qiskit import execute, Aer, QuantumCircuit from math import pi, sqrt # first measurement qc = QuantumCircuit(1, 2) backend = Aer.get_backend('qasm_simulator') statevector = [1 / sqrt(2), 1j / sqrt(2)] qc.initialize(statevector, 0) qc.measure(0, 0) qc.measure(0, 1) print(qc) result = execute(qc, backend).result() counts = result.get_counts() print(counts)
def _circuit(self) -> QuantumCircuit: n_qubits: int = self._n_qubits circuit: QuantumCircuit = QuantumCircuit(n_qubits) circuit.h(range(n_qubits)) circuit.measure_all() return circuit
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[4],input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.z(input_qubit[4]) # number=55 prog.cx(input_qubit[4],input_qubit[0]) # number=56 prog.h(input_qubit[2]) # number=50 prog.cz(input_qubit[4],input_qubit[2]) # number=51 prog.h(input_qubit[2]) # number=52 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=28 prog.h(input_qubit[0]) # number=66 prog.cz(input_qubit[3],input_qubit[0]) # number=67 prog.h(input_qubit[0]) # number=68 prog.z(input_qubit[3]) # number=61 prog.cx(input_qubit[3],input_qubit[0]) # number=62 prog.cz(input_qubit[1],input_qubit[0]) # number=29 prog.h(input_qubit[0]) # number=30 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[1],input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.cx(input_qubit[1],input_qubit[0]) # number=35 prog.cx(input_qubit[1],input_qubit[0]) # number=38 prog.x(input_qubit[0]) # number=39 prog.cx(input_qubit[1],input_qubit[0]) # number=40 prog.cx(input_qubit[1],input_qubit[0]) # number=37 prog.h(input_qubit[0]) # number=46 prog.cz(input_qubit[1],input_qubit[0]) # number=47 prog.h(input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=63 prog.cz(input_qubit[1],input_qubit[0]) # number=64 prog.h(input_qubit[0]) # number=65 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.cx(input_qubit[0],input_qubit[1]) # number=22 prog.y(input_qubit[2]) # number=41 prog.x(input_qubit[1]) # number=23 prog.cx(input_qubit[0],input_qubit[1]) # number=24 prog.rx(1.0398671683382215,input_qubit[2]) # number=31 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def __init__(self): super().__init__() self.qc = QuantumCircuit() self.enable_variadic = bool(variadic_gates)
def test_unitary_decomposition(self): """Test decomposition for unitary gates over 2 qubits.""" qc = QuantumCircuit(3) qc.unitary(random_unitary(8, seed=42), [0, 1, 2]) self.assertTrue(Operator(qc).equiv(Operator(qc.decompose())))
from qiskit import compile, Aer ############################################################### # Set the backend name and coupling map. ############################################################### coupling_map = [[0, 1], [0, 2], [1, 2], [3, 2], [3, 4], [4, 2]] backend = Aer.get_backend("qasm_simulator") ############################################################### # Make a quantum program for quantum teleportation. ############################################################### q = QuantumRegister(3, "q") c0 = ClassicalRegister(1, "c0") c1 = ClassicalRegister(1, "c1") c2 = ClassicalRegister(1, "c2") qc = QuantumCircuit(q, c0, c1, c2, name="teleport") # Prepare an initial state qc.u3(0.3, 0.2, 0.1, q[0]) # Prepare a Bell pair qc.h(q[1]) qc.cx(q[1], q[2]) # Barrier following state preparation qc.barrier(q) # Measure in the Bell basis qc.cx(q[0], q[1]) qc.h(q[0]) qc.measure(q[0], c0[0])
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[4],input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.cx(input_qubit[4],input_qubit[0]) # number=46 prog.cx(input_qubit[4],input_qubit[0]) # number=52 prog.z(input_qubit[4]) # number=53 prog.cx(input_qubit[4],input_qubit[0]) # number=54 prog.cx(input_qubit[4],input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=37 prog.cz(input_qubit[4],input_qubit[0]) # number=38 prog.h(input_qubit[0]) # number=39 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(-1.0430087609918113,input_qubit[4]) # number=36 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1],input_qubit[0]) # number=40 prog.x(input_qubit[0]) # number=41 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1],input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.x(input_qubit[1]) # number=10 prog.rx(-0.06597344572538572,input_qubit[3]) # number=27 prog.cx(input_qubit[0],input_qubit[2]) # number=22 prog.x(input_qubit[2]) # number=23 prog.h(input_qubit[2]) # number=28 prog.cz(input_qubit[0],input_qubit[2]) # number=29 prog.h(input_qubit[2]) # number=30 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[4]) # number=35 prog.h(input_qubit[0]) # number=17 prog.rx(2.4912829742967055,input_qubit[2]) # number=26 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[2]) # number=25 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
# -*- coding: utf-8 -*- """ Created on Sun Mar 29 18:38:23 2020 @author: Neil Gupte """ import numpy as np from qiskit import(QuantumCircuit, execute, Aer) from qiskit.visualization import plot_histogram # Use Aer's qasm_simulator simulator = Aer.get_backend('qasm_simulator') circuit1 = QuantumCircuit(2, 2) circuit1.h(0) circuit1.draw() circuit1.x(1) circuit1.cx(0, 1) circuit1.draw() circuit1.measure([0,1], [0,1]) job1 = execute(circuit1, simulator, shots=1000) # Grab results from the job result1 = job1.result() # Returns counts counts1 = result1.get_counts(circuit1) print("\nTotal count for 10 and 01 are:",counts1) plot_histogram(result1.get_counts(circuit1))
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.rx(-1.3603096190043806, input_qubit[2]) # number=28 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[3]) # number=34 prog.cz(input_qubit[4], input_qubit[3]) # number=35 prog.h(input_qubit[3]) # number=36 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1], input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.x(input_qubit[0]) # number=32 prog.cx(input_qubit[1], input_qubit[0]) # number=33 prog.cx(input_qubit[0], input_qubit[1]) # number=24 prog.x(input_qubit[1]) # number=25 prog.x(input_qubit[1]) # number=41 prog.cx(input_qubit[0], input_qubit[1]) # number=26 prog.x(input_qubit[2]) # number=11 prog.h(input_qubit[3]) # number=46 prog.cz(input_qubit[2], input_qubit[3]) # number=47 prog.h(input_qubit[3]) # number=48 prog.x(input_qubit[3]) # number=12 prog.h(input_qubit[2]) # number=42 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.cx(input_qubit[0], input_qubit[2]) # number=43 prog.x(input_qubit[2]) # number=44 prog.cx(input_qubit[0], input_qubit[2]) # number=45 prog.rx(-1.9697785938008003, input_qubit[1]) # number=37 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.x(input_qubit[1]) # number=22 prog.x(input_qubit[1]) # number=23 # circuit end return prog
def test_fusion_operations(self): """Test Fusion enable/disable option""" shots = 100 qr = QuantumRegister(10) cr = ClassicalRegister(10) circuit = QuantumCircuit(qr, cr) for i in range(10): circuit.h(qr[i]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[0]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[1]) circuit.barrier(qr) circuit.cx(qr[1], qr[0]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[0]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[1]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[3]) circuit.barrier(qr) circuit.x(qr[0]) circuit.barrier(qr) circuit.x(qr[1]) circuit.barrier(qr) circuit.x(qr[0]) circuit.barrier(qr) circuit.x(qr[1]) circuit.barrier(qr) circuit.cx(qr[2], qr[3]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[3]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[3]) circuit.barrier(qr) circuit.x(qr[0]) circuit.barrier(qr) circuit.x(qr[1]) circuit.barrier(qr) circuit.x(qr[0]) circuit.barrier(qr) circuit.x(qr[1]) circuit.barrier(qr) circuit.cx(qr[2], qr[3]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[3]) circuit.barrier(qr) circuit.u3(0.1, 0.1, 0.1, qr[3]) circuit.barrier(qr) circuit.measure(qr, cr) qobj = assemble([circuit], self.SIMULATOR, shots=shots, seed_simulator=1) backend_options = self.BACKEND_OPTS.copy() backend_options['fusion_enable'] = True backend_options['fusion_verbose'] = True backend_options['fusion_threshold'] = 1 backend_options['optimize_ideal_threshold'] = 1 backend_options['optimize_noise_threshold'] = 1 result_fusion = self.SIMULATOR.run( qobj, backend_options=backend_options).result() self.assertTrue(getattr(result_fusion, 'success', 'False')) backend_options = self.BACKEND_OPTS.copy() backend_options['fusion_enable'] = False backend_options['fusion_verbose'] = True backend_options['fusion_threshold'] = 1 backend_options['optimize_ideal_threshold'] = 1 backend_options['optimize_noise_threshold'] = 1 result_nonfusion = self.SIMULATOR.run( qobj, backend_options=backend_options).result() self.assertTrue(getattr(result_nonfusion, 'success', 'False')) self.assertDictAlmostEqual(result_fusion.get_counts(circuit), result_nonfusion.get_counts(circuit), delta=0.0, msg="fusion x-x-x was failed")
def setUp(self): logger = getLogger() logger.setLevel('DEBUG') self.output = io.StringIO() logger.addHandler(StreamHandlerRaiseException(self.output)) self.circuit = QuantumCircuit(QuantumRegister(1))
def build_circuit(n: int, f: Callable[[str], str]) -> QuantumCircuit: # implement the Bernstein-Vazirani circuit zero = np.binary_repr(0, n) b = f(zero) # initial n + 1 bits input_qubit = QuantumRegister(n+1, "qc") classicals = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classicals) # inverse last one (can be omitted if using O_f^\pm) prog.x(input_qubit[n]) # circuit begin prog.h(input_qubit[1]) # number=1 prog.h(input_qubit[2]) # number=38 prog.cz(input_qubit[0],input_qubit[2]) # number=39 prog.h(input_qubit[2]) # number=40 prog.h(input_qubit[2]) # number=59 prog.cz(input_qubit[0],input_qubit[2]) # number=60 prog.h(input_qubit[2]) # number=61 prog.h(input_qubit[2]) # number=42 prog.cz(input_qubit[0],input_qubit[2]) # number=43 prog.h(input_qubit[2]) # number=44 prog.h(input_qubit[2]) # number=48 prog.cz(input_qubit[0],input_qubit[2]) # number=49 prog.h(input_qubit[2]) # number=50 prog.cx(input_qubit[0],input_qubit[2]) # number=54 prog.x(input_qubit[2]) # number=55 prog.h(input_qubit[2]) # number=67 prog.cz(input_qubit[0],input_qubit[2]) # number=68 prog.h(input_qubit[2]) # number=69 prog.h(input_qubit[2]) # number=64 prog.cz(input_qubit[0],input_qubit[2]) # number=65 prog.h(input_qubit[2]) # number=66 prog.h(input_qubit[2]) # number=71 prog.cz(input_qubit[0],input_qubit[2]) # number=72 prog.h(input_qubit[2]) # number=73 prog.h(input_qubit[2]) # number=51 prog.cz(input_qubit[0],input_qubit[2]) # number=52 prog.h(input_qubit[2]) # number=53 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0],input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.h(input_qubit[1]) # number=7 prog.cz(input_qubit[2],input_qubit[1]) # number=8 prog.rx(0.17592918860102857,input_qubit[2]) # number=34 prog.rx(-0.3989822670059037,input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=9 prog.h(input_qubit[1]) # number=18 prog.rx(2.3310617489636263,input_qubit[2]) # number=58 prog.cz(input_qubit[2],input_qubit[1]) # number=19 prog.h(input_qubit[1]) # number=20 prog.x(input_qubit[1]) # number=62 prog.y(input_qubit[1]) # number=14 prog.h(input_qubit[1]) # number=22 prog.cz(input_qubit[2],input_qubit[1]) # number=23 prog.rx(-0.9173450548482197,input_qubit[1]) # number=57 prog.cx(input_qubit[2],input_qubit[1]) # number=63 prog.h(input_qubit[1]) # number=24 prog.z(input_qubit[2]) # number=3 prog.cx(input_qubit[2],input_qubit[1]) # number=70 prog.z(input_qubit[1]) # number=41 prog.x(input_qubit[1]) # number=17 prog.y(input_qubit[2]) # number=5 prog.x(input_qubit[2]) # number=21 # apply H to get superposition for i in range(n): prog.h(input_qubit[i]) prog.h(input_qubit[n]) prog.barrier() # apply oracle O_f oracle = build_oracle(n, f) prog.append( oracle.to_gate(), [input_qubit[i] for i in range(n)] + [input_qubit[n]]) # apply H back (QFT on Z_2^n) for i in range(n): prog.h(input_qubit[i]) prog.barrier() # measure return prog
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.cx(input_qubit[3],input_qubit[0]) # number=32 prog.z(input_qubit[3]) # number=33 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[3],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.rx(0.11938052083641225,input_qubit[1]) # number=36 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(1.4765485471872026,input_qubit[2]) # number=35 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.x(input_qubit[0]) # number=9 prog.x(input_qubit[4]) # number=30 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.rx(-2.5258404934861938,input_qubit[1]) # number=25 prog.h(input_qubit[3]) # number=29 prog.cx(input_qubit[0],input_qubit[3]) # number=22 prog.x(input_qubit[3]) # number=23 prog.cx(input_qubit[0],input_qubit[3]) # number=24 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.rx(-0.0722566310325653,input_qubit[4]) # number=37 prog.x(input_qubit[1]) # number=14 prog.cx(input_qubit[0],input_qubit[2]) # number=26 prog.x(input_qubit[2]) # number=27 prog.cx(input_qubit[0],input_qubit[2]) # number=28 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def grover(marked_element): # Determine the number of qubits needed n = len(marked_element) N = 2**n # Flip bitstring - required due to the way qiskit marks strings marked_element = marked_element[::-1] # Determine the number of times to iterate T = int(round(np.pi * np.sqrt(N) / 4 - 0.5)) print('Number of iterations T =', T) # Initialise n qubit register, classical readout register and ancilla qubit q = QuantumRegister(n, 'ctrl') c = ClassicalRegister(n, 'meas') a = QuantumRegister(n - 1, 'anc') t = QuantumRegister(1, 'tgt') # Combine resources into a quantum circuit qc = QuantumCircuit(q, a, t, c) # Step 1: Start with n qubit register in equal superposition for i in range(n): qc.h(q[i]) # Put the target ancilla qubit into the |-> state qc.x(t[0]) qc.h(t[0]) # Define n-qubit CNOT gate def MultiCNOT(): # Compute qc.ccx(q[0], q[1], a[0]) for i in range(2, n): qc.ccx(q[i], a[i - 2], a[i - 1]) # Copy qc.cx(a[n - 2], t[0]) # Uncompute for i in range(n - 1, 1, -1): qc.ccx(q[i], a[i - 2], a[i - 1]) qc.ccx(q[0], q[1], a[0]) # Define the oracle def U_f(): for j in range(n): if marked_element[j] == '0': qc.x(q[j]) MultiCNOT() for j in range(n): if marked_element[j] == '0': qc.x(q[j]) # Define the gate D def D(): # Apply H and X for j in range(n): qc.h(q[j]) qc.x(q[j]) MultiCNOT() # Apply X and H for j in range(n): qc.x(q[j]) qc.h(q[j]) # Step 2: Repeat applications of U_f and D for i in range(T): U_f() D() # Measure our quantum register via our classical register for i in range(n): qc.measure(q[i], c[i]) # Execute the quantum circuit on the local simulator job = execute(qc, 'local_qasm_simulator') result = job.result() print('The results of the simulation shots are:', result.get_counts(qc))
def test_num_qubits_qubitless_circuit(self): """Check output in absence of qubits. """ c_reg = ClassicalRegister(3) circ = QuantumCircuit(c_reg) self.assertEqual(circ.num_qubits, 0)
import numpy as np from qiskit import (QuantumCircuit,QuantumRegister,ClassicalRegister,execute,Aer) from qiskit.visualization import * #Controlled-Z matrice cu CNOT si Hadamard si CNOT din C-Z cu Hadamard #nr de qubiti n=2 qr=n #nr de biti cr=n #backend=Aer.get_backend('statevector_simulator') simulator=Aer.get_backend('qasm_simulator') dem1=QuantumCircuit(qr,cr) circuit=QuantumCircuit(qr,cr) dem2=QuantumCircuit(qr,cr) circuit2=QuantumCircuit(qr,cr) dem1.x(1) dem1.cz(0,1) dem2.x(0) dem2.cx(0,1) circuit.x(1) # HXH=Z #Hadamard circuit.h(1) #CNOT circuit.cx(0,1) #H circuit.h(1)
def test_circuit_depth_empty(self): """Test depth of empty circuity """ q = QuantumRegister(5, 'q') qc = QuantumCircuit(q) self.assertEqual(qc.depth(), 0)
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.cx(input_qubit[0],input_qubit[4]) # number=54 prog.x(input_qubit[4]) # number=55 prog.cx(input_qubit[0],input_qubit[4]) # number=56 prog.cx(input_qubit[2],input_qubit[0]) # number=45 prog.z(input_qubit[2]) # number=46 prog.cx(input_qubit[2],input_qubit[0]) # number=47 prog.h(input_qubit[1]) # number=4 prog.rx(2.664070570244145,input_qubit[1]) # number=39 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[2]) # number=49 prog.cz(input_qubit[3],input_qubit[2]) # number=50 prog.h(input_qubit[2]) # number=51 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[3]) # number=40 prog.y(input_qubit[4]) # number=35 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=25 prog.cz(input_qubit[1],input_qubit[0]) # number=26 prog.h(input_qubit[0]) # number=27 prog.h(input_qubit[0]) # number=36 prog.cz(input_qubit[1],input_qubit[0]) # number=37 prog.h(input_qubit[0]) # number=38 prog.cx(input_qubit[1],input_qubit[0]) # number=41 prog.x(input_qubit[0]) # number=42 prog.cx(input_qubit[1],input_qubit[0]) # number=43 prog.cx(input_qubit[1],input_qubit[0]) # number=34 prog.cx(input_qubit[1],input_qubit[0]) # number=24 prog.cx(input_qubit[0],input_qubit[1]) # number=29 prog.cx(input_qubit[2],input_qubit[3]) # number=44 prog.x(input_qubit[1]) # number=30 prog.cx(input_qubit[0],input_qubit[1]) # number=31 prog.x(input_qubit[2]) # number=11 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.z(input_qubit[1]) # number=52 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
import matplotlib.pyplot as plt import sys import quantum_okiba as qo from tqdm import tqdm from qiskit import QuantumCircuit,visualization,Aer,execute from qiskit.quantum_info import average_gate_fidelity pi = np.pi e = constants.e # [C] h = constants.h # [m^2 kg/s] hbar = constants.hbar iDir = os.path.abspath(os.path.dirname(__file__)) opts = qt.solver.Options(nsteps=10000) #回路を設計 circ = QuantumCircuit(2) circ.h(0) Image=circ.draw(output='mpl') Image.savefig(iDir+'/sfg.png') #回路を実行1 backend = Aer.get_backend('statevector_simulator') job = execute(circ, backend) #これでstatusとresultを得られる状態に result = job.result() outputstate = result.get_statevector(circ, decimals=3) print(outputstate) #回路を実行2 backend = Aer.get_backend('unitary_simulator') job = execute(circ, backend) #これでstatusとresultを得られる状態に
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[1]) # number=29 prog.cz(input_qubit[3],input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=31 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.h(input_qubit[0]) # number=51 prog.cz(input_qubit[1],input_qubit[0]) # number=52 prog.h(input_qubit[0]) # number=53 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[1],input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.x(input_qubit[0]) # number=49 prog.cx(input_qubit[1],input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=54 prog.cz(input_qubit[1],input_qubit[0]) # number=55 prog.h(input_qubit[0]) # number=56 prog.h(input_qubit[4]) # number=41 prog.cx(input_qubit[1],input_qubit[0]) # number=37 prog.x(input_qubit[1]) # number=10 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0],input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0],input_qubit[2]) # number=24 prog.cx(input_qubit[0],input_qubit[3]) # number=32 prog.x(input_qubit[3]) # number=33 prog.h(input_qubit[3]) # number=42 prog.cz(input_qubit[0],input_qubit[3]) # number=43 prog.h(input_qubit[3]) # number=44 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end return prog
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.cx(input_qubit[0],input_qubit[2]) # number=35 prog.x(input_qubit[2]) # number=36 prog.cx(input_qubit[0],input_qubit[2]) # number=37 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(1): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.y(input_qubit[1]) # number=31 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1],input_qubit[0]) # number=28 prog.x(input_qubit[0]) # number=29 prog.cx(input_qubit[1],input_qubit[0]) # number=30 prog.x(input_qubit[1]) # number=10 prog.cx(input_qubit[0],input_qubit[2]) # number=22 prog.cx(input_qubit[0],input_qubit[2]) # number=25 prog.x(input_qubit[2]) # number=26 prog.cx(input_qubit[0],input_qubit[2]) # number=27 prog.cx(input_qubit[0],input_qubit[2]) # number=24 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.rx(1.7404423300887455,input_qubit[1]) # number=32 prog.z(input_qubit[1]) # number=33 prog.h(input_qubit[3]) # number=20 prog.h(input_qubit[0]) prog.h(input_qubit[1]) prog.h(input_qubit[2]) prog.h(input_qubit[3]) # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def complete_meas_cal(qubit_list=None, qr=None, cr=None, circlabel=''): """ Return a list of measurement calibration circuits for the full Hilbert space. Each of the 2**n circuits creates a basis state Args: qubit_list: A list of qubits to perform the measurement correction on, if None and qr is given then assumed to be performed over the entire qr. The calibration states will be labelled according to this ordering qr (QuantumRegister): A quantum register. If none one is created cr (ClassicalRegister): A classical register. If none one is created circlabel: A string to add to the front of circuit names for unique identification Returns: A list of QuantumCircuit objects containing the calibration circuits A list of calibration state labels Additional Information: The returned circuits are named circlabel+cal_XXX where XXX is the basis state, e.g., cal_1001 Pass the results of these circuits to the CompleteMeasurementFitter constructor """ if qubit_list is None and qr is None: raise QiskitError("Must give one of a qubit_list or a qr") # Create the registers if not already done if qr is None: qr = QuantumRegister(max(qubit_list) + 1) if qubit_list is None: qubit_list = range(len(qr)) cal_circuits = [] nqubits = len(qubit_list) # create classical bit registers if cr is None: cr = ClassicalRegister(nqubits) # labels for 2**n qubit states state_labels = count_keys(nqubits) for basis_state in state_labels: qc_circuit = QuantumCircuit(qr, cr, name='%scal_%s' % (circlabel, basis_state)) for qind, _ in enumerate(basis_state): if int(basis_state[nqubits - qind - 1]): # the index labeling of the label is backwards with # the list qc_circuit.x(qr[qubit_list[qind]]) # add measurements qc_circuit.measure(qr[qubit_list[qind]], cr[qind]) cal_circuits.append(qc_circuit) return cal_circuits, state_labels