def test_get_pauli_2_qubit_proj_3_1_2(self):
        num_qubits = 3
        qubit_pro1 = 1
        qubit_pro2 = 2
        paulis = get_pauli_n_qubit_projection(num_qubits,
                                              [qubit_pro1, qubit_pro2])
        self.assertTrue(len(paulis) == 16)

        X = np.array([[0, 1], [1, 0]], dtype=np.complex128)
        Y = np.array([[0, -1j], [1j, 0]], dtype=np.complex128)
        Z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
        I = np.array([[1, 0], [0, 1]], dtype=np.complex128)

        self.assertTrue(self.in_array(np.kron(np.kron(I, X), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Y), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Z), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, I), I), paulis))

        self.assertTrue(self.in_array(np.kron(np.kron(I, X), X), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Y), X), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Z), X), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, I), X), paulis))

        self.assertTrue(self.in_array(np.kron(np.kron(I, X), Y), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Y), Y), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Z), Y), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, I), Y), paulis))

        self.assertTrue(self.in_array(np.kron(np.kron(I, X), Z), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Y), Z), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, Z), Z), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, I), Z), paulis))
    def test_fixedgate_get_unitary(self):
        reset_tensor_cache()
        fg = FixedGate("Test", 4, 2, (0, 1))

        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            gate = fg.get_unitary(sess)

        paulis = get_pauli_n_qubit_projection(4, (0, 1))
        H = pauli_dot_product([0.25] * 16, paulis)
        U = la.expm(1j * H)
        self.assertTrue(hilbert_schmidt_distance(gate, U) <= 1e-16)
    def test_fixedgate_get_herm ( self ):
        reset_tensor_cache()
        fg = FixedGate( "Test", 4, 2, (0, 1) )
        herm = fg.get_herm()

        with tf.Session() as sess:
            sess.run( tf.global_variables_initializer() )
            herm = herm.eval()

        paulis = get_pauli_n_qubit_projection( 4, (0, 1) )
        H = pauli_dot_product( [ 0.25 ] * 16, paulis )
        self.assertTrue( np.array_equal( herm, H )  )
    def test_genericgate_get_unitary(self):
        reset_tensor_cache()
        lm = LocationModel(4, 2)
        gg = GenericGate("Test", 4, 2, lm, loc_vals=[1, 0, 0, 0, 0, 0])

        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            gate = gg.get_unitary(sess)

        paulis = get_pauli_n_qubit_projection(4, (0, 1))
        H = pauli_dot_product([0.25] * 16, paulis)
        U = la.expm(1j * H)
        self.assertTrue(hilbert_schmidt_distance(gate, U) <= 1e-16)
    def test_genericgate_get_herm(self):
        reset_tensor_cache()
        lm = LocationModel(4, 2)
        gg = GenericGate("Test", 4, 2, lm, loc_vals=[1, 0, 0, 0, 0, 0])
        herm = gg.get_herm()

        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            herm = herm.eval()

        paulis = get_pauli_n_qubit_projection(4, list(lm.locations)[0])
        H = pauli_dot_product([0.25] * 16, paulis)
        self.assertTrue(np.allclose(herm, H, rtol=0, atol=1e-15))
    def test_get_pauli_1_qubit_proj_3_0(self):
        num_qubits = 3
        qubit_proj = 0
        paulis = get_pauli_n_qubit_projection(num_qubits, [qubit_proj])
        self.assertTrue(len(paulis) == 4)

        X = np.array([[0, 1], [1, 0]], dtype=np.complex128)
        Y = np.array([[0, -1j], [1j, 0]], dtype=np.complex128)
        Z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
        I = np.array([[1, 0], [0, 1]], dtype=np.complex128)

        self.assertTrue(self.in_array(np.kron(np.kron(X, I), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(Y, I), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(Z, I), I), paulis))
        self.assertTrue(self.in_array(np.kron(np.kron(I, I), I), paulis))