Exemple #1
0
 def _define_decompositions(self):
     """
     gate cz a,b { h b; cx a,b; h b; }
     """
     decomposition = DAGCircuit()
     q = QuantumRegister(2, "q")
     decomposition.add_qreg(q)
     decomposition.add_basis_element("h", 1, 0, 0)
     decomposition.add_basis_element("cx", 2, 0, 0)
     rule = [
         HGate(q[1]),
         CnotGate(q[0], q[1]),
         HGate(q[1])
     ]
     for inst in rule:
         decomposition.apply_operation_back(inst)
     self._decompositions = [decomposition]
Exemple #2
0
    def test_get_op_nodes_particular(self):
        """The method dag.gates_nodes(op=AGate) returns all the AGate nodes"""
        self.dag.apply_operation_back(HGate(), [self.qubit0], [])
        self.dag.apply_operation_back(HGate(), [self.qubit1], [])
        self.dag.apply_operation_back(Reset(), [self.qubit0], [])

        self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit1],
                                      [])

        op_nodes = self.dag.op_nodes(op=HGate)
        self.assertEqual(len(op_nodes), 2)

        op_node_1 = op_nodes.pop()
        op_node_2 = op_nodes.pop()

        self.assertIsInstance(op_node_1.op, HGate)
        self.assertIsInstance(op_node_2.op, HGate)
    def test_apply_operation_front(self):
        """The apply_operation_front() method"""
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_front(Reset(self.qubit0))
        h_node = self.dag.op_nodes(op=HGate).pop()
        reset_node = self.dag.op_nodes(op=Reset).pop()

        self.assertIn(reset_node, set(self.dag.predecessors(h_node)))
    def test_topological_op_nodes(self):
        """The topological_op_nodes() method"""
        self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit1],
                                      [])
        self.dag.apply_operation_back(HGate(), [self.qubit0], [])
        self.dag.apply_operation_back(CnotGate(), [self.qubit2, self.qubit1],
                                      [])
        self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit2],
                                      [])
        self.dag.apply_operation_back(HGate(), [self.qubit2], [])

        named_nodes = self.dag.topological_op_nodes()

        expected = [('cx', [self.qubit0, self.qubit1]), ('h', [self.qubit0]),
                    ('cx', [self.qubit2, self.qubit1]),
                    ('cx', [self.qubit0, self.qubit2]), ('h', [self.qubit2])]
        self.assertEqual(expected, [(i.name, i.qargs) for i in named_nodes])
    def test_remove_op_node_longer(self):
        """Test remove_op_node method in a "longer" dag"""
        self.dag.apply_operation_back(CXGate(), [self.qubit0, self.qubit1])
        self.dag.apply_operation_back(HGate(), [self.qubit0])
        self.dag.apply_operation_back(CXGate(), [self.qubit2, self.qubit1])
        self.dag.apply_operation_back(CXGate(), [self.qubit0, self.qubit2])
        self.dag.apply_operation_back(HGate(), [self.qubit2])

        op_nodes = list(self.dag.topological_op_nodes())
        self.dag.remove_op_node(op_nodes[0])

        expected = [('h', [self.qubit0]),
                    ('cx', [self.qubit2, self.qubit1]),
                    ('cx', [self.qubit0, self.qubit2]),
                    ('h', [self.qubit2])]
        self.assertEqual(expected,
                         [(i.name, i.qargs) for i in self.dag.topological_op_nodes()])
Exemple #6
0
 def _dec_ucg(self):
     """
     Call to create a circuit that implements the uniformly controlled gate. If
     up_to_diagonal=True, the circuit implements the gate up to a diagonal gate and
     the diagonal gate is also returned.
     """
     diag = np.ones(2**self.num_qubits).tolist()
     q = QuantumRegister(self.num_qubits)
     q_controls = q[1:]
     q_target = q[0]
     circuit = QuantumCircuit(q)
     # If there is no control, we use the ZYZ decomposition
     if not q_controls:
         theta, phi, lamb = euler_angles_1q(self.params[0])
         circuit.u3(theta, phi, lamb, q)
         return circuit, diag
     # If there is at least one control, first,
     # we find the single qubit gates of the decomposition.
     (single_qubit_gates, diag) = self._dec_ucg_help()
     # Now, it is easy to place the C-NOT gates and some Hadamards and Rz(pi/2) gates
     # (which are absorbed into the single-qubit unitaries) to get back the full decomposition.
     for i, gate in enumerate(single_qubit_gates):
         # Absorb Hadamards and Rz(pi/2) gates
         if i == 0:
             squ = HGate().to_matrix().dot(gate)
         elif i == len(single_qubit_gates) - 1:
             squ = gate.dot(UCG._rz(np.pi / 2)).dot(HGate().to_matrix())
         else:
             squ = HGate().to_matrix().dot(gate.dot(UCG._rz(
                 np.pi / 2))).dot(HGate().to_matrix())
         # Add single-qubit gate
         circuit.squ(squ, q_target)
         # The number of the control qubit is given by the number of zeros at the end
         # of the binary representation of (i+1)
         binary_rep = np.binary_repr(i + 1)
         num_trailing_zeros = len(binary_rep) - len(binary_rep.rstrip('0'))
         q_contr_index = num_trailing_zeros
         # Add C-NOT gate
         if not i == len(single_qubit_gates) - 1:
             circuit.cx(q_controls[q_contr_index], q_target)
     if not self.up_to_diagonal:
         # Important: the diagonal gate is given in the computational basis of the qubits
         # q[k-1],...,q[0],q_target (ordered with decreasing significance),
         # where q[i] are the control qubits and t denotes the target qubit.
         circuit.diag_gate(diag.tolist(), q)
     return circuit, diag
Exemple #7
0
    def test_remove_op_node(self):
        """Test remove_op_node method."""
        self.dag.apply_operation_back(HGate(), [self.qubit0])

        op_nodes = self.dag.gate_nodes()
        h_gate = op_nodes.pop()
        self.dag.remove_op_node(h_gate)

        self.assertEqual(len(self.dag.gate_nodes()), 0)
Exemple #8
0
    def test_get_op_nodes_particular(self):
        """The method dag.get_gates_nodes(op=AGate) returns all the AGate nodes"""
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_back(HGate(self.qubit1))
        self.dag.apply_operation_back(Reset(self.qubit0))

        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))

        op_nodes = self.dag.get_op_nodes(op=HGate(self.qubit0))
        self.assertEqual(len(op_nodes), 2)

        op_node_1 = op_nodes.pop()
        op_node_2 = op_nodes.pop()

        self.assertIsInstance(self.dag.multi_graph.nodes[op_node_1]["op"],
                              HGate)
        self.assertIsInstance(self.dag.multi_graph.nodes[op_node_2]["op"],
                              HGate)
Exemple #9
0
    def test_instructions_equal(self):
        """Test equality of two instructions."""
        hop1 = Instruction('h', 1, 0, [])
        hop2 = Instruction('s', 1, 0, [])
        hop3 = Instruction('h', 1, 0, [])

        uop1 = Instruction('u', 1, 0, [0.4, 0.5, 0.5])
        uop2 = Instruction('u', 1, 0, [0.4, 0.6, 0.5])
        uop3 = Instruction('v', 1, 0, [0.4, 0.5, 0.5])
        uop4 = Instruction('u', 1, 0, [0.4, 0.5, 0.5])
        self.assertFalse(hop1 == hop2)
        self.assertTrue(hop1 == hop3)
        self.assertFalse(uop1 == uop2)
        self.assertTrue(uop1 == uop4)
        self.assertFalse(uop1 == uop3)
        self.assertTrue(HGate() == HGate())
        self.assertFalse(HGate() == CnotGate())
        self.assertFalse(hop1 == HGate())
Exemple #10
0
 def _define(self):
     """
     gate iswap a,b {
         s q[0];
         s q[1];
         h q[0];
         cx q[0],q[1];
         cx q[1],q[0];
         h q[1];
     }
     """
     from qiskit.extensions.standard.h import HGate
     from qiskit.extensions.standard.s import SGate
     from qiskit.extensions.standard.x import CXGate
     q = QuantumRegister(2, 'q')
     self.definition = [(SGate(), [q[0]], []), (SGate(), [q[1]], []),
                        (HGate(), [q[0]], []), (CXGate(), [q[0], q[1]], []),
                        (CXGate(), [q[1], q[0]], []), (HGate(), [q[1]], [])]
Exemple #11
0
    def test_substitute_circuit_one_middle(self):
        """The method substitute_node_with_dag() replaces a in-the-middle node with a DAG."""
        cx_node = self.dag.op_nodes(op=CnotGate).pop()

        flipped_cx_circuit = DAGCircuit()
        v = QuantumRegister(2, "v")
        flipped_cx_circuit.add_qreg(v)
        flipped_cx_circuit.apply_operation_back(HGate(), [v[0]], [])
        flipped_cx_circuit.apply_operation_back(HGate(), [v[1]], [])
        flipped_cx_circuit.apply_operation_back(CnotGate(), [v[1], v[0]], [])
        flipped_cx_circuit.apply_operation_back(HGate(), [v[0]], [])
        flipped_cx_circuit.apply_operation_back(HGate(), [v[1]], [])

        self.dag.substitute_node_with_dag(cx_node,
                                          flipped_cx_circuit,
                                          wires=[v[0], v[1]])

        self.assertEqual(self.dag.count_ops()['h'], 5)
    def test_get_named_nodes(self):
        """The get_named_nodes(AName) method returns all the nodes with name AName"""
        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_back(CnotGate(self.qubit2, self.qubit1))
        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit2))
        self.dag.apply_operation_back(HGate(self.qubit2))

        # The ordering is not assured, so we only compare the output (unordered) sets.
        # We use tuples because lists aren't hashable.
        named_nodes = self.dag.get_named_nodes('cx')
        node_qargs = {tuple(self.dag.multi_graph.node[node_id]["op"].qargs)
                      for node_id in named_nodes}
        expected_qargs = {
            (self.qubit0, self.qubit1),
            (self.qubit2, self.qubit1),
            (self.qubit0, self.qubit2)}
        self.assertEqual(expected_qargs, node_qargs)
 def test_apply_operation_back(self):
     """The apply_operation_back() method."""
     self.dag.apply_operation_back(HGate(self.qubit0), condition=None)
     self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1), condition=None)
     self.dag.apply_operation_back(Measure(self.qubit1, self.clbit1), condition=None)
     self.dag.apply_operation_back(XGate(self.qubit1), condition=self.condition)
     self.dag.apply_operation_back(Measure(self.qubit0, self.clbit0), condition=None)
     self.dag.apply_operation_back(Measure(self.qubit1, self.clbit1), condition=None)
     self.assertEqual(len(self.dag.multi_graph.nodes), 16)
     self.assertEqual(len(self.dag.multi_graph.edges), 17)
    def test_substitute_circuit_one_middle(self):
        """The method substitute_circuit_one() replaces a in-the-middle node with a DAG."""
        cx_node = self.dag.get_op_nodes(op=CnotGate(self.qubit0, self.qubit1)).pop()

        flipped_cx_circuit = DAGCircuit()
        v = QuantumRegister(2, "v")
        flipped_cx_circuit.add_qreg(v)
        flipped_cx_circuit.add_basis_element("cx", 2)
        flipped_cx_circuit.add_basis_element("h", 1)
        flipped_cx_circuit.apply_operation_back(HGate(v[0]))
        flipped_cx_circuit.apply_operation_back(HGate(v[1]))
        flipped_cx_circuit.apply_operation_back(CnotGate(v[1], v[0]))
        flipped_cx_circuit.apply_operation_back(HGate(v[0]))
        flipped_cx_circuit.apply_operation_back(HGate(v[1]))

        self.dag.substitute_circuit_one(cx_node, input_circuit=flipped_cx_circuit,
                                        wires=[v[0], v[1]])

        self.assertEqual(self.dag.count_ops()['h'], 5)
 def test_apply_operation_back(self):
     """The apply_operation_back() method."""
     self.dag.apply_operation_back(HGate(), [self.qubit0], [], condition=None)
     self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit1], [], condition=None)
     self.dag.apply_operation_back(Measure(), [self.qubit1, self.clbit1], [], condition=None)
     self.dag.apply_operation_back(XGate(), [self.qubit1], [], condition=self.condition)
     self.dag.apply_operation_back(Measure(), [self.qubit0, self.clbit0], [], condition=None)
     self.dag.apply_operation_back(Measure(), [self.qubit1, self.clbit1], [], condition=None)
     self.assertEqual(len(list(self.dag.nodes())), 16)
     self.assertEqual(len(list(self.dag.edges())), 17)
Exemple #16
0
    def test_substituting_io_node_raises(self, inplace):
        """Verify replacing an io node raises."""
        dag = DAGCircuit()
        qr = QuantumRegister(1)
        dag.add_qreg(qr)

        io_node = next(dag.nodes())

        with self.assertRaises(DAGCircuitError) as _:
            dag.substitute_node(io_node, HGate(), inplace=inplace)
Exemple #17
0
 def _define_decompositions(self):
     decomposition = DAGCircuit()
     q = QuantumRegister(5, "q")
     decomposition.add_qreg(q)
     decomposition.add_basis_element("u1", 1, 0, 1)
     decomposition.add_basis_element("h", 1, 0, 0)
     decomposition.add_basis_element("x", 1, 0, 0)
     decomposition.add_basis_element("cx", 2, 0, 0)
     decomposition.add_basis_element("ccx", 3, 0, 0)
     decomposition.add_basis_element("c3x", 4, 0, 0)
     decomposition.add_basis_element("t", 1, 0, 0)
     decomposition.add_basis_element("tdg", 1, 0, 0)
     rule = [
         HGate(q[4]),
         C3NotGate(q[0], q[1], q[2], q[4]),
         TdgGate(q[4]),
         CnotGate(q[3], q[4]),
         TGate(q[4]),
         C3NotGate(q[0], q[1], q[2], q[4]),
         TdgGate(q[4]),
         CnotGate(q[3], q[4]),
         TGate(q[4]),
         HGate(q[4]),
         C3NotGate(q[0], q[1], q[2], q[3]),
         ToffoliGate(q[0], q[1], q[2]),
         CnotGate(q[0], q[1]),
         XGate(q[0]),
         U1Gate(-math.pi / 16, q[1]),
         U1Gate(-math.pi / 8, q[2]),
         U1Gate(-math.pi / 4, q[3]),
         XGate(q[0]),
         CnotGate(q[0], q[1]),
         ToffoliGate(q[0], q[1], q[2]),
         C3NotGate(q[0], q[1], q[2], q[3]),
         U1Gate(math.pi / 16, q[0]),
         U1Gate(math.pi / 16, q[1]),
         U1Gate(math.pi / 8, q[2]),
         U1Gate(math.pi / 4, q[3])
     ]
     for inst in rule:
         decomposition.apply_operation_back(inst)
     self._decompositions = [decomposition]
Exemple #18
0
 def _define(self):
     self.definition = []
     q = QuantumRegister(self.num_qubits)
     for i in range(self.num_qubits):
         self.definition.append((HGate(), [q[i]], []))
         for distance in range(self.num_qubits - i - 1):
             distance = distance + 1
             self.definition.append(
                 (Cu1Gate(pi / 2**distance), [q[distance + i], q[i]], []))
     if self.params[0]:
         self.definition.append((DoSwapsGate(self.num_qubits), q, []))
    def test_get_op_nodes_all(self):
        """The method dag.op_nodes() returns all op nodes"""
        self.dag.apply_operation_back(HGate(), [self.qubit0], [])
        self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit1], [])
        self.dag.apply_operation_back(Reset(), [self.qubit0], [])

        op_nodes = self.dag.op_nodes()
        self.assertEqual(len(op_nodes), 3)

        for node in op_nodes:
            self.assertIsInstance(node.op, Instruction)
    def test_get_op_nodes_all(self):
        """The method dag.get_op_nodes() returns all op nodes"""
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))
        self.dag.apply_operation_back(Reset(self.qubit0))

        op_nodes = self.dag.get_op_nodes()
        self.assertEqual(len(op_nodes), 3)

        for node in op_nodes:
            self.assertIsInstance(self.dag.multi_graph.nodes[node]["op"], Instruction)
Exemple #21
0
 def _define(self):
     """Calculate a subcircuit that implements this unitary."""
     from qiskit.extensions.standard.x import CXGate
     from qiskit.extensions.standard.u1 import U1Gate
     from qiskit.extensions.standard.h import HGate
     definition = []
     q = QuantumRegister(2, 'q')
     theta = self.params[0]
     rule = [
         (HGate(), [q[0]], []),
         (HGate(), [q[1]], []),
         (CXGate(), [q[0], q[1]], []),
         (U1Gate(theta), [q[1]], []),
         (CXGate(), [q[0], q[1]], []),
         (HGate(), [q[1]], []),
         (HGate(), [q[0]], []),
     ]
     for inst in rule:
         definition.append(inst)
     self.definition = definition
Exemple #22
0
 def _define(self):
     """
     gate c3sqrtx a,b,c,d
     {
         h d; cu1(-pi/8) a,d; h d;
         cx a,b;
         h d; cu1(pi/8) b,d; h d;
         cx a,b;
         h d; cu1(-pi/8) b,d; h d;
         cx b,c;
         h d; cu1(pi/8) c,d; h d;
         cx a,c;
         h d; cu1(-pi/8) c,d; h d;
         cx b,c;
         h d; cu1(pi/8) c,d; h d;
         cx a,c;
         h d; cu1(-pi/8) c,d; h d;
     }
     gate c4x a,b,c,d,e
     {
         h e; cu1(-pi/2) d,e; h e;
         c3x a,b,c,d;
         h d; cu1(pi/4) d,e; h d;
         c3x a,b,c,d;
         c3sqrtx a,b,c,e;
     }
     """
     from qiskit.extensions.standard.u1 import CU1Gate
     q = QuantumRegister(5, name='q')
     definition = [
         (HGate(), [q[4]], []),
         (CU1Gate(-numpy.pi / 2), [q[3], q[4]], []),
         (HGate(), [q[4]], []),
         (C3XGate(), [q[0], q[1], q[2], q[3]], []),
         (HGate(), [q[4]], []),
         (CU1Gate(numpy.pi / 2), [q[3], q[4]], []),
         (HGate(), [q[4]], []),
         (C3XGate(), [q[0], q[1], q[2], q[3]], []),
         (C3XGate(numpy.pi / 8), [q[0], q[1], q[2], q[4]], []),
     ]
     self.definition = definition
Exemple #23
0
 def _define(self):
     """
     gate ch a,b {
         s b;
         h b;
         t b;
         cx a, b;
         tdg b;
         h b;
         sdg b;
     }
     """
     definition = []
     q = QuantumRegister(2, "q")
     rule = [(SGate(), [q[1]], []), (HGate(), [q[1]], []),
             (TGate(), [q[1]], []), (CnotGate(), [q[0], q[1]], []),
             (TdgGate(), [q[1]], []), (HGate(), [q[1]], []),
             (SdgGate(), [q[1]], [])]
     for inst in rule:
         definition.append(inst)
     self.definition = definition
    def test_get_op_nodes_all(self):
        """The method dag.get_op_nodes() returns all op nodes"""
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))

        op_nodes = self.dag.get_op_nodes()
        self.assertEqual(len(op_nodes), 2)

        op_node_1 = op_nodes.pop()
        op_node_2 = op_nodes.pop()
        self.assertIsInstance(self.dag.multi_graph.nodes[op_node_1]["op"], Gate)
        self.assertIsInstance(self.dag.multi_graph.nodes[op_node_2]["op"], Gate)
Exemple #25
0
    def __init__(self, ctrl1: QubitType, ctrl2: QubitType, target: QubitType,
                 circuit: QuantumCircuit = None):
        """Initialize the CCZGate class.

        :param ctrl1: The first control qubit used to control the CCZ gate.
        :param ctrl2: The second control qubit used to control the CCZ gate.
        :param target: The qubit on which the Z gate is applied.
        :param circuit: The associated quantum circuit.
        """
        used_qubits = [ctrl1, ctrl2, target]

        super().__init__(self.__class__.__name__,  # name
                         [],  # parameters
                         used_qubits,  # qubits
                         circuit)  # circuit

        self.comment("CCZ")
        from qiskit.extensions.standard.h import HGate
        self._attach(HGate(target, circuit).inverse())
        self.ccx(ctrl1, ctrl2, target)
        self._attach(HGate(target, circuit).inverse())
    def test_instructions_equal(self):
        """Test equality of two instructions.
        """
        qr = QuantumRegister(3)
        cr = ClassicalRegister(3)
        hop1 = Instruction('h', [], qr, cr)
        hop2 = Instruction('s', [], qr, cr)
        hop3 = Instruction('h', [], qr, cr)

        uop1 = Instruction('u', [0.4, 0.5, 0.5], qr, cr)
        uop2 = Instruction('u', [0.4, 0.6, 0.5], qr, cr)
        uop3 = Instruction('v', [0.4, 0.5, 0.5], qr, cr)
        uop4 = Instruction('u', [0.4, 0.5, 0.5], qr, cr)
        self.assertFalse(hop1 == hop2)
        self.assertTrue(hop1 == hop3)
        self.assertFalse(uop1 == uop2)
        self.assertTrue(uop1 == uop4)
        self.assertFalse(uop1 == uop3)
        self.assertTrue(HGate(qr[0]) == HGate(qr[1]))
        self.assertFalse(HGate(qr[0]) == CnotGate(qr[0], qr[1]))
        self.assertFalse(hop1 == HGate(qr[2]))
Exemple #27
0
    def test_apply_operation_back_conditional(self):
        """Test consistency of apply_operation_back with condition set."""

        # Single qubit gate conditional: qc.h(qr[2]).c_if(cr, 3)

        h_gate = HGate()
        h_gate.condition = self.condition
        h_node = self.dag.apply_operation_back(
            h_gate, [self.qubit2], [], h_gate.condition)

        self.assertEqual(h_node.qargs, [self.qubit2])
        self.assertEqual(h_node.cargs, [])
        self.assertEqual(h_node.condition, h_gate.condition)

        self.assertEqual(
            sorted(self.dag._get_multi_graph_in_edges(h_node._node_id)),
            sorted([
                (self.dag.input_map[self.qubit2]._node_id, h_node._node_id,
                 {'wire': self.qubit2, 'name': 'qr[2]'}),
                (self.dag.input_map[self.clbit0]._node_id, h_node._node_id,
                 {'wire': self.clbit0, 'name': 'cr[0]'}),
                (self.dag.input_map[self.clbit1]._node_id, h_node._node_id,
                 {'wire': self.clbit1, 'name': 'cr[1]'}),
            ]))

        self.assertEqual(
            sorted(self.dag._get_multi_graph_out_edges(h_node._node_id)),
            sorted([
                (h_node._node_id, self.dag.output_map[self.qubit2]._node_id,
                 {'wire': self.qubit2, 'name': 'qr[2]'}),
                (h_node._node_id, self.dag.output_map[self.clbit0]._node_id,
                 {'wire': self.clbit0, 'name': 'cr[0]'}),
                (h_node._node_id, self.dag.output_map[self.clbit1]._node_id,
                 {'wire': self.clbit1, 'name': 'cr[1]'}),
            ]))

        if self.dag._USE_RX:
            self.assertTrue(rx.is_directed_acyclic_graph(self.dag._multi_graph))
        else:
            self.assertTrue(nx.is_directed_acyclic_graph(self.dag._multi_graph))
Exemple #28
0
    def test_two_q_gates(self):
        """The method dag.twoQ_gates() returns all 2Q gate nodes"""
        self.dag.apply_operation_back(HGate(self.qubit0))
        self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))
        self.dag.apply_operation_back(Barrier((self.qubit0, self.qubit1)))
        self.dag.apply_operation_back(Reset(self.qubit0))

        op_nodes = self.dag.twoQ_gates()
        self.assertEqual(len(op_nodes), 1)

        op_node = op_nodes.pop()
        self.assertIsInstance(op_node["op"], Gate)
        self.assertEqual(len(op_node['qargs']), 2)
    def test_two_q_gates(self):
        """The method dag.twoQ_gates() returns all 2Q gate nodes"""
        self.dag.apply_operation_back(HGate(), [self.qubit0], [])
        self.dag.apply_operation_back(CnotGate(), [self.qubit0, self.qubit1], [])
        self.dag.apply_operation_back(Barrier(2), [self.qubit0, self.qubit1], [])
        self.dag.apply_operation_back(Reset(), [self.qubit0], [])

        op_nodes = self.dag.twoQ_gates()
        self.assertEqual(len(op_nodes), 1)

        op_node = op_nodes.pop()
        self.assertIsInstance(op_node.op, Gate)
        self.assertEqual(len(op_node.qargs), 2)
Exemple #30
0
 def _define(self):
     """
     gate ccx a,b,c
     {
     h c; cx b,c; tdg c; cx a,c;
     t c; cx b,c; tdg c; cx a,c;
     t b; t c; h c; cx a,b;
     t a; tdg b; cx a,b;}
     """
     definition = []
     q = QuantumRegister(3, "q")
     rule = [(HGate(), [q[2]], []), (CnotGate(), [q[1], q[2]], []),
             (TdgGate(), [q[2]], []), (CnotGate(), [q[0], q[2]], []),
             (TGate(), [q[2]], []), (CnotGate(), [q[1], q[2]], []),
             (TdgGate(), [q[2]], []), (CnotGate(), [q[0], q[2]], []),
             (TGate(), [q[1]], []), (TGate(), [q[2]], []),
             (HGate(), [q[2]], []), (CnotGate(), [q[0], q[1]], []),
             (TGate(), [q[0]], []), (TdgGate(), [q[1]], []),
             (CnotGate(), [q[0], q[1]], [])]
     for inst in rule:
         definition.append(inst)
     self.definition = definition