def test_from_backend_for_backend_without_dt(self):
backend = FakeTokyo()
gate = self._find_gate_with_length(backend)
durations = InstructionDurations.from_backend(backend)
self.assertIsNone(durations.dt)
self.assertGreater(durations.get(gate, 0, "s"), 0)
with self.assertRaises(TranspilerError):
durations.get(gate, 0)
def test_all_levels_use_trivial_if_perfect(self, level):
"""Test that we always use trivial if it's a perfect match.
See: https://github.com/Qiskit/qiskit-terra/issues/5694 for more
details
"""
backend = FakeTokyo()
config = backend.configuration()
rows = [x[0] for x in config.coupling_map]
cols = [x[1] for x in config.coupling_map]
adjacency_matrix = np.zeros((20, 20))
adjacency_matrix[rows, cols] = 1
qc = GraphState(adjacency_matrix)
qc.measure_all()
expected = {
0: Qubit(QuantumRegister(20, "q"), 0),
1: Qubit(QuantumRegister(20, "q"), 1),
2: Qubit(QuantumRegister(20, "q"), 2),
3: Qubit(QuantumRegister(20, "q"), 3),
4: Qubit(QuantumRegister(20, "q"), 4),
5: Qubit(QuantumRegister(20, "q"), 5),
6: Qubit(QuantumRegister(20, "q"), 6),
7: Qubit(QuantumRegister(20, "q"), 7),
8: Qubit(QuantumRegister(20, "q"), 8),
9: Qubit(QuantumRegister(20, "q"), 9),
10: Qubit(QuantumRegister(20, "q"), 10),
11: Qubit(QuantumRegister(20, "q"), 11),
12: Qubit(QuantumRegister(20, "q"), 12),
13: Qubit(QuantumRegister(20, "q"), 13),
14: Qubit(QuantumRegister(20, "q"), 14),
15: Qubit(QuantumRegister(20, "q"), 15),
16: Qubit(QuantumRegister(20, "q"), 16),
17: Qubit(QuantumRegister(20, "q"), 17),
18: Qubit(QuantumRegister(20, "q"), 18),
19: Qubit(QuantumRegister(20, "q"), 19),
}
trans_qc = transpile(qc,
backend,
optimization_level=level,
seed_transpiler=42)
self.assertEqual(trans_qc._layout._p2v, expected)
def setUp(self):
super().setUp()
self.cmap20 = FakeTokyo().configuration().coupling_map
self.target_19 = Target()
rng = np.random.default_rng(12345)
instruction_props = {
edge: InstructionProperties(duration=rng.uniform(1e-7, 1e-6),
error=rng.uniform(1e-4, 1e-3))
for edge in CouplingMap.from_heavy_hex(3).get_edges()
}
self.target_19.add_instruction(CXGate(), instruction_props)
def test_call_limit(self):
"""Hard to solve situations hit the call limit"""
dag = TestCSPLayout.create_hard_dag()
coupling_map = CouplingMap(FakeTokyo().configuration().coupling_map)
pass_ = CSPLayout(coupling_map, call_limit=1, time_limit=None)
start = process_time()
pass_.run(dag)
runtime = process_time() - start
self.assertLess(runtime, 1)
self.assertEqual(pass_.property_set["CSPLayout_stop_reason"],
"call limit reached")
def test_trivial_layout(self, level):
"""Test that trivial layout is preferred in level 0
See: https://github.com/Qiskit/qiskit-terra/pull/3657#pullrequestreview-342012465
"""
qr = QuantumRegister(10, "qr")
qc = QuantumCircuit(qr)
qc.cx(qr[0], qr[1])
qc.cx(qr[1], qr[2])
qc.cx(qr[2], qr[6])
qc.cx(qr[3], qr[8])
qc.cx(qr[4], qr[9])
qc.cx(qr[9], qr[8])
qc.cx(qr[8], qr[7])
qc.cx(qr[7], qr[6])
qc.cx(qr[6], qr[5])
qc.cx(qr[5], qr[0])
ancilla = QuantumRegister(10, "ancilla")
trivial_layout = {
0: qr[0],
1: qr[1],
2: qr[2],
3: qr[3],
4: qr[4],
5: qr[5],
6: qr[6],
7: qr[7],
8: qr[8],
9: qr[9],
10: ancilla[0],
11: ancilla[1],
12: ancilla[2],
13: ancilla[3],
14: ancilla[4],
15: ancilla[5],
16: ancilla[6],
17: ancilla[7],
18: ancilla[8],
19: ancilla[9],
}
expected_layouts = [trivial_layout, trivial_layout]
backend = FakeTokyo()
result = transpile(qc,
backend,
optimization_level=level,
seed_transpiler=42)
self.assertEqual(result._layout._p2v, expected_layouts[level])
def test_initial_layout(self, level):
"""When a user provides a layout (initial_layout), it should be used."""
qr = QuantumRegister(10, "qr")
qc = QuantumCircuit(qr)
qc.cx(qr[0], qr[1])
qc.cx(qr[1], qr[2])
qc.cx(qr[2], qr[3])
qc.cx(qr[3], qr[9])
qc.cx(qr[4], qr[9])
qc.cx(qr[9], qr[8])
qc.cx(qr[8], qr[7])
qc.cx(qr[7], qr[6])
qc.cx(qr[6], qr[5])
qc.cx(qr[5], qr[0])
initial_layout = {
0: qr[0],
2: qr[1],
4: qr[2],
6: qr[3],
8: qr[4],
10: qr[5],
12: qr[6],
14: qr[7],
16: qr[8],
18: qr[9],
}
backend = FakeTokyo()
result = transpile(qc,
backend,
optimization_level=level,
initial_layout=initial_layout,
seed_transpiler=42)
for physical, virtual in initial_layout.items():
self.assertEqual(result._layout._p2v[physical], virtual)
class TestTranspileLevels(QiskitTestCase):
"""Test transpiler on fake backend"""
@combine(
circuit=[emptycircuit, circuit_2532],
level=[0, 1, 2, 3],
backend=[
FakeTenerife(),
FakeMelbourne(),
FakeRueschlikon(),
FakeTokyo(),
FakePoughkeepsie(),
None,
],
dsc=
"Transpiler {circuit.__name__} on {backend} backend at level {level}",
name="{circuit.__name__}_{backend}_level{level}",
)
def test(self, circuit, level, backend):
"""All the levels with all the backends"""
result = transpile(circuit(),
backend=backend,
optimization_level=level,
seed_transpiler=42)
self.assertIsInstance(result, QuantumCircuit)
def test_layout_tokyo_fully_connected_cx(self, level):
"""Test that final layout in tokyo in a fully connected circuit"""
qr = QuantumRegister(5, "qr")
qc = QuantumCircuit(qr)
for qubit_target in qr:
for qubit_control in qr:
if qubit_control != qubit_target:
qc.cx(qubit_control, qubit_target)
ancilla = QuantumRegister(15, "ancilla")
trivial_layout = {
0: qr[0],
1: qr[1],
2: qr[2],
3: qr[3],
4: qr[4],
5: ancilla[0],
6: ancilla[1],
7: ancilla[2],
8: ancilla[3],
9: ancilla[4],
10: ancilla[5],
11: ancilla[6],
12: ancilla[7],
13: ancilla[8],
14: ancilla[9],
15: ancilla[10],
16: ancilla[11],
17: ancilla[12],
18: ancilla[13],
19: ancilla[14],
}
dense_layout = {
11: qr[0],
6: qr[1],
5: qr[2],
10: qr[3],
15: qr[4],
0: ancilla[0],
1: ancilla[1],
2: ancilla[2],
3: ancilla[3],
4: ancilla[4],
7: ancilla[5],
8: ancilla[6],
9: ancilla[7],
12: ancilla[8],
13: ancilla[9],
14: ancilla[10],
16: ancilla[11],
17: ancilla[12],
18: ancilla[13],
19: ancilla[14],
}
sabre_layout = {
6: qr[0],
11: qr[1],
10: qr[2],
5: qr[3],
16: qr[4],
0: ancilla[0],
1: ancilla[1],
2: ancilla[2],
3: ancilla[3],
4: ancilla[4],
7: ancilla[5],
8: ancilla[6],
9: ancilla[7],
12: ancilla[8],
13: ancilla[9],
14: ancilla[10],
15: ancilla[11],
17: ancilla[12],
18: ancilla[13],
19: ancilla[14],
}
expected_layout_level0 = trivial_layout
expected_layout_level1 = dense_layout
expected_layout_level2 = dense_layout
expected_layout_level3 = sabre_layout
expected_layouts = [
expected_layout_level0,
expected_layout_level1,
expected_layout_level2,
expected_layout_level3,
]
backend = FakeTokyo()
result = transpile(qc,
backend,
optimization_level=level,
seed_transpiler=42)
self.assertEqual(result._layout._p2v, expected_layouts[level])
def test_layout_tokyo_2845(self, level):
"""Test that final layout in tokyo #2845
See: https://github.com/Qiskit/qiskit-terra/issues/2845
"""
qr1 = QuantumRegister(3, "qr1")
qr2 = QuantumRegister(2, "qr2")
qc = QuantumCircuit(qr1, qr2)
qc.cx(qr1[0], qr1[1])
qc.cx(qr1[1], qr1[2])
qc.cx(qr1[2], qr2[0])
qc.cx(qr2[0], qr2[1])
trivial_layout = {
0: Qubit(QuantumRegister(3, "qr1"), 0),
1: Qubit(QuantumRegister(3, "qr1"), 1),
2: Qubit(QuantumRegister(3, "qr1"), 2),
3: Qubit(QuantumRegister(2, "qr2"), 0),
4: Qubit(QuantumRegister(2, "qr2"), 1),
5: Qubit(QuantumRegister(15, "ancilla"), 0),
6: Qubit(QuantumRegister(15, "ancilla"), 1),
7: Qubit(QuantumRegister(15, "ancilla"), 2),
8: Qubit(QuantumRegister(15, "ancilla"), 3),
9: Qubit(QuantumRegister(15, "ancilla"), 4),
10: Qubit(QuantumRegister(15, "ancilla"), 5),
11: Qubit(QuantumRegister(15, "ancilla"), 6),
12: Qubit(QuantumRegister(15, "ancilla"), 7),
13: Qubit(QuantumRegister(15, "ancilla"), 8),
14: Qubit(QuantumRegister(15, "ancilla"), 9),
15: Qubit(QuantumRegister(15, "ancilla"), 10),
16: Qubit(QuantumRegister(15, "ancilla"), 11),
17: Qubit(QuantumRegister(15, "ancilla"), 12),
18: Qubit(QuantumRegister(15, "ancilla"), 13),
19: Qubit(QuantumRegister(15, "ancilla"), 14),
}
vf2_layout = {
0: Qubit(QuantumRegister(15, "ancilla"), 0),
1: Qubit(QuantumRegister(15, "ancilla"), 1),
2: Qubit(QuantumRegister(15, "ancilla"), 2),
3: Qubit(QuantumRegister(15, "ancilla"), 3),
4: Qubit(QuantumRegister(15, "ancilla"), 4),
5: Qubit(QuantumRegister(15, "ancilla"), 5),
6: Qubit(QuantumRegister(3, "qr1"), 1),
7: Qubit(QuantumRegister(15, "ancilla"), 6),
8: Qubit(QuantumRegister(15, "ancilla"), 7),
9: Qubit(QuantumRegister(15, "ancilla"), 8),
10: Qubit(QuantumRegister(3, "qr1"), 0),
11: Qubit(QuantumRegister(3, "qr1"), 2),
12: Qubit(QuantumRegister(15, "ancilla"), 9),
13: Qubit(QuantumRegister(15, "ancilla"), 10),
14: Qubit(QuantumRegister(15, "ancilla"), 11),
15: Qubit(QuantumRegister(15, "ancilla"), 12),
16: Qubit(QuantumRegister(2, "qr2"), 0),
17: Qubit(QuantumRegister(2, "qr2"), 1),
18: Qubit(QuantumRegister(15, "ancilla"), 13),
19: Qubit(QuantumRegister(15, "ancilla"), 14),
}
# Trivial layout
expected_layout_level0 = trivial_layout
# Dense layout
expected_layout_level1 = vf2_layout
# CSP layout
expected_layout_level2 = vf2_layout
expected_layout_level3 = vf2_layout
expected_layouts = [
expected_layout_level0,
expected_layout_level1,
expected_layout_level2,
expected_layout_level3,
]
backend = FakeTokyo()
result = transpile(qc,
backend,
optimization_level=level,
seed_transpiler=42)
self.assertEqual(result._layout._p2v, expected_layouts[level])
def test_with_backend(self, optimization_level):
"""Test a passmanager is constructed when only a backend and optimization level."""
target = FakeTokyo()
pm = generate_preset_pass_manager(optimization_level, target)
self.assertIsInstance(pm, PassManager)