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')
