def test_ugates_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(3) c1.add(gates.RX(0, 0.1)) c1.add(gates.RZ(1, 0.4)) c1.add(gates.U2(2, 0.5, 0.6)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector # pylint: disable=no-member np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol) c1 = Circuit(3) c1.add(gates.RX(0, 0.1)) c1.add(gates.RZ(1, 0.4)) c1.add(gates.U2(2, 0.5, 0.6)) c1.add(gates.CU3(2, 1, 0.2, 0.3, 0.4)) # catches unknown gate "cu3" with pytest.raises(exception.QasmException): c2 = circuit_from_qasm(c1.to_qasm()) qibo.set_backend(original_backend)
def test_ugates_cirq(): c1 = Circuit(3) c1.add(gates.RX(0, 0.1)) c1.add(gates.RZ(1, 0.4)) c1.add(gates.U2(2, 0.5, 0.6)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol) c1 = Circuit(3) c1.add(gates.RX(0, 0.1)) c1.add(gates.RZ(1, 0.4)) c1.add(gates.U2(2, 0.5, 0.6)) c1.add(gates.CU3(2, 1, 0.2, 0.3, 0.4)) # catches unknown gate "cu3" with pytest.raises(exception.QasmException): c2 = circuit_from_qasm(c1.to_qasm())
def test_consistency_with_qasm_output_and_qiskit(): qubits = [cirq.NamedQubit('q_{}'.format(i)) for i in range(4)] a, b, c, d = qubits circuit1 = cirq.Circuit( cirq.rx(np.pi / 2).on(a), cirq.ry(np.pi / 2).on(b), cirq.rz(np.pi / 2).on(b), cirq.X.on(a), cirq.Y.on(b), cirq.Z.on(c), cirq.H.on(d), cirq.S.on(a), cirq.T.on(b), cirq.S.on(c) ** -1, cirq.T.on(d) ** -1, cirq.X.on(d) ** 0.125, cirq.TOFFOLI.on(a, b, c), cirq.CSWAP.on(d, a, b), cirq.SWAP.on(c, d), cirq.CX.on(a, b), cirq.ControlledGate(cirq.Y).on(c, d), cirq.CZ.on(a, b), cirq.ControlledGate(cirq.H).on(b, c), cirq.IdentityGate(1).on(c), cirq.circuits.qasm_output.QasmUGate(1.0, 2.0, 3.0).on(d), ) qasm = cirq.qasm(circuit1) circuit2 = circuit_from_qasm(qasm) cirq_unitary = cirq.unitary(circuit2) ct.assert_allclose_up_to_global_phase(cirq_unitary, cirq.unitary(circuit1), atol=1e-8) cq.assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, cirq_unitary)
def test_cu1_cirq(): c1 = Circuit(2) c1.add(gates.RX(0, 0.1234)) c1.add(gates.RZ(1, 0.4321)) c1.add(gates.CU1(0, 1, 0.567)) # catches unknown gate "cu1" with pytest.raises(exception.QasmException): c2 = circuit_from_qasm(c1.to_qasm())
def test_AT(self): before = format_from_qasm(os.path.join(rel, "Arithmetic_and_Toffoli/tof_10.qasm")) with open("copy.qasm", "r") as f: c = f.read() before = circuit_from_qasm(c) #c.close() f = open(os.path.join((os.path.dirname(os.path.abspath(__file__))), "interop/tests/optimized_qasm_files/optim_tof_10.qasm")) t = f.read() f.close() after = circuit_from_qasm(t) #f.close() a = cirq.qasm(after) after = circuit_from_qasm(a) run = self.run_voqc(before) run = cirq.qasm(run) run = circuit_from_qasm(run) self.assertEqual(run, after)
def test_crotations_cirq(): c1 = Circuit(3) c1.add(gates.RX(0, 0.1)) c1.add(gates.RZ(1, 0.4)) c1.add(gates.CRX(0, 2, 0.5)) c1.add(gates.RY(1, 0.3).controlled_by(2)) # catches unknown gate "crx" with pytest.raises(exception.QasmException): c2 = circuit_from_qasm(c1.to_qasm())
def from_qasm(qasm: QASMType) -> cirq.Circuit: """Returns a Mitiq circuit equivalent to the input QASM string. Args: qasm: QASM string to convert to a Mitiq circuit. Returns: Mitiq circuit representation equivalent to the input QASM string. """ return circuit_from_qasm(qasm)
def load_circuit_file(input_path: str) -> cirq.Circuit: """Reads a QASM circuit file and returns it as a cirq Circuit.""" print(f'reading: {input_path}', flush=True) start = timer() with open(input_path, 'r') as handle: contents = handle.read() circuit = circuit_from_qasm(contents) stop = timer() print_stats(stop - start, circuit) return circuit
def test_AT(self): before = format_from_qasm( os.path.join(rel, "pyvoqc/tests/test_qasm_files/tof_10.qasm")) with open("copy.qasm", "r") as f: c = f.read() before = circuit_from_qasm(c) #c.close() f = open( os.path.join(rel, "pyvoqc/tests/test_qasm_files/optim_tof_10.qasm")) t = f.read() f.close() after = circuit_from_qasm(t) a = cirq.qasm(after) after = circuit_from_qasm(a) run = self.run_voqc(before) run = cirq.qasm(run) run = circuit_from_qasm(run) self.assertEqual(run, after)
def diagonal_decompose(n_qubits, unitary): response_circuit = qiskit.circuit.library.Diagonal(unitary.diagonal()) qasm_string = response_circuit.qasm(filename=Path(DIR_PATH, RAW_QASM_FN)) response_circuit = _initial_transpile(response_circuit) qasm_string = response_circuit.qasm(filename=Path(DIR_PATH, IR0_QASM_FN)) qasm_string = _invert_qubit_order(n_qubits, DIR_PATH, IR0_QASM_FN, IR1_QASM_FN) return circuit_from_qasm(qasm_string)
def from_qasm(qasm: QASMType) -> cirq.Circuit: """Returns a Mitiq circuit equivalent to the input QASM string. Args: qasm: QASM string to convert to a Mitiq circuit. Returns: Mitiq circuit representation equivalent to the input QASM string. """ qasm = _remove_barriers(qiskit.QuantumCircuit.from_qasm_str(qasm)).qasm() return circuit_from_qasm(qasm)
def random_decompose(n_qubits, unitary): _write_backend_config(CONFIG_PATH) _openql_compile(DIR_PATH, CONFIG_PATH, n_qubits, unitary) qasm_string = _rewrite_openql_qasm(DIR_PATH, n_qubits) qasm_string = _invert_qubit_order(n_qubits, DIR_PATH, RAW_QASM_FN, IR0_QASM_FN) response_circuit = _make_response_circuit(n_qubits, qasm_string) response_circuit = _initial_transpile(response_circuit) qasm_string = response_circuit.qasm(filename=Path(DIR_PATH, IR1_QASM_FN)) return circuit_from_qasm(qasm_string)
def incrementer_decompose(n_qubits, unitary): response_circuit = QuantumCircuit(n_qubits) for i in reversed(range(1, n_qubits)): response_circuit.mcx(list(range(i)), i) response_circuit.x(0) qasm_string = response_circuit.qasm(filename=Path(DIR_PATH, RAW_QASM_FN)) response_circuit = _initial_transpile(response_circuit) qasm_string = response_circuit.qasm(filename=Path(DIR_PATH, IR0_QASM_FN)) qasm_string = _invert_qubit_order(n_qubits, DIR_PATH, IR0_QASM_FN, IR1_QASM_FN) return circuit_from_qasm(qasm_string)
def test_parametrized_gate_cirq(): c1 = Circuit(2) c1.add(gates.Y(0)) c1.add(gates.RY(1, 0.1234)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
def test_simple_cirq(backend): c1 = Circuit(2) c1.add(gates.H(0)) c1.add(gates.H(1)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector # pylint: disable=no-member np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
def to_tfq_circuit(hamil: type([hamiltonian, qiskit.QuantumCircuit])): if isinstance(hamil, hamiltonian): qasm_cir = hamil.get_quantumCircuit().qasm() elif isinstance(hamil, qiskit.QuantumCircuit): qasm_cir = hamil.qasm() from cirq.contrib.qasm_import import circuit_from_qasm cirq_cir = circuit_from_qasm(qasm_cir) cirq_cir_gridded = cirq.Circuit([cirq.ops.Moment(operation.transform_qubits( _qubit_mapping)for operation in moment.operations)for moment in cirq_cir.moments]) if isinstance(hamil, phase_hamiltonian): expanded_PauliSum = hamil.get_pHamil() Z_list = list(expanded_PauliSum.free_symbols) Z_list.remove(sympy.abc.I) Z_list.sort(key=_get_qubitNo) _cir = cirq.GridQubit.rect(1, len(Z_list)) cirq_zList = [] for q in _cir: cirq_zList.append(cirq.Z(q)) conversion_dict = dict(zip(Z_list, cirq_zList)) conversion_dict[sympy.abc.I] = 1 pauli_sum = 0 for exp in expanded_PauliSum.args: pauli_exp = 1 for var in exp.args: if var.is_Number: number = float(var) if number < 0: number = number * -1 pauli_exp *= number else: pauli_exp *= conversion_dict[var] pauli_sum += cirq.PauliString(pauli_exp) return (cirq_cir_gridded, pauli_sum) else: return(cirq_cir_gridded, None)
def run(self, target, run_analyser=True): with tempfile.TemporaryDirectory() as tmpdirname: fname = os.path.join(tmpdirname, "target.qasm") target.save_to_qasm(fname, qreg_name="q") with open(fname) as file: qasm_data = file.read() original_circuit = circuit_from_qasm(qasm_data) start_time = timer() # only 'greedy' routing is implemented in Cirq swap_networks: List[ccr.SwapNetwork] = [] routing_attempts = 1 with suppress(KeyError): routing_attempts = self._cfg["routing_attempts"] for _ in range(routing_attempts): swap_network = ccr.route_circuit(original_circuit, self.cirq_hardware, router=None, algo_name="greedy") swap_networks.append(swap_network) assert len(swap_networks) > 0, "Unable to get routing for circuit" # Sort by the least number of qubits first (as routing sometimes adds extra ancilla qubits), # and then the length of the circuit second. swap_networks.sort(key=lambda swap_network: (len( swap_network.circuit.all_qubits()), len(swap_network.circuit))) routed_circuit = swap_networks[0].circuit qubit_order = { LineQubit(n): NamedQubit(f"q_{n}") for n in range(self.quantum_hardware.num_qubits) } # decompose composite gates no_decomp = lambda op: isinstance(op.gate, CNotPowGate) opt = ExpandComposite(no_decomp=no_decomp) opt.optimize_circuit(routed_circuit) self.execution_time = timer() - start_time qasm_data = routed_circuit.to_qasm(qubit_order=qubit_order) lines = qasm_data.split("\n") gate_chain = GateChain.from_qasm_list_of_lines(lines, quantum_hardware=None) if run_analyser: self.analyse(target, gate_chain) self.analyser_report["Execution Time"] = self.execution_time return gate_chain
def matrix_to_sycamore_operations( target_qubits: List[cirq.GridQubit], matrix: np.ndarray) -> Tuple[cirq.OP_TREE, List[cirq.GridQubit]]: """A method to convert a unitary matrix to a list of Sycamore operations. This method will return a list of `cirq.Operation`s using the qubits and (optionally) ancilla qubits to implement the unitary matrix `matrix` on the target qubits `qubits`. The operations are also supported by `cirq.google.gate_sets.SYC_GATESET`. Args: target_qubits: list of qubits the returned operations will act on. The qubit order defined by the list is assumed to be used by the operations to implement `matrix`. matrix: a matrix that is guaranteed to be unitary and of size (2**len(qs), 2**len(qs)). Returns: A tuple of operations and ancilla qubits allocated. Operations: In case the matrix is supported, a list of operations `ops` is returned. `ops` acts on `qs` qubits and for which `cirq.unitary(ops)` is equal to `matrix` up to certain tolerance. In case the matrix is not supported, it might return NotImplemented to reduce the noise in the judge output. Ancilla qubits: In case ancilla qubits are allocated a list of ancilla qubits. Otherwise an empty list. . """ if len(target_qubits) > 4: return NotImplemented, [] # Converting the Unitary to Operations using Qiskit qc = qiskit.QuantumCircuit(len(target_qubits)) qc.unitary(matrix, list(range(len(target_qubits)))) qc = qiskit.transpile(qc, basis_gates=['cx', 'u3']) # Converting Qiskit to Cirq from cirq.contrib import qasm_import qasm = qc.qasm() qx = cirq.Circuit(qasm_import.circuit_from_qasm(qasm)) # Compiling down to the Sycamore hardware convertor = cirq.google.ConvertToSycamoreGates() qz = convertor.convert(qx) # Running an optimization pass qy = cirq.Circuit(qz) qy = cirq.google.optimized_for_sycamore(qy) qy = list(qy.all_operations()) ans = qz if len(qy) > len( qz) else qy # Check if optimizations are doing better return ans, []
def test_multiqubit_gates_cirq(): c1 = Circuit(2) c1.add(gates.H(0)) c1.add(gates.CNOT(0, 1)) c1.add(gates.X(1)) c1.add(gates.SWAP(0, 1)) c1.add(gates.X(0).controlled_by(1)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
def test_parametrized_gate_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(2) c1.add(gates.Y(0)) c1.add(gates.RY(1, 0.1234)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol) qibo.set_backend(original_backend)
def test_toffoli_cirq(): c1 = Circuit(3) c1.add(gates.Y(0)) c1.add(gates.TOFFOLI(0, 1, 2)) c1.add(gates.X(1)) c1.add(gates.TOFFOLI(0, 2, 1)) c1.add(gates.Z(2)) c1.add(gates.TOFFOLI(1, 2, 0)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
def test_multiqubit_gates_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(2) c1.add(gates.H(0)) c1.add(gates.CNOT(0, 1)) c1.add(gates.X(1)) c1.add(gates.SWAP(0, 1)) c1.add(gates.X(0).controlled_by(1)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector # pylint: disable=no-member np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol) qibo.set_backend(original_backend)
def test_toffoli_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(3) c1.add(gates.Y(0)) c1.add(gates.TOFFOLI(0, 1, 2)) c1.add(gates.X(1)) c1.add(gates.TOFFOLI(0, 2, 1)) c1.add(gates.Z(2)) c1.add(gates.TOFFOLI(1, 2, 0)) final_state_c1 = c1() c2 = circuit_from_qasm(c1.to_qasm()) c2depth = len(cirq.Circuit(c2.all_operations())) assert c1.depth == c2depth final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector # pylint: disable=no-member np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol) c3 = Circuit.from_qasm(c2.to_qasm()) assert c3.depth == c2depth final_state_c3 = c3() np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol) qibo.set_backend(original_backend)
def run(self, target, run_analyser=True): with tempfile.TemporaryDirectory() as tmpdirname: fname = os.path.join(tmpdirname, "target.qasm") target.save_to_qasm(fname, qreg_name="q") with open(fname) as file: qasm_data = file.read() optimised_circuit = circuit_from_qasm(qasm_data) start_time = timer() # Push Z gates toward the end of the circuit eject_z = cirq.optimizers.EjectZ() eject_z.optimize_circuit(optimised_circuit) # Push X, Y, and PhasedXPow gates toward the end of the circuit eject_paulis = cirq.optimizers.EjectPhasedPaulis() eject_paulis.optimize_circuit(optimised_circuit) # Merge single qubit gates into PhasedX and PhasedZ gates cirq.merge_single_qubit_gates_into_phased_x_z(optimised_circuit) # drop negligible gates drop_neg = cirq.optimizers.DropNegligible() drop_neg.optimize_circuit(optimised_circuit) # drop empty moments drop_empty = cirq.optimizers.DropEmptyMoments() drop_empty.optimize_circuit(optimised_circuit) self.execution_time = timer() - start_time qubit_order = { NamedQubit(f'q_{n}'): NamedQubit(f'q_{n}') for n in range(target.quantum_hardware.num_qubits) } qasm_data = optimised_circuit.to_qasm(qubit_order=qubit_order) lines = qasm_data.split("\n") gate_chain = GateChain.from_qasm_list_of_lines(lines, quantum_hardware=None) if run_analyser: self.analyse(target, gate_chain) self.analyser_report["Execution Time"] = self.execution_time return gate_chain
def run(d, l): t = open(l, "w") csvwriter = csv.writer(t) csvwriter.writerow(["Name", "Before", "VOQC", "Cirq+VOQC", "Time"]) t.close() for fname in os.listdir(d): print(fname) format_from_qasm(os.path.join(d, fname)) c = open('copy.qasm').read() circ = circuit_from_qasm(c) before = len(list(circ.all_operations())) print("Original:\t Total %d" % (len(list(circ.all_operations())))) start = time.time() circ = CqVOQC().optimize_circuit(circ) end = time.time() first = end - start after_voqc = len(list(circ.all_operations())) print("After VOQC:\t Total %d" % (len(list(circ.all_operations())))) start = time.time() ConvertToCzAndSingleGates().optimize_circuit(circ) MergeInteractions().optimize_circuit(circ) MergeSingleQubitGates().optimize_circuit(circ) EjectPhasedPaulis().optimize_circuit(circ) EjectZ().optimize_circuit(circ) DropNegligible().optimize_circuit(circ) end = time.time() second = end - start final_1 = len(list(circ.all_operations())) print("Final:\t Total %d" % (len(list(circ.all_operations())))) t = open(l, "a") csvwriter = csv.writer(t) csvwriter.writerow( [fname, before, after_voqc, final_1, first + second]) t.close()
def optimize_circuit(self, circuit: circuits.Circuit): #Write qasm file from circuit circuit = Circuit( decompose(circuit, intercepting_decomposer=decompose_library, keep=need_to_keep)) qasm_str = cirq.qasm(circuit) f = open("temp.qasm", "w") f.write(qasm_str) f.close() #Call VOQC optimizations from input list and go from rzq to rz t = self.function_call("temp.qasm") rzq_to_rz("temp2.qasm") #Get Cirq Circuit from qasm file with open("temp2.qasm", "r") as f: c = f.read() circ = circuit_from_qasm(c) #Remove temporary files os.remove("temp.qasm") os.remove("temp2.qasm") return circ
def from_qasm(circuit): if isinstance(circuit, CIRCUIT_TYPE): return circuit else: return circuit_from_qasm(circuit)
import cirq import qsimcirq import time from cirq.contrib.qasm_import import circuit_from_qasm import sys time_start=time.time() qasm_file = sys.argv[1] with open(qasm_file, 'r') as qasm: data = qasm.read() circuit = circuit_from_qasm(data) qsimSim = qsimcirq.QSimSimulator() time_start=time.time() result = qsimSim.run(circuit) time_end=time.time() print('time cost',time_end-time_start,'s')
import networkx from cirq.contrib.qasm_import import circuit_from_qasm from cirq import NamedQubit from olsq.device import qcdevice from olsq.olsq_cirq import OLSQ_cirq circuit = circuit_from_qasm("""OPENQASM 2.0; include "qelib1.inc"; qreg q[3]; h q[2]; cx q[1], q[2]; tdg q[2]; cx q[0], q[2]; t q[2]; cx q[1], q[2]; tdg q[2]; cx q[0], q[2]; t q[1]; t q[2]; cx q[0], q[1]; h q[2]; t q[0]; tdg q[1]; cx q[0], q[1];""") device_graph = networkx.Graph() device_graph.add_nodes_from([NamedQubit(f'q_{i}') for i in range(5)]) device_graph.add_edge(NamedQubit('q_0'), NamedQubit('q_1')) device_graph.add_edge(NamedQubit('q_1'), NamedQubit('q_2')) device_graph.add_edge(NamedQubit('q_1'), NamedQubit('q_3')) device_graph.add_edge(NamedQubit('q_3'), NamedQubit('q_4'))
def read_qasm_circuit(path): qasm_string = open(path, 'r').read() try: return circuit_from_qasm(qasm_string) except: print('wrong circuit format')