Beispiel #1
0
    def test_expand_method(self):
        """Test expand method"""
        samples = 10
        rng = np.random.default_rng(333)
        for num_qubits_1 in range(1, 5):
            for num_qubits_2 in range(1, 5):
                for _ in range(samples):
                    elem1 = random_cnotdihedral(num_qubits_1, seed=rng)
                    elem2 = random_cnotdihedral(num_qubits_2, seed=rng)
                    circ1 = elem1.to_instruction()
                    circ2 = elem2.to_instruction()
                    value = elem2.expand(elem1)
                    circ = QuantumCircuit(num_qubits_1 + num_qubits_2)
                    qargs = list(range(num_qubits_1))
                    for instr, qregs, _ in circ1.definition:
                        new_qubits = [qargs[tup.index] for tup in qregs]
                        circ.append(instr, new_qubits)
                    qargs = list(range(num_qubits_1, num_qubits_1 + num_qubits_2))
                    for instr, qregs, _ in circ2.definition:
                        new_qubits = [qargs[tup.index] for tup in qregs]
                        circ.append(instr, new_qubits)
                    target = CNOTDihedral(circ)

                    self.assertEqual(target, value,
                                     'Error: expand circuit is not the same')
    def test_tensor_method(self):
        """Test tensor method"""
        samples = 10
        rng = np.random.default_rng(333)
        for num_qubits_1 in range(1, 5):
            for num_qubits_2 in range(1, 5):
                for _ in range(samples):
                    elem1 = random_cnotdihedral(num_qubits_1, seed=rng)
                    elem2 = random_cnotdihedral(num_qubits_2, seed=rng)
                    circ1 = elem1.to_instruction()
                    circ2 = elem2.to_instruction()
                    value = elem1.tensor(elem2)
                    circ = QuantumCircuit(num_qubits_1 + num_qubits_2)
                    qargs = list(range(num_qubits_1))
                    for instruction in circ1.definition:
                        new_qubits = [
                            qargs[circ1.definition.qubits.index(tup)] for tup in instruction.qubits
                        ]
                        circ.append(instruction.operation, new_qubits)
                    qargs = list(range(num_qubits_1, num_qubits_1 + num_qubits_2))
                    for instruction in circ2.definition:
                        new_qubits = [
                            qargs[circ2.definition.qubits.index(tup)] for tup in instruction.qubits
                        ]
                        circ.append(instruction.operation, new_qubits)
                    target = CNOTDihedral(circ)

                    self.assertEqual(target, value, "Error: tensor circuit is not the same")
Beispiel #3
0
    def test_random_decompose(self):
        """
        Test that random elements are CNOTDihedral
        and to_circuit, to_instruction, _from_circuit, _is_valid methods
        """
        rng = np.random.default_rng(1234)
        samples = 10
        for num_qubits in range(1, 9):
            for _ in range(samples):
                # Test of random_cnotdihedral method
                elem = random_cnotdihedral(num_qubits, seed=rng)
                self.assertIsInstance(
                    elem, CNOTDihedral,
                    "Error: random element is not CNOTDihedral")
                self.assertTrue(elem._is_valid(),
                                "Error: random element is not CNOTDihedral")

                # Test of to_circuit and _from_circuit methods
                test_circ = elem.to_circuit()
                self.assertTrue(
                    test_circ,
                    "Error: cannot decompose a random "
                    "CNOTDihedral element to a circuit",
                )
                test_elem = CNOTDihedral(test_circ)

                self.assertEqual(
                    elem,
                    test_elem,
                    "Error: decomposed circuit is not equal "
                    "to the original circuit",
                )
                # Test that _is_valid fails if linear part is wrong
                test_elem.linear = np.zeros((num_qubits, num_qubits))
                value = test_elem._is_valid()
                self.assertFalse(
                    value, "Error: CNOTDihedral _is_valid is not correct.")

                # Test of to_instruction and _from_circuit methods
                test_gates = elem.to_instruction()
                self.assertIsInstance(
                    test_gates,
                    Gate,
                    "Error: cannot decompose a random "
                    "CNOTDihedral element to a Gate",
                )
                self.assertEqual(
                    test_gates.num_qubits,
                    test_circ.num_qubits,
                    "Error: wrong num_qubits in decomposed gates",
                )
                test_elem1 = CNOTDihedral(test_gates)
                self.assertEqual(
                    elem,
                    test_elem1,
                    "Error: decomposed gates are not equal "
                    "to the original gates",
                )