def circuit_tester(prep, test_circ):
    for gate in test_circ.gates():
        id = gate.gate_id()
        target = gate.target()
        control = gate.control()

        num_qubits = 5

        qc1 = Computer(num_qubits)
        qc2 = Computer(num_qubits)

        qc1.apply_circuit_safe(prep)
        qc2.apply_circuit_safe(prep)

        qc1.apply_gate_safe(gate)
        qc2.apply_gate(gate)

        C1 = qc1.get_coeff_vec()
        C2 = qc2.get_coeff_vec()

        diff_vec = [(C1[i] - C2[i]) * np.conj(C1[i] - C2[i])
                    for i in range(len(C1))]
        diff_norm = np.sum(diff_vec)

        if (np.sum(diff_vec) != (0.0 + 0.0j)):
            print('|C - C_safe|F^2   control   target   id')
            print('----------------------------------------')
            print(diff_norm, '              ', control, '       ', target,
                  '      ', id)

        return diff_norm
Ejemplo n.º 2
0
    def test_cX_gate(self):
        # test the cX/CNOT gate
        nqubits = 2
        basis0 = make_basis('00')  # basis0:|00>
        basis1 = make_basis('01')  # basis1:|10>
        basis2 = make_basis('10')  # basis2:|01>
        basis3 = make_basis('11')  # basis3:|11>
        computer = Computer(nqubits)
        CNOT = gate('CNOT', 0, 1)

        # test CNOT|00> = |00>
        computer.set_state([(basis0, 1.0)])
        computer.apply_gate(CNOT)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(1.0, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)

        # test CNOT|10> = |11>
        computer.set_state([(basis1, 1.0)])
        computer.apply_gate(CNOT)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3 == approx(1, abs=1.0e-16)

        # test CNOT|01> = |01>
        computer.set_state([(basis2, 1.0)])
        computer.apply_gate(CNOT)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(1, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)

        # test CNOT|11> = |10>
        computer.set_state([(basis3, 1.0)])
        computer.apply_gate(CNOT)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1 == approx(1, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)

        with pytest.raises(ValueError):
            gate('CNOT', 0, 1.0)
Ejemplo n.º 3
0
    def test_cY_gate(self):
        # test the cY gate
        nqubits = 2
        basis0 = make_basis('00')  # basis0:|00>
        basis1 = make_basis('01')  # basis1:|10>
        basis2 = make_basis('10')  # basis2:|01>
        basis3 = make_basis('11')  # basis3:|11>
        computer = Computer(nqubits)
        cY = gate('cY', 0, 1)

        # test cY|00> = |00>
        computer.set_state([(basis0, 1.0)])
        computer.apply_gate(cY)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(1, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)

        # test cY|01> = |01>
        computer.set_state([(basis2, 1.0)])
        computer.apply_gate(cY)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(1, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)

        # test cY|10> = i|11>
        computer.set_state([(basis1, 1.0)])
        computer.apply_gate(cY)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1 == approx(0, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3.imag == approx(1, abs=1.0e-16)

        # test cY|11> = -i|10>
        computer.set_state([(basis3, 1.0)])
        computer.apply_gate(cY)
        coeff0 = computer.coeff(basis0)
        coeff1 = computer.coeff(basis1)
        coeff2 = computer.coeff(basis2)
        coeff3 = computer.coeff(basis3)
        assert coeff0 == approx(0, abs=1.0e-16)
        assert coeff1.imag == approx(-1.0, abs=1.0e-16)
        assert coeff2 == approx(0, abs=1.0e-16)
        assert coeff3 == approx(0, abs=1.0e-16)
Ejemplo n.º 4
0
 def test_Z_gate(self):
     # test the Pauli Y gate
     nqubits = 1
     basis0 = make_basis('0')
     basis1 = make_basis('1')
     computer = Computer(nqubits)
     Z = gate('Z', 0, 0)
     # test Z|0> = |0>
     computer.apply_gate(Z)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0 == approx(1, abs=1.0e-16)
     assert coeff1 == approx(0, abs=1.0e-16)
     # test Z|1> = -|1>
     computer.set_state([(basis1, 1.0)])
     computer.apply_gate(Z)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0 == approx(0, abs=1.0e-16)
     assert coeff1 == approx(-1.0, abs=1.0e-16)
Ejemplo n.º 5
0
 def test_Y_gate(self):
     # test the Pauli Y gate
     nqubits = 1
     basis0 = make_basis('0')
     basis1 = make_basis('1')
     computer = Computer(nqubits)
     Y = gate('Y', 0, 0)
     # test Y|0> = i|1>
     computer.apply_gate(Y)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0 == approx(0, abs=1.0e-16)
     assert coeff1.imag == approx(1.0, abs=1.0 - 16)
     # test Y|1> = -i|0>
     computer.set_state([(basis1, 1.0)])
     computer.apply_gate(Y)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0.imag == approx(-1, abs=1.0e-16)
     assert coeff1 == approx(0, abs=1.0e-16)
Ejemplo n.º 6
0
 def test_X_gate(self):
     # test the Pauli X gate
     nqubits = 1
     basis0 = make_basis('0')
     basis1 = make_basis('1')
     computer = Computer(nqubits)
     X = gate('X', 0)
     # test X|0> = |1>
     computer.apply_gate(X)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0 == approx(0, abs=1.0e-16)
     assert coeff1 == approx(1, abs=1.0e-16)
     # test X|1> = |0>
     computer.set_state([(basis1, 1.0)])
     computer.apply_gate(X)
     coeff0 = computer.coeff(basis0)
     coeff1 = computer.coeff(basis1)
     assert coeff0 == approx(1, abs=1.0e-16)
     assert coeff1 == approx(0, abs=1.0e-16)
Ejemplo n.º 7
0
    def test_computer(self):
        print('\n')
        # test that 1 - 1 = 0

        # print('\n'.join(qc.str()))
        X = gate('X', 0, 0)
        print(X)
        Y = gate('Y', 0, 0)
        print(Y)
        Z = gate('Z', 0, 0)
        print(Z)
        H = gate('H', 0, 0)
        print(H)
        R = gate('R', 0, 0, 0.1)
        print(R)
        S = gate('S', 0, 0)
        print(S)
        T = gate('T', 0, 0)
        print(T)
        cX = gate('cX', 0, 1)
        print(cX)
        cY = gate('cY', 0, 1)
        print(cY)
        cZ = gate('cZ', 0, 1)
        print(cZ)
        # qcircuit = Circuit()
        # qcircuit.add(qg)
        # qcircuit.add(Gate(GateType.Hgate,1,1));
        # print('\n'.join(qcircuit.str()))
        # self.assertEqual(subtract(1, 1), 0)

        computer = Computer(16)
        # print(repr(computer))
        # circuit = Circuit()
        # circuit.add(X)
        for i in range(3000):
            computer.apply_gate(X)
            computer.apply_gate(Y)
            computer.apply_gate(Z)
            computer.apply_gate(H)
Ejemplo n.º 8
0
    def test_trotterization_with_controlled_U(self):

        circ_vec = [build_circuit('Y_0 X_1'), build_circuit('X_0 Y_1')]
        coef_vec = [-1.0719145972781818j, 1.0719145972781818j]

        # the operator to be exponentiated
        minus_iH = QubitOperator()
        for i in range(len(circ_vec)):
            minus_iH.add(coef_vec[i], circ_vec[i])

        ancilla_idx = 2

        # exponentiate the operator
        Utrot, phase = trotterization.trotterize_w_cRz(minus_iH, ancilla_idx)

        # Case 1: positive control

        # initalize a quantum computer
        qc = Computer(3)

        # build HF state
        qc.apply_gate(gate('X', 0, 0))

        # put ancilla in |1> state
        qc.apply_gate(gate('X', 2, 2))

        # apply the troterized minus_iH
        qc.apply_circuit(Utrot)

        smart_print(qc)

        coeffs = qc.get_coeff_vec()

        assert coeffs[5] == approx(-0.5421829373021542, abs=1.0e-15)
        assert coeffs[6] == approx(-0.8402604730072732, abs=1.0e-15)

        # Case 2: negitive control

        # initalize a quantum computer
        qc = Computer(3)

        # build HF state
        qc.apply_gate(gate('X', 0, 0))

        # apply the troterized minus_iH
        qc.apply_circuit(Utrot)

        smart_print(qc)

        coeffs = qc.get_coeff_vec()

        assert coeffs[1] == approx(1, abs=1.0e-15)