def test_error_operator_all_diagonal(self):
terms = [
QubitOperator(()),
QubitOperator('Z0 Z1 Z2'),
QubitOperator('Z0 Z3'),
QubitOperator('Z0 Z1 Z2 Z3')
]
zero = QubitOperator()
self.assertTrue(zero.isclose(error_operator(terms)))
def test_z(self):
pauli_z = QubitOperator(((2, 'Z'), ))
transmed_z = reverse_jordan_wigner(pauli_z)
expected = (FermionOperator(()) + FermionOperator(
((2, 1), (2, 0)), -2.))
self.assertTrue(transmed_z.isclose(expected))
retransmed_z = jordan_wigner(transmed_z)
self.assertTrue(pauli_z.isclose(retransmed_z))
def test_bravyi_kitaev_fast_edgeoperator_Aij(self):
# checking the edge operators
edge_matrix = numpy.triu(numpy.ones((4, 4)))
edge_matrix_indices = numpy.array(numpy.nonzero(
numpy.triu(edge_matrix) -
numpy.diag(numpy.diag(edge_matrix))))
correct_operators_a01 = ((0, 'X'),)
correct_operators_a02 = ((0, 'Z'), (1, 'X'))
correct_operators_a03 = ((0, 'Z'), (1, 'Z'), (2, 'X'))
correct_operators_a12 = ((0, 'Z'), (1, 'Z'), (3, 'X'))
correct_operators_a13 = ((0, 'Z'), (2, 'Z'), (3, 'Z'), (4, 'X'))
correct_operators_a23 = ((1, 'Z'), (2, 'Z'), (3, 'Z'),
(4, 'Z'), (5, 'X'))
qterm_a01 = QubitOperator(correct_operators_a01, 1)
qterm_a02 = QubitOperator(correct_operators_a02, 1)
qterm_a03 = QubitOperator(correct_operators_a03, 1)
qterm_a12 = QubitOperator(correct_operators_a12, 1)
qterm_a13 = QubitOperator(correct_operators_a13, 1)
qterm_a23 = QubitOperator(correct_operators_a23, 1)
self.assertTrue(qterm_a01.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 0, 1)))
self.assertTrue(qterm_a02.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 0, 2)))
self.assertTrue(qterm_a03.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 0, 3)))
self.assertTrue(qterm_a12.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 1, 2)))
self.assertTrue(qterm_a13.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 1, 3)))
self.assertTrue(qterm_a23.isclose(_bksf.edge_operator_aij(
edge_matrix_indices, 2, 3)))
def test_xy(self):
xy = QubitOperator(((4, 'X'), (5, 'Y')), -2.j)
transmed_xy = reverse_jordan_wigner(xy)
retransmed_xy = jordan_wigner(transmed_xy)
expected1 = -2j * (FermionOperator(((4, 1), ), 1j) - FermionOperator(
((4, 0), ), 1j))
expected2 = (FermionOperator(((5, 1), )) - FermionOperator(((5, 0), )))
expected = expected1 * expected2
self.assertTrue(xy.isclose(retransmed_xy))
self.assertTrue(
normal_ordered(transmed_xy).isclose(normal_ordered(expected)))
def test_yy(self):
yy = QubitOperator(((2, 'Y'), (3, 'Y')), 2.)
transmed_yy = reverse_jordan_wigner(yy)
retransmed_yy = jordan_wigner(transmed_yy)
expected1 = -(FermionOperator(((2, 1), ), 2.) + FermionOperator(
((2, 0), ), 2.))
expected2 = (FermionOperator(((3, 1), )) - FermionOperator(((3, 0), )))
expected = expected1 * expected2
self.assertTrue(yy.isclose(retransmed_yy))
self.assertTrue(
normal_ordered(transmed_yy).isclose(normal_ordered(expected)))
def test_xx(self):
xx = QubitOperator(((3, 'X'), (4, 'X')), 2.)
transmed_xx = reverse_jordan_wigner(xx)
retransmed_xx = jordan_wigner(transmed_xx)
expected1 = (FermionOperator(((3, 1), ), 2.) - FermionOperator(
((3, 0), ), 2.))
expected2 = (FermionOperator(((4, 1), ), 1.) + FermionOperator(
((4, 0), ), 1.))
expected = expected1 * expected2
self.assertTrue(xx.isclose(retransmed_xx))
self.assertTrue(
normal_ordered(transmed_xx).isclose(normal_ordered(expected)))
def test_yx(self):
yx = QubitOperator(((0, 'Y'), (1, 'X')), -0.5)
transmed_yx = reverse_jordan_wigner(yx)
retransmed_yx = jordan_wigner(transmed_yx)
expected1 = 1j * (FermionOperator(((0, 1), )) + FermionOperator(
((0, 0), )))
expected2 = -0.5 * (FermionOperator(((1, 1), )) + FermionOperator(
((1, 0), )))
expected = expected1 * expected2
self.assertTrue(yx.isclose(retransmed_yx))
self.assertTrue(
normal_ordered(transmed_yx).isclose(normal_ordered(expected)))
def test_jordan_wigner_dual_basis_jellium_constant_shift(self):
length_scale = 0.6
grid = Grid(dimensions=2, length=3, scale=length_scale)
spinless = True
hamiltonian_without_constant = jordan_wigner_dual_basis_jellium(
grid, spinless, include_constant=False)
hamiltonian_with_constant = jordan_wigner_dual_basis_jellium(
grid, spinless, include_constant=True)
difference = hamiltonian_with_constant - hamiltonian_without_constant
expected = QubitOperator('') * (2.8372 / length_scale)
self.assertTrue(expected.isclose(difference))
def test_bravyi_kitaev_fast_edgeoperator_Bi(self):
# checking the edge operators
edge_matrix = numpy.triu(numpy.ones((4, 4)))
edge_matrix_indices = numpy.array(
numpy.nonzero(
numpy.triu(edge_matrix) - numpy.diag(numpy.diag(edge_matrix))))
correct_operators_b0 = ((0, 'Z'), (1, 'Z'), (2, 'Z'))
correct_operators_b1 = ((0, 'Z'), (3, 'Z'), (4, 'Z'))
correct_operators_b2 = ((1, 'Z'), (3, 'Z'), (5, 'Z'))
correct_operators_b3 = ((2, 'Z'), (4, 'Z'), (5, 'Z'))
qterm_b0 = QubitOperator(correct_operators_b0, 1)
qterm_b1 = QubitOperator(correct_operators_b1, 1)
qterm_b2 = QubitOperator(correct_operators_b2, 1)
qterm_b3 = QubitOperator(correct_operators_b3, 1)
self.assertTrue(
qterm_b0.isclose(_bksf.edge_operator_b(edge_matrix_indices, 0)))
self.assertTrue(
qterm_b1.isclose(_bksf.edge_operator_b(edge_matrix_indices, 1)))
self.assertTrue(
qterm_b2.isclose(_bksf.edge_operator_b(edge_matrix_indices, 2)))
self.assertTrue(
qterm_b3.isclose(_bksf.edge_operator_b(edge_matrix_indices, 3)))
def test_yzxz(self):
yzxz = QubitOperator(((0, 'Y'), (1, 'Z'), (2, 'X'), (3, 'Z')))
transmed_yzxz = reverse_jordan_wigner(yzxz)
retransmed_yzxz = jordan_wigner(transmed_yzxz)
self.assertTrue(yzxz.isclose(retransmed_yzxz))
def test_y(self):
pauli_y = QubitOperator(((2, 'Y'), ))
transmed_y = reverse_jordan_wigner(pauli_y)
retransmed_y = jordan_wigner(transmed_y)
self.assertTrue(pauli_y.isclose(retransmed_y))
def test_x(self):
pauli_x = QubitOperator(((2, 'X'), ))
transmed_x = reverse_jordan_wigner(pauli_x)
retransmed_x = jordan_wigner(transmed_x)
self.assertTrue(pauli_x.isclose(retransmed_x))
class ReverseJWTest(unittest.TestCase):
def setUp(self):
self.coefficient = 0.5
self.operators = ((1, 'X'), (3, 'Y'), (8, 'Z'))
self.term = QubitOperator(self.operators, self.coefficient)
self.identity = QubitOperator(())
self.coefficient_a = 6.7j
self.coefficient_b = -88.
self.operators_a = ((3, 'Z'), (1, 'Y'), (4, 'Y'))
self.operators_b = ((2, 'X'), (3, 'Y'))
self.operator_a = QubitOperator(self.operators_a, self.coefficient_a)
self.operator_b = QubitOperator(self.operators_b, self.coefficient_b)
self.operator_ab = self.operator_a + self.operator_b
self.qubit_operator = QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')),
0.5)
self.qubit_operator += QubitOperator(((1, 'Z'), (3, 'X'), (8, 'Z')),
1.2)
def test_identity_jwterm(self):
self.assertTrue(
FermionOperator(
()).isclose(reverse_jordan_wigner(QubitOperator(()))))
def test_x(self):
pauli_x = QubitOperator(((2, 'X'), ))
transmed_x = reverse_jordan_wigner(pauli_x)
retransmed_x = jordan_wigner(transmed_x)
self.assertTrue(pauli_x.isclose(retransmed_x))
def test_y(self):
pauli_y = QubitOperator(((2, 'Y'), ))
transmed_y = reverse_jordan_wigner(pauli_y)
retransmed_y = jordan_wigner(transmed_y)
self.assertTrue(pauli_y.isclose(retransmed_y))
def test_z(self):
pauli_z = QubitOperator(((2, 'Z'), ))
transmed_z = reverse_jordan_wigner(pauli_z)
expected = (FermionOperator(()) + FermionOperator(
((2, 1), (2, 0)), -2.))
self.assertTrue(transmed_z.isclose(expected))
retransmed_z = jordan_wigner(transmed_z)
self.assertTrue(pauli_z.isclose(retransmed_z))
def test_reverse_jw_too_few_n_qubits(self):
with self.assertRaises(ValueError):
reverse_jordan_wigner(self.operator_a, 0)
def test_identity(self):
n_qubits = 5
transmed_i = reverse_jordan_wigner(self.identity, n_qubits)
expected_i = FermionOperator(())
self.assertTrue(transmed_i.isclose(expected_i))
retransmed_i = jordan_wigner(transmed_i)
self.assertTrue(self.identity.isclose(retransmed_i))
def test_zero(self):
n_qubits = 5
transmed_i = reverse_jordan_wigner(QubitOperator(), n_qubits)
expected_i = FermionOperator()
self.assertTrue(transmed_i.isclose(expected_i))
retransmed_i = jordan_wigner(transmed_i)
self.assertTrue(expected_i.isclose(retransmed_i))
def test_yzxz(self):
yzxz = QubitOperator(((0, 'Y'), (1, 'Z'), (2, 'X'), (3, 'Z')))
transmed_yzxz = reverse_jordan_wigner(yzxz)
retransmed_yzxz = jordan_wigner(transmed_yzxz)
self.assertTrue(yzxz.isclose(retransmed_yzxz))
def test_term(self):
transmed_term = reverse_jordan_wigner(self.term)
retransmed_term = jordan_wigner(transmed_term)
self.assertTrue(self.term.isclose(retransmed_term))
def test_xx(self):
xx = QubitOperator(((3, 'X'), (4, 'X')), 2.)
transmed_xx = reverse_jordan_wigner(xx)
retransmed_xx = jordan_wigner(transmed_xx)
expected1 = (FermionOperator(((3, 1), ), 2.) - FermionOperator(
((3, 0), ), 2.))
expected2 = (FermionOperator(((4, 1), ), 1.) + FermionOperator(
((4, 0), ), 1.))
expected = expected1 * expected2
self.assertTrue(xx.isclose(retransmed_xx))
self.assertTrue(
normal_ordered(transmed_xx).isclose(normal_ordered(expected)))
def test_yy(self):
yy = QubitOperator(((2, 'Y'), (3, 'Y')), 2.)
transmed_yy = reverse_jordan_wigner(yy)
retransmed_yy = jordan_wigner(transmed_yy)
expected1 = -(FermionOperator(((2, 1), ), 2.) + FermionOperator(
((2, 0), ), 2.))
expected2 = (FermionOperator(((3, 1), )) - FermionOperator(((3, 0), )))
expected = expected1 * expected2
self.assertTrue(yy.isclose(retransmed_yy))
self.assertTrue(
normal_ordered(transmed_yy).isclose(normal_ordered(expected)))
def test_xy(self):
xy = QubitOperator(((4, 'X'), (5, 'Y')), -2.j)
transmed_xy = reverse_jordan_wigner(xy)
retransmed_xy = jordan_wigner(transmed_xy)
expected1 = -2j * (FermionOperator(((4, 1), ), 1j) - FermionOperator(
((4, 0), ), 1j))
expected2 = (FermionOperator(((5, 1), )) - FermionOperator(((5, 0), )))
expected = expected1 * expected2
self.assertTrue(xy.isclose(retransmed_xy))
self.assertTrue(
normal_ordered(transmed_xy).isclose(normal_ordered(expected)))
def test_yx(self):
yx = QubitOperator(((0, 'Y'), (1, 'X')), -0.5)
transmed_yx = reverse_jordan_wigner(yx)
retransmed_yx = jordan_wigner(transmed_yx)
expected1 = 1j * (FermionOperator(((0, 1), )) + FermionOperator(
((0, 0), )))
expected2 = -0.5 * (FermionOperator(((1, 1), )) + FermionOperator(
((1, 0), )))
expected = expected1 * expected2
self.assertTrue(yx.isclose(retransmed_yx))
self.assertTrue(
normal_ordered(transmed_yx).isclose(normal_ordered(expected)))
def test_jw_term_bad_type(self):
with self.assertRaises(TypeError):
reverse_jordan_wigner(3)
def test_reverse_jordan_wigner(self):
transmed_operator = reverse_jordan_wigner(self.qubit_operator)
retransmed_operator = jordan_wigner(transmed_operator)
self.assertTrue(self.qubit_operator.isclose(retransmed_operator))
def test_reverse_jw_linearity(self):
term1 = QubitOperator(((0, 'X'), (1, 'Y')), -0.5)
term2 = QubitOperator(((0, 'Y'), (1, 'X'), (2, 'Y'), (3, 'Y')), -1j)
op12 = reverse_jordan_wigner(term1) - reverse_jordan_wigner(term2)
self.assertTrue(op12.isclose(reverse_jordan_wigner(term1 - term2)))
def test_bad_type(self):
with self.assertRaises(TypeError):
reverse_jordan_wigner(3)
def test_jw_convention(self):
"""Test that the Jordan-Wigner convention places the Z-string on
lower indices."""
qubit_op = QubitOperator('Z0 X1')
transformed_op = reverse_jordan_wigner(qubit_op)
expected_op = FermionOperator('1^')
expected_op += FermionOperator('1')
self.assertTrue(transformed_op.isclose(expected_op))
