コード例 #1
0
    def test_apply_operation_back_conditional_measure(self):
        """Test consistency of apply_operation_back for conditional measure."""

        # Measure targeting a clbit which is not a member of the conditional
        # register. qc.measure(qr[0], cr[0]).c_if(cr2, 0)

        new_creg = ClassicalRegister(1, 'cr2')
        self.dag.add_creg(new_creg)

        meas_gate = Measure()
        meas_gate.control = (new_creg, 0)
        meas_node = self.dag.apply_operation_back(meas_gate, [self.qubit0],
                                                  [self.clbit0],
                                                  meas_gate.control)

        self.assertEqual(meas_node.qargs, [self.qubit0])
        self.assertEqual(meas_node.cargs, [self.clbit0])
        self.assertEqual(meas_node.condition, meas_gate.control)

        self.assertEqual(
            sorted(self.dag._multi_graph.in_edges(meas_node, data=True)),
            sorted([
                (self.dag.input_map[self.qubit0], meas_node, {
                    'wire': Qubit(*self.qubit0),
                    'name': 'qr[0]'
                }),
                (self.dag.input_map[self.clbit0], meas_node, {
                    'wire': Clbit(*self.clbit0),
                    'name': 'cr[0]'
                }),
                (self.dag.input_map[new_creg[0]], meas_node, {
                    'wire': Clbit(new_creg, 0),
                    'name': 'cr2[0]'
                }),
            ]))

        self.assertEqual(
            sorted(self.dag._multi_graph.out_edges(meas_node, data=True)),
            sorted([
                (meas_node, self.dag.output_map[self.qubit0], {
                    'wire': Qubit(*self.qubit0),
                    'name': 'qr[0]'
                }),
                (meas_node, self.dag.output_map[self.clbit0], {
                    'wire': Clbit(*self.clbit0),
                    'name': 'cr[0]'
                }),
                (meas_node, self.dag.output_map[new_creg[0]], {
                    'wire': Clbit(new_creg, 0),
                    'name': 'cr2[0]'
                }),
            ]))

        self.assertTrue(nx.is_directed_acyclic_graph(self.dag._multi_graph))
コード例 #2
0
    def test_apply_operation_back_conditional_measure_to_self(self):
        """Test consistency of apply_operation_back for measure onto conditioning bit."""

        # Measure targeting a clbit which _is_ a member of the conditional
        # register. qc.measure(qr[0], cr[0]).c_if(cr, 3)

        meas_gate = Measure()
        meas_gate.control = self.condition
        meas_node = self.dag.apply_operation_back(meas_gate, [self.qubit1],
                                                  [self.clbit1],
                                                  self.condition)

        self.assertEqual(meas_node.qargs, [self.qubit1])
        self.assertEqual(meas_node.cargs, [self.clbit1])
        self.assertEqual(meas_node.condition, meas_gate.control)

        self.assertEqual(
            sorted(self.dag._multi_graph.in_edges(meas_node, data=True)),
            sorted([
                (self.dag.input_map[self.qubit1], meas_node, {
                    'wire': Qubit(*self.qubit1),
                    'name': 'qr[1]'
                }),
                (self.dag.input_map[self.clbit0], meas_node, {
                    'wire': Clbit(*self.clbit0),
                    'name': 'cr[0]'
                }),
                (self.dag.input_map[self.clbit1], meas_node, {
                    'wire': Clbit(*self.clbit1),
                    'name': 'cr[1]'
                }),
            ]))

        self.assertEqual(
            sorted(self.dag._multi_graph.out_edges(meas_node, data=True)),
            sorted([
                (meas_node, self.dag.output_map[self.qubit1], {
                    'wire': Qubit(*self.qubit1),
                    'name': 'qr[1]'
                }),
                (meas_node, self.dag.output_map[self.clbit0], {
                    'wire': Clbit(*self.clbit0),
                    'name': 'cr[0]'
                }),
                (meas_node, self.dag.output_map[self.clbit1], {
                    'wire': Clbit(*self.clbit1),
                    'name': 'cr[1]'
                }),
            ]))

        self.assertTrue(nx.is_directed_acyclic_graph(self.dag._multi_graph))