def _state_tomography_quantum_program(self, target, state, n_qubits, shots=1): qp = qiskit.QuantumProgram() try: backend = 'local_qiskit_simulator' qp.get_backend_configuration(backend) except LookupError: backend = 'local_qasm_simulator' # Prepared target state and assess quality qp = self.target_prep(state, target, n_qubits, qp=qp) prep_result = qp.execute(['prep'], backend=backend, shots=1) prep_state = prep_result.get_data('prep')['quantum_state'] F_prep = state_fidelity(prep_state, target) print('Prepared state fidelity =', F_prep) # Run state tomography simulation and fit data to reconstruct circuit qp, tomo_set, tomo_circuits = self.add_tomo_circuits(qp) tomo_result = qp.execute(tomo_circuits, backend=backend, shots=shots) tomo_data = tomo.tomography_data(tomo_result, 'prep', tomo_set) rho_fit = tomo.fit_tomography_data(tomo_data) # calculate fidelity and purity of fitted state F_fit = state_fidelity(rho_fit, target) pur = purity(rho_fit) print('Fitted state fidelity =', F_fit) print('Fitted state purity =', str(pur))
def test_output_unitary_same_as_qiskit(): qubits = tuple(_make_qubits(5)) operations = _all_operations(*qubits, include_measurments=False) output = cirq.QasmOutput(operations, qubits, header='Generated from Cirq', precision=10) text = str(output) # coverage: ignore try: # We don't want to require qiskit as a dependency but # if Qiskit is installed, test QASM output against it. import qiskit # type: ignore except ImportError: return circuit = cirq.Circuit.from_ops(operations) cirq_unitary = circuit.to_unitary_matrix(qubit_order=qubits[::-1]) p = qiskit.QuantumProgram() p.load_qasm_text(text) result = p.execute(backend='local_unitary_simulator') qiskit_unitary = result.get_unitary() cirq.testing.assert_allclose_up_to_global_phase(cirq_unitary, qiskit_unitary, rtol=1e-8, atol=1e-8)
def setup(self): version_parts = qiskit.__version__.split('.') if version_parts[0] == '0' and int(version_parts[1]) < 5: self.local_qasm_simulator = None elif hasattr(qiskit, 'BasicAer'): self.local_qasm_simulator = qiskit.BasicAer.get_backend( 'qasm_simulator') elif hasattr(qiskit, 'get_backend'): self.local_qasm_simulator = qiskit.get_backend( 'local_qasm_simulator') else: self.local_qasm_simulator = qiskit.BasicAer.get_backend( "qasm_simulator") self.has_compile = False if hasattr(qiskit, 'compile'): self.has_compile = True self.single_gate_circuit = self._build_single_gate_circuit() self.cx_circuit = self._build_cx_circuit() self.qasm_path = os.path.abspath( os.path.join(os.path.dirname(__file__), 'qasm')) large_qasm_path = os.path.join(self.qasm_path, 'test_eoh_qasm.qasm') if hasattr(qiskit, 'load_qasm_file'): self.large_qasm = qiskit.load_qasm_file(large_qasm_path) elif version_parts[0] == '0' and int(version_parts[1]) < 5: self.large_qasm = qiskit.QuantumProgram() self.large_qasm.load_qasm_file(large_qasm_path, name='large_qasm') else: self.large_qasm = qiskit.QuantumCircuit.from_qasm_file( large_qasm_path)
def _build_single_gate_circuit(self): if self.local_qasm_simulator is None: qp = qiskit.QuantumProgram() single_register = qp.create_quantum_register('qr', 1) single_gate_circuit = qp.create_circuit('single_gate', [single_register]) single_gate_circuit.h(single_register[0]) return qp if self.local_qasm_simulator is not None: single_register = qiskit.QuantumRegister(1) single_gate_circuit = qiskit.QuantumCircuit(single_register) single_gate_circuit.h(single_register[0]) return single_gate_circuit return None
def main(): if (len(sys.argv) != 2): print("Usage: python3 run_qasm.py [qasm_filename]") name = "test" qp = qiskit.QuantumProgram() qp.load_qasm_file(sys.argv[1], name=name) ret = qp.execute([name], backend="local_qasm_simulator", shots=1,\ max_credits=5, hpc=None, timeout=60*60*24) sim_result = ret.get_counts(name) sim_result_keys = sim_result.keys() print(ret) print(sim_result) print(sim_result_keys) return
def _ansatz(): """Mimics the circuits from the appendix of the paper, with the exception of the ordering of the circuit.cx gates (before and after compilation they still do not match). This is probably best just left up to the compiler. For ease of reading the printed operations, the qubits are looped over several times. """ program = qiskit.QuantumProgram() qubits = self.qc.qubits() n_qubits = self.q var = 'theta' ro = program.declare('ro', memory_type='BIT', memory_size=n_qubits) thetas = { var + str(qubit): program.declare(var + str(qubit), memory_type='REAL') for qubit in qubits } sq = int(np.sqrt(n_qubits)) lim = n_qubits - sq - 1 for m in qubits: program += qiskit.rx(thetas[var + str(m)], m) for m in qubits: m_1 = m + 1 m_sq = m + sq skip = (m_1) % sq if m_1 < n_qubits: if (m_sq >= n_qubits): program += qiskit.circuit.cx(m, m_1) else: program += qiskit.circuit.cx(m, m_sq) if (m < lim) and (skip != 0): program += qiskit.circuit.cx(m, m_1) for m in qubits: program += qiskit.measure(m, ro[m]) print("program instructions from Qiskit:\n") for instruction in program.instructions: print(instruction) return program
def _build_cx_circuit(self): if self.local_qasm_simulator is None: qp = qiskit.QuantumProgram() cx_register = qp.create_quantum_register('qr', 2) cx_circuit = qp.create_circuit("cx_circuit", [cx_register]) cx_circuit.h(cx_register[0]) cx_circuit.h(cx_register[0]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) return qp if self.local_qasm_simulator is not None: cx_register = qiskit.QuantumRegister(2) cx_circuit = qiskit.QuantumCircuit(cx_register) cx_circuit.h(cx_register[0]) cx_circuit.h(cx_register[0]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) cx_circuit.cx(cx_register[0], cx_register[1]) return cx_circuit return None
"StatePreparation", "circuits": [ { "name": "initializerCirc", "quantum_registers": [{ "name": "qr", "size": qubit_number }], "classical_registers": [{ "name": "cr", "size": qubit_number }] }, ], } Q_program = qiskit.QuantumProgram(specs=Q_SPECS) ## State preparation import numpy as np from qiskit.extensions.quantum_initializer import _initializer def psi_0_coefficients(qubit_number: int): T = 2**qubit_number tau = np.arange(T) return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1 / 2) / T) def get_coeffs(qubit_number: int): # Can be changed to anything, the initialize function will take # care of the initialisation.
def runBenchmark(name, qubit, backend, depth, verify, seed): if seed: seed = int(seed) if depth > 0: qasm_files = name + "/" + name + "_n" + str(qubit) + "_d" + str( depth) + "*.qasm" pattern1 = name + "_n" + str(qubit) + "_d" + str( depth) + "[^0-9]*\.qasm" pattern2 = name + "_n" + str(qubit) + "_d" + str(depth) + "\D.*\.qasm" else: qasm_files = name + "/" + name + "_n" + str(qubit) + "*.qasm" pattern1 = name + "_n" + str(qubit) + "[^0-9]*\.qasm" pattern2 = name + "_n" + str(qubit) + "\D.*\.qasm" file_list = glob.glob(qasm_files) if not file_list: raise Exception("No qasm file") for qasm in file_list: ret = None if not ((re.search(pattern1, os.path.basename(qasm))) or (re.search(pattern2, os.path.basename(qasm)))): continue qp = qiskit.QuantumProgram() if backend.startswith("ibmqx"): import Qconfig qp.set_api(Qconfig.APItoken, Qconfig.config['url']) elif not backend.startswith("local"): raise Exception('only ibmqx or local simulators are supported') qp.load_qasm_file(qasm, name=name) start = time.time() ret = qp.execute([name], backend=backend, shots=1, max_credits=5, hpc=None, timeout=60 * 60 * 24, seed=seed) elapsed = time.time() - start #print(ret.get_data(name)) if not ret.get_circuit_status(0) == "DONE": return False if backend.startswith("ibmqx"): elapsed = ret.get_data(name)["time"] print(name + "," + backend + "," + str(qubit) + "," + str(depth) + "," + str(elapsed), flush=True) #print(ret.get_counts(name)) if verify: verify_result(ret, name, qasm) if not ret: raise Exception("No qasm file") return True
qr = qiskit.QuantumRegister("qr", 2) # Create a Classical Register called "cr" with 2 bits. cr = qiskit.ClassicalRegister("cr", 2) # Create a Quantum Circuit called involving "qr" and "cr" qc = qiskit.QuantumCircuit(qr, cr) # Add a H gate on qubit 0, putting this qubit in superposition. qc.h(qr[0]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. qc.cx(qr[0], qr[1]) # Add a Measure gate to see the state. qc.measure(qr, cr) # Create a Quantum Program for execution qp = qiskit.QuantumProgram() # Add the circuit you created to it, and call it the "bell" circuit. # (You can add multiple circuits to the same program, for batch execution) qp.add_circuit("bell", qc) # Compile and run the Quantum Program on a simulator backend print("(Local Backends)") for backend in local_backends: print(backend) sim_result = qp.execute("bell", backend='local_qasm_simulator', shots=1024, seed=1) # Show the results print("simulation: ", sim_result) print(sim_result.get_counts("bell")) # Compile and run the Quantum Program on a real device backend
def run_benchmark(args, qubit): """ Run simulation by each qasm files """ name = args.name backend = args.backend depth = int(args.depth) seed = args.seed if seed: seed = int(seed) if depth > 0: qasm_files = name + "/" + name + "_n" + \ str(qubit) + "_d" + str(depth) + "*.qasm" pattern1 = name + "_n" + str(qubit) + \ "_d" + str(depth) + r"[^0-9]*\.qasm" pattern2 = name + "_n" + str(qubit) + "_d" + str(depth) + r"\D.*\.qasm" else: qasm_files = name + "/" + name + "_n" + str(qubit) + "*.qasm" pattern1 = name + "_n" + str(qubit) + r"[^0-9]*\.qasm" pattern2 = name + "_n" + str(qubit) + r"\D.*\.qasm" qasm_files = glob.glob(qasm_files) if not qasm_files: raise Exception("No qasm file") for qasm in qasm_files: ret = None if not ((re.search(pattern1, os.path.basename(qasm))) or (re.search(pattern2, os.path.basename(qasm)))): continue q_prog = qiskit.QuantumProgram() if backend.startswith("ibmqx"): import Qconfig q_prog.set_api(Qconfig.APItoken, Qconfig.config['url']) elif not backend.startswith("local"): raise Exception('only ibmqx or local simulators are supported') q_prog.load_qasm_file(qasm, name=name) start = time.time() ret = q_prog.execute([name], backend=backend, shots=1, max_credits=5, hpc=None, timeout=60 * 60 * 24, seed=seed) elapsed = time.time() - start if not ret.get_circuit_status(0) == "DONE": return False if backend.startswith("ibmqx"): elapsed = ret.get_data(name)["time"] print(name + "," + backend + "," + str(qubit) + "," + str(depth) + "," + str(elapsed), flush=True) if args.verify: verify_result(ret, name, qasm) if not ret: raise Exception("No qasm file") return True