def test_failed_reduced_map(self):
"""Generate a bad disconnected reduced map"""
fake = FakeRueschlikon()
cmap = fake.configuration().coupling_map
coupling_map = CouplingMap(cmap)
with self.assertRaises(CouplingError):
coupling_map.reduce([12, 11, 10, 3])
def test_successful_reduced_map(self):
"""Generate a reduced map"""
fake = FakeRueschlikon()
cmap = fake.configuration().coupling_map
coupling_map = CouplingMap(cmap)
out = coupling_map.reduce([12, 11, 10, 9]).get_edges()
ans = [(1, 2), (3, 2), (0, 1)]
self.assertEqual(set(out), set(ans))
def test_layout_1711(self, level):
"""Test that a user-given initial layout is respected,
in the qobj.
See: https://github.com/Qiskit/qiskit-terra/issues/1711
"""
# build a circuit which works as-is on the coupling map, using the initial layout
qr = QuantumRegister(3, "q")
cr = ClassicalRegister(3)
ancilla = QuantumRegister(13, "ancilla")
qc = QuantumCircuit(qr, cr)
qc.cx(qr[2], qr[1])
qc.cx(qr[2], qr[0])
initial_layout = {0: qr[1], 2: qr[0], 15: qr[2]}
final_layout = {
0: qr[1],
1: ancilla[0],
2: qr[0],
3: ancilla[1],
4: ancilla[2],
5: ancilla[3],
6: ancilla[4],
7: ancilla[5],
8: ancilla[6],
9: ancilla[7],
10: ancilla[8],
11: ancilla[9],
12: ancilla[10],
13: ancilla[11],
14: ancilla[12],
15: qr[2],
}
backend = FakeRueschlikon()
qc_b = transpile(qc,
backend,
initial_layout=initial_layout,
optimization_level=level)
qobj = assemble(qc_b)
self.assertEqual(qc_b._layout._p2v, final_layout)
compiled_ops = qobj.experiments[0].instructions
for operation in compiled_ops:
if operation.name == "cx":
self.assertIn(operation.qubits,
backend.configuration().coupling_map)
self.assertIn(operation.qubits, [[15, 0], [15, 2]])
def test_plot_16_qubit_gate_map(self):
"""Test plot_gate_map using 16 qubit backend"""
# getting the mock backend from FakeProvider
backend = FakeRueschlikon()
self.graph_plot_gate_map(backend=backend, filename="16_qubit_gate_map.png")
def test_9q_circuit_Rueschlikon(self):
"""9 qubits in Rueschlikon, without considering the direction
1 → 2 → 3 → 4 ← 5 ← 6 → 7 ← 8
↓ ↑ ↓ ↓ ↑ ↓ ↓ ↑
0 ← 15 → 14 ← 13 ← 12 → 11 → 10 ← 9
1 -- q1_0 - q1_1 - 4 --- 5 -- 6 - 7 --- q0_1
| | | | | | | |
q1_2 - q1_3 - q0_0 - 13 - q0_3 - 11 - q1_4 - q0_2
"""
cmap16 = CouplingMap(FakeRueschlikon().configuration().coupling_map)
qr0 = QuantumRegister(4, "q0")
qr1 = QuantumRegister(5, "q1")
circuit = QuantumCircuit(qr0, qr1)
circuit.cx(qr0[1], qr0[2]) # q0[1] -> q0[2]
circuit.cx(qr0[0], qr1[3]) # q0[0] -> q1[3]
circuit.cx(qr1[4], qr0[2]) # q1[4] -> q0[2]
dag = circuit_to_dag(circuit)
pass_ = VF2Layout(cmap16,
strict_direction=False,
seed=self.seed,
max_trials=1)
pass_.run(dag)
self.assertLayout(dag, cmap16, pass_.property_set)
def test_9q_circuit_16q_coupling(self):
"""9 qubits in Rueschlikon, without considering the direction
q0[1] - q0[0] - q1[3] - q0[3] - q1[0] - q1[1] - q1[2] - 8
| | | | | | | |
q0[2] - q1[4] -- 14 ---- 13 ---- 12 ---- 11 ---- 10 --- 9
"""
cmap16 = FakeRueschlikon().configuration().coupling_map
qr0 = QuantumRegister(4, "q0")
qr1 = QuantumRegister(5, "q1")
circuit = QuantumCircuit(qr0, qr1)
circuit.cx(qr0[1], qr0[2]) # q0[1] -> q0[2]
circuit.cx(qr0[0], qr1[3]) # q0[0] -> q1[3]
circuit.cx(qr1[4], qr0[2]) # q1[4] -> q0[2]
dag = circuit_to_dag(circuit)
pass_ = CSPLayout(CouplingMap(cmap16),
strict_direction=False,
seed=self.seed)
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr0[0]], 9)
self.assertEqual(layout[qr0[1]], 6)
self.assertEqual(layout[qr0[2]], 7)
self.assertEqual(layout[qr0[3]], 5)
self.assertEqual(layout[qr1[0]], 14)
self.assertEqual(layout[qr1[1]], 12)
self.assertEqual(layout[qr1[2]], 1)
self.assertEqual(layout[qr1[3]], 8)
self.assertEqual(layout[qr1[4]], 10)
self.assertEqual(pass_.property_set["CSPLayout_stop_reason"],
"solution found")
def test_parallel_compile(self):
"""Trigger parallel routines in compile."""
backend = FakeRueschlikon()
qr = QuantumRegister(16)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
for k in range(1, 15):
qc.cx(qr[0], qr[k])
qc.measure(qr[5], cr[0])
qlist = [qc for k in range(10)]
qobj = assemble(transpile(qlist, backend=backend))
self.assertEqual(len(qobj.experiments), 10)
def run_test():
"""Run tests."""
backend = FakeRueschlikon()
qr = QuantumRegister(16)
cr = ClassicalRegister(16)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
for k in range(1, 15):
qc.cx(qr[0], qr[k])
qc.measure(qr, cr)
qlist = [qc for k in range(15)]
for opt_level in [0, 1, 2, 3]:
tqc = transpile(qlist,
backend=backend,
optimization_level=opt_level,
seed_transpiler=424242)
result = backend.run(tqc, seed_simulator=4242424242,
shots=1000).result()
counts = result.get_counts()
for count in counts:
assert math.isclose(count["0000000000000000"], 500, rel_tol=0.1)
assert math.isclose(count["0111111111111111"], 500, rel_tol=0.1)
def test_5q_circuit_Rueschlikon_no_solution(self):
"""5 qubits in Rueschlikon, no solution
q0[1] ↖ ↗ q0[2]
q0[0]
q0[3] ↙ ↘ q0[4]
"""
cmap16 = FakeRueschlikon().configuration().coupling_map
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[2])
circuit.cx(qr[0], qr[3])
circuit.cx(qr[0], qr[4])
dag = circuit_to_dag(circuit)
pass_ = VF2Layout(CouplingMap(cmap16), seed=self.seed, max_trials=1)
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertIsNone(layout)
self.assertEqual(pass_.property_set["VF2Layout_stop_reason"],
VF2LayoutStopReason.NO_SOLUTION_FOUND)
def test_5q_circuit_16q_coupling_no_solution(self):
"""5 qubits in Rueschlikon, no solution
q0[1] ↖ ↗ q0[2]
q0[0]
q0[3] ↙ ↘ q0[4]
"""
cmap16 = FakeRueschlikon().configuration().coupling_map
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[2])
circuit.cx(qr[0], qr[3])
circuit.cx(qr[0], qr[4])
dag = circuit_to_dag(circuit)
pass_ = CSPLayout(CouplingMap(cmap16), seed=self.seed)
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertIsNone(layout)
self.assertEqual(pass_.property_set["CSPLayout_stop_reason"],
"nonexistent solution")
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 setUp(self):
super().setUp()
self.cmap5 = FakeTenerife().configuration().coupling_map
self.cmap16 = FakeRueschlikon().configuration().coupling_map