def test_evals(self):
""" evals test """
# TODO: Think about eval names
self.assertEqual(Z.eval('0').eval('0'), 1)
self.assertEqual(Z.eval('1').eval('0'), 0)
self.assertEqual(Z.eval('0').eval('1'), 0)
self.assertEqual(Z.eval('1').eval('1'), -1)
self.assertEqual(X.eval('0').eval('0'), 0)
self.assertEqual(X.eval('1').eval('0'), 1)
self.assertEqual(X.eval('0').eval('1'), 1)
self.assertEqual(X.eval('1').eval('1'), 0)
self.assertEqual(Y.eval('0').eval('0'), 0)
self.assertEqual(Y.eval('1').eval('0'), -1j)
self.assertEqual(Y.eval('0').eval('1'), 1j)
self.assertEqual(Y.eval('1').eval('1'), 0)
with self.assertRaises(ValueError):
Y.eval('11')
with self.assertRaises(ValueError):
(X ^ Y).eval('1111')
with self.assertRaises(ValueError):
Y.eval((X ^ X).to_matrix_op())
# Check that Pauli logic eval returns same as matrix logic
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('0').eval('0'), 1)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('1').eval('0'), 0)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('0').eval('1'), 0)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('1').eval('1'), -1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval('0').eval('0'), 0)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval('1').eval('0'), 1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval('0').eval('1'), 1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval('1').eval('1'), 0)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('0').eval('0'), 0)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('1').eval('0'), -1j)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('0').eval('1'), 1j)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('1').eval('1'), 0)
pauli_op = Z ^ I ^ X ^ Y
mat_op = PrimitiveOp(pauli_op.to_matrix())
full_basis = list(map(''.join, itertools.product('01', repeat=pauli_op.num_qubits)))
for bstr1, bstr2 in itertools.product(full_basis, full_basis):
# print('{} {} {} {}'.format(bstr1, bstr2, pauli_op.eval(bstr1, bstr2),
# mat_op.eval(bstr1, bstr2)))
np.testing.assert_array_almost_equal(pauli_op.eval(bstr1).eval(bstr2),
mat_op.eval(bstr1).eval(bstr2))
gnarly_op = SummedOp([(H ^ I ^ Y).compose(X ^ X ^ Z).tensor(Z),
PrimitiveOp(Operator.from_label('+r0I')),
3 * (X ^ CX ^ T)], coeff=3 + .2j)
gnarly_mat_op = PrimitiveOp(gnarly_op.to_matrix())
full_basis = list(map(''.join, itertools.product('01', repeat=gnarly_op.num_qubits)))
for bstr1, bstr2 in itertools.product(full_basis, full_basis):
np.testing.assert_array_almost_equal(gnarly_op.eval(bstr1).eval(bstr2),
gnarly_mat_op.eval(bstr1).eval(bstr2))
def test_circuit_op_to_matrix(self):
"""test CircuitOp.to_matrix"""
qc = QuantumCircuit(1)
qc.rz(1.0, 0)
qcop = CircuitOp(qc)
np.testing.assert_array_almost_equal(
qcop.to_matrix(), scipy.linalg.expm(-0.5j * Z.to_matrix()))
def test_to_matrix(self):
"""to matrix text"""
np.testing.assert_array_equal(X.to_matrix(),
Operator.from_label("X").data)
np.testing.assert_array_equal(Y.to_matrix(),
Operator.from_label("Y").data)
np.testing.assert_array_equal(Z.to_matrix(),
Operator.from_label("Z").data)
op1 = Y + H
np.testing.assert_array_almost_equal(op1.to_matrix(),
Y.to_matrix() + H.to_matrix())
op2 = op1 * 0.5
np.testing.assert_array_almost_equal(op2.to_matrix(),
op1.to_matrix() * 0.5)
op3 = (4 - 0.6j) * op2
np.testing.assert_array_almost_equal(op3.to_matrix(),
op2.to_matrix() * (4 - 0.6j))
op4 = op3.tensor(X)
np.testing.assert_array_almost_equal(
op4.to_matrix(), np.kron(op3.to_matrix(), X.to_matrix()))
op5 = op4.compose(H ^ I)
np.testing.assert_array_almost_equal(
op5.to_matrix(), np.dot(op4.to_matrix(), (H ^ I).to_matrix()))
op6 = op5 + PrimitiveOp(Operator.from_label("+r").data)
np.testing.assert_array_almost_equal(
op6.to_matrix(),
op5.to_matrix() + Operator.from_label("+r").data)
param = Parameter("α")
m = np.array([[0, -1j], [1j, 0]])
op7 = MatrixOp(m, param)
np.testing.assert_array_equal(op7.to_matrix(), m * param)
param = Parameter("β")
op8 = PauliOp(primitive=Pauli("Y"), coeff=param)
np.testing.assert_array_equal(op8.to_matrix(), m * param)
param = Parameter("γ")
qc = QuantumCircuit(1)
qc.h(0)
op9 = CircuitOp(qc, coeff=param)
m = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
np.testing.assert_array_equal(op9.to_matrix(), m * param)
def test_pauli_I_Z(self):
"""test from_ising and to_ising with Pauli I and Z"""
with self.subTest("0 * I, linear=False"):
q_p = from_ising(0 * I, linear=False)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 0)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2)))
self.assertAlmostEqual(offset, 0)
with self.subTest("0 * I, linear=True"):
q_p = from_ising(0 * I, linear=True)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 0)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2)))
self.assertAlmostEqual(offset, 0)
with self.subTest("2 * I, linear=False"):
q_p = from_ising(2 * I, linear=False)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 2)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2)))
self.assertAlmostEqual(offset, 2)
with self.subTest("2 * I, linear=True"):
q_p = from_ising(2 * I, linear=True)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 2)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2)))
self.assertAlmostEqual(offset, 2)
with self.subTest("Z, linear=False"):
q_p = from_ising(Z)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 1)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[-2]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), Z.to_matrix())
self.assertAlmostEqual(offset, 0)
with self.subTest("Z, linear=True"):
q_p = from_ising(Z, linear=True)
self.assertEqual(q_p.get_num_vars(), 1)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 1)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [-2])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), Z.to_matrix())
self.assertAlmostEqual(offset, 0)
with self.subTest("3 * II, linear=False"):
q_p = from_ising(3 * I ^ I)
self.assertEqual(q_p.get_num_vars(), 2)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 3)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((4, 4)))
self.assertAlmostEqual(offset, 3)
with self.subTest("3 * II, linear=True"):
q_p = from_ising(3 * I ^ I)
self.assertEqual(q_p.get_num_vars(), 2)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 3)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), np.zeros((4, 4)))
self.assertAlmostEqual(offset, 3)
with self.subTest("IZ, linear=False"):
q_p = from_ising(I ^ Z)
self.assertEqual(q_p.get_num_vars(), 2)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 1)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[-2, 0], [0, 0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), (I ^ Z).to_matrix())
self.assertAlmostEqual(offset, 0)
with self.subTest("IZ, linear=True"):
q_p = from_ising(I ^ Z, linear=True)
self.assertEqual(q_p.get_num_vars(), 2)
self.assertEqual(q_p.get_num_linear_constraints(), 0)
self.assertEqual(q_p.get_num_quadratic_constraints(), 0)
self.assertAlmostEqual(q_p.objective.constant, 1)
np.testing.assert_allclose(q_p.objective.linear.to_array(), [-2, 0])
np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]])
op, offset = to_ising(q_p)
np.testing.assert_allclose(op.to_matrix(), (I ^ Z).to_matrix())
self.assertAlmostEqual(offset, 0)