コード例 #1
0
 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])
コード例 #2
0
ファイル: test_transpiler.py プロジェクト: Styps/qiskit-terra
    def test_move_measurements(self):
        """Measurements applied AFTER swap mapping.
        """
        backend = FakeRueschlikon()
        cmap = backend.configuration().coupling_map
        circ = QuantumCircuit.from_qasm_file(
            self._get_resource_path('move_measurements.qasm', Path.QASMS))

        lay = Layout({
            ('qa', 0): ('q', 0),
            ('qa', 1): ('q', 1),
            ('qb', 0): ('q', 15),
            ('qb', 1): ('q', 2),
            ('qb', 2): ('q', 14),
            ('qN', 0): ('q', 3),
            ('qN', 1): ('q', 13),
            ('qN', 2): ('q', 4),
            ('qc', 0): ('q', 12),
            ('qNt', 0): ('q', 5),
            ('qNt', 1): ('q', 11),
            ('qt', 0): ('q', 6)
        })
        out = transpile(circ, initial_layout=lay, coupling_map=cmap)
        out_dag = circuit_to_dag(out)
        meas_nodes = out_dag.named_nodes('measure')
        for meas_node in meas_nodes:
            is_last_measure = all([
                after_measure.type == 'out'
                for after_measure in out_dag.quantum_successors(meas_node)
            ])
            self.assertTrue(is_last_measure)
コード例 #3
0
    def test_already_mapped_1(self):
        """Circuit not remapped if matches topology.

        See: https://github.com/Qiskit/qiskit-terra/issues/342
        """
        backend = FakeRueschlikon()
        coupling_map = backend.configuration().coupling_map
        basis_gates = backend.configuration().basis_gates

        qr = QuantumRegister(16, 'qr')
        cr = ClassicalRegister(16, 'cr')
        qc = QuantumCircuit(qr, cr)
        qc.cx(qr[3], qr[14])
        qc.cx(qr[5], qr[4])
        qc.h(qr[9])
        qc.cx(qr[9], qr[8])
        qc.x(qr[11])
        qc.cx(qr[3], qr[4])
        qc.cx(qr[12], qr[11])
        qc.cx(qr[13], qr[4])
        qc.measure(qr, cr)

        new_qc = transpile(qc, coupling_map=coupling_map, basis_gates=basis_gates)
        cx_qubits = [qargs for (gate, qargs, _) in new_qc.data
                     if gate.name == "cx"]
        cx_qubits_physical = [[ctrl[1], tgt[1]] for [ctrl, tgt] in cx_qubits]
        self.assertEqual(sorted(cx_qubits_physical),
                         [[3, 4], [3, 14], [5, 4], [9, 8], [12, 11], [13, 4]])
コード例 #4
0
    def test_initial_layout_1(self):
        """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)
        cr = ClassicalRegister(3)
        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]}
        backend = FakeRueschlikon()

        for optimization_level in range(4):
            qc_b = transpile(qc,
                             backend,
                             initial_layout=initial_layout,
                             optimization_level=optimization_level)
            qobj = assemble(qc_b)

            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]])
コード例 #5
0
    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]])
コード例 #6
0
 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))
コード例 #7
0
    def test_simjob_raises_error_when_sending_bad_qobj(self):
        """Test SimulatorJob is denied resource request access when given an invalid Qobj instance.
        """
        job_id = str(uuid.uuid4())
        backend = FakeRueschlikon()
        self.bad_qobj.header = QobjHeader(backend_name=backend.name())

        with self.assertRaises(SchemaValidationError):
            job = basicaerjob.BasicAerJob(backend, job_id, _nop, self.bad_qobj)
            job.submit()
コード例 #8
0
    def test_delay_converts_to_dt(self):
        """Test that a delay instruction is converted to units of dt given a backend."""
        qc = QuantumCircuit(2)
        qc.delay(1000, [0], unit='us')

        backend = FakeRueschlikon()
        backend.configuration().dt = 0.5e-6
        out = transpile([qc, qc], backend)
        self.assertEqual(out[0].data[0][0].unit, 'dt')
        self.assertEqual(out[1].data[0][0].unit, 'dt')

        out = transpile(qc, dt=1e-9)
        self.assertEqual(out.data[0][0].unit, 'dt')
コード例 #9
0
    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]], 2)
        self.assertEqual(layout[qr0[1]], 1)
        self.assertEqual(layout[qr0[2]], 0)
        self.assertEqual(layout[qr0[3]], 4)
        self.assertEqual(layout[qr1[0]], 5)
        self.assertEqual(layout[qr1[1]], 6)
        self.assertEqual(layout[qr1[2]], 7)
        self.assertEqual(layout[qr1[3]], 3)
        self.assertEqual(layout[qr1[4]], 15)
        self.assertEqual(pass_.property_set['CSPLayout_stop_reason'], 'solution found')
コード例 #10
0
    def test_9q_circuit_16q_coupling_sd(self):
        """9 qubits in Rueschlikon, 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=True,
                          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]], 10)
        self.assertEqual(layout[qr1[4]], 8)
        self.assertEqual(pass_.property_set["CSPLayout_stop_reason"],
                         "solution found")
コード例 #11
0
    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)
コード例 #12
0
 def run_with_api(self, api):
     """Creates a new ``IBMQJob`` running with the provided API object."""
     backend = FakeRueschlikon()
     self._current_api = api
     self._current_qjob = IBMQJob(backend, None, api, qobj=new_fake_qobj())
     self._current_qjob.submit()
     return self._current_qjob
コード例 #13
0
    def test_already_mapped(self):
        """Circuit not remapped if matches topology.

        See: https://github.com/Qiskit/qiskit-terra/issues/342
        """
        backend = FakeRueschlikon()
        qr = QuantumRegister(16, 'qr')
        cr = ClassicalRegister(16, 'cr')
        qc = QuantumCircuit(qr, cr)
        qc.cx(qr[3], qr[14])
        qc.cx(qr[5], qr[4])
        qc.h(qr[9])
        qc.cx(qr[9], qr[8])
        qc.x(qr[11])
        qc.cx(qr[3], qr[4])
        qc.cx(qr[12], qr[11])
        qc.cx(qr[13], qr[4])
        for j in range(16):
            qc.measure(qr[j], cr[j])
        qobj = compile(qc, backend=backend)
        cx_qubits = [x.qubits
                     for x in qobj.experiments[0].instructions
                     if x.name == "cx"]

        self.assertEqual(sorted(cx_qubits), [[3, 4], [3, 14], [5, 4],
                                             [9, 8], [12, 11], [13, 4]])
コード例 #14
0
    def test_move_measurements(self):
        """Measurements applied AFTER swap mapping.
        """
        backend = FakeRueschlikon()
        cmap = backend.configuration().coupling_map
        circ = QuantumCircuit.from_qasm_file(
            self._get_resource_path('move_measurements.qasm', Path.QASMS))

        lay = [0, 1, 15, 2, 14, 3, 13, 4, 12, 5, 11, 6]
        out = transpile(circ, initial_layout=lay, coupling_map=cmap)
        out_dag = circuit_to_dag(out)
        meas_nodes = out_dag.named_nodes('measure')
        for meas_node in meas_nodes:
            is_last_measure = all([after_measure.type == 'out'
                                   for after_measure in out_dag.quantum_successors(meas_node)])
            self.assertTrue(is_last_measure)
コード例 #15
0
    def test_final_measurement_barrier_for_devices(self, mock_pass):
        """Verify BarrierBeforeFinalMeasurements pass is called in default pipeline for devices."""

        circ = QuantumCircuit.from_qasm_file(self._get_resource_path('example.qasm', Path.QASMS))
        dag_circuit = circuit_to_dag(circ)
        transpile_dag(dag_circuit, coupling_map=FakeRueschlikon().configuration().coupling_map)

        self.assertTrue(mock_pass.called)
コード例 #16
0
    def test_final_measurement_barrier_for_devices(self, mock_pass):
        """Verify BarrierBeforeFinalMeasurements pass is called in default pipeline for devices."""

        circ = QuantumCircuit.from_qasm_file(self._get_resource_path('example.qasm', Path.QASMS))
        layout = Layout.generate_trivial_layout(*circ.qregs)
        transpile(circ, coupling_map=FakeRueschlikon().configuration().coupling_map,
                  initial_layout=layout)

        self.assertTrue(mock_pass.called)
コード例 #17
0
    def test_compile_with_initial_layout(self):
        """Test compile with an initial layout.
        Regression test for #1711
        """
        qr = QuantumRegister(3)
        cr = ClassicalRegister(3)
        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)}
        backend = FakeRueschlikon()

        qobj = compile(qc, backend, seed=42, initial_layout=initial_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]])
コード例 #18
0
 def test_optimization_level(self):
     """Test several backends with all optimization levels"""
     for backend in [FakeTenerife(), FakeMelbourne(), FakeRueschlikon(), FakeTokyo()]:
         for optimization_level in range(4):
             result = transpile(
                 [self._circuit],
                 backend=backend,
                 optimization_level=optimization_level
             )
             self.assertIsInstance(result, QuantumCircuit)
コード例 #19
0
    def test_move_measurements(self):
        """Measurements applied AFTER swap mapping.
        """
        backend = FakeRueschlikon()
        cmap = backend.configuration().coupling_map
        qasm_dir = os.path.join(
            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
            'qasm')
        circ = QuantumCircuit.from_qasm_file(
            os.path.join(qasm_dir, 'move_measurements.qasm'))

        lay = [0, 1, 15, 2, 14, 3, 13, 4, 12, 5, 11, 6]
        out = transpile(circ, initial_layout=lay, coupling_map=cmap)
        out_dag = circuit_to_dag(out)
        meas_nodes = out_dag.named_nodes('measure')
        for meas_node in meas_nodes:
            is_last_measure = all(after_measure.type == 'out'
                                  for after_measure in out_dag.quantum_successors(meas_node))
            self.assertTrue(is_last_measure)
コード例 #20
0
    def test_empty_dag(self):
        """ Empty DAG."""
        circuit = QuantumCircuit()
        passmanager = PassManager()
        passmanager.append(ResourceEstimation())
        _ = transpile(circuit, FakeRueschlikon(), pass_manager=passmanager)

        self.assertEqual(passmanager.property_set['size'], 0)
        self.assertEqual(passmanager.property_set['depth'], 0)
        self.assertEqual(passmanager.property_set['width'], 0)
        self.assertDictEqual(passmanager.property_set['count_ops'], {})
コード例 #21
0
 def test_final_measurement_barrier_for_devices(self):
     """Verify BarrierBeforeFinalMeasurements pass is called in default pipeline for devices."""
     qasm_dir = os.path.join(
         os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
         'qasm')
     circ = QuantumCircuit.from_qasm_file(
         os.path.join(qasm_dir, 'example.qasm'))
     layout = Layout.generate_trivial_layout(*circ.qregs)
     orig_pass = BarrierBeforeFinalMeasurements()
     with patch.object(BarrierBeforeFinalMeasurements, 'run', wraps=orig_pass.run) as mock_pass:
         transpile(circ, coupling_map=FakeRueschlikon().configuration().coupling_map,
                   initial_layout=layout)
         self.assertTrue(mock_pass.called)
コード例 #22
0
 def run_with_api(self, api, job_class=IBMQJobPreQobj):
     """Creates a new ``IBMQJobPreQobj`` instance running with the provided API
     object.
     """
     backend = FakeRueschlikon()
     self._current_api = api
     self._current_qjob = job_class(backend,
                                    None,
                                    api,
                                    False,
                                    qobj=new_fake_qobj())
     self._current_qjob.submit()
     return self._current_qjob
コード例 #23
0
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)
コード例 #24
0
 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)
コード例 #25
0
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)
コード例 #26
0
    def test_do_not_run_cxdirection_with_symmetric_cm(self):
        """When the coupling map is symmetric, do not run CXDirection."""

        circ = QuantumCircuit.from_qasm_file(self._get_resource_path('example.qasm', Path.QASMS))
        layout = Layout.generate_trivial_layout(*circ.qregs)
        coupling_map = []
        for node1, node2 in FakeRueschlikon().configuration().coupling_map:
            coupling_map.append([node1, node2])
            coupling_map.append([node2, node1])

        cxdir_pass = CXDirection(CouplingMap(coupling_map))
        with unittest.mock.patch.object(CXDirection, 'run', wraps=cxdir_pass.run) as mock_pass:
            transpile(circ, coupling_map=coupling_map, initial_layout=layout)
            self.assertFalse(mock_pass.called)
コード例 #27
0
 def test_mapping_already_satisfied(self):
     """Test compiler doesn't change circuit already matching backend coupling
     """
     backend = FakeRueschlikon()
     qr = QuantumRegister(16)
     cr = ClassicalRegister(16)
     qc = QuantumCircuit(qr, cr)
     qc.h(qr[1])
     qc.x(qr[2])
     qc.x(qr[3])
     qc.x(qr[4])
     qc.cx(qr[1], qr[2])
     qc.cx(qr[2], qr[3])
     qc.cx(qr[3], qr[4])
     qc.cx(qr[3], qr[14])
     qc.measure(qr, cr)
     qobj = compile(qc, backend)
     compiled_ops = qobj.experiments[0].instructions
     original_cx_qubits = [[1, 2], [2, 3], [3, 4], [3, 14]]
     for operation in compiled_ops:
         if operation.name == 'cx':
             self.assertIn(operation.qubits, backend.configuration().coupling_map)
             self.assertIn(operation.qubits, original_cx_qubits)
コード例 #28
0
    def test_optimize_h_gates(self):
        """ Transpile: qr:--[H]-[H]-[H]-- == qr:--[u2]-- """
        qr = QuantumRegister(1, 'qr')
        circuit = QuantumCircuit(qr)
        circuit.h(qr[0])
        circuit.h(qr[0])
        circuit.h(qr[0])

        expected = QuantumCircuit(qr)
        expected.u2(0, np.pi, qr[0])

        passmanager = PassManager()
        passmanager.append(Optimize1qGates())
        result = transpile(circuit, FakeRueschlikon(), pass_manager=passmanager)
        self.assertEqual(expected, result)
コード例 #29
0
    def test_wait_for_final_state_timeout(self):
        """Test timeout waiting for job to reach a final state."""
        job_id = str(uuid.uuid4())
        backend = FakeRueschlikon()
        with mocked_executor() as (BasicAerJob, executor):
            job = BasicAerJob(backend, job_id, lambda: None, FakeQobj())
            job.submit()

        mocked_future = executor.submit.return_value
        mocked_future.running.return_value = True
        mocked_future.cancelled.return_value = False
        mocked_future.done.return_value = False
        self.assertRaises(JobTimeoutError,
                          job.wait_for_final_state,
                          timeout=0.5)
コード例 #30
0
    def test_cancel(self):
        # Again, cancelling jobs is beyond our responsibility. In this test
        # we only check if we delegate on the proper method of the underlaying
        # future object.

        job_id = str(uuid.uuid4())
        backend = FakeRueschlikon()
        with mocked_executor() as (BasicAerJob, executor):
            job = BasicAerJob(backend, job_id, lambda: None, FakeQobj())
            job.submit()
            job.cancel()

        self.assertCalledOnce(executor.submit)
        mocked_future = executor.submit.return_value
        self.assertCalledOnce(mocked_future.cancel)