def test_ccr_offsite_odd_aa(self):
a1 = FermionOperator(((1, 0), ))
a4 = FermionOperator(((4, 0), ))
self.assertTrue(
normal_ordered(a1 * a4).isclose(normal_ordered(-a4 * a1)))
self.assertTrue(
jordan_wigner(a1 * a4).isclose(jordan_wigner(-a4 * a1)))
def test_ccr_offsite_even_aa(self):
a2 = FermionOperator(((2, 0), ))
a4 = FermionOperator(((4, 0), ))
self.assertTrue(
normal_ordered(a2 * a4).isclose(normal_ordered(-a4 * a2)))
self.assertTrue(
jordan_wigner(a2 * a4).isclose(jordan_wigner(-a4 * a2)))
def test_ccr_offsite_odd_cc(self):
c1 = FermionOperator(((1, 1), ))
c4 = FermionOperator(((4, 1), ))
self.assertTrue(
normal_ordered(c1 * c4).isclose(normal_ordered(-c4 * c1)))
self.assertTrue(
jordan_wigner(c1 * c4).isclose(jordan_wigner(-c4 * c1)))
def test_ccr_offsite_even_cc(self):
c2 = FermionOperator(((2, 1), ))
c4 = FermionOperator(((4, 1), ))
self.assertTrue(
normal_ordered(c2 * c4).isclose(normal_ordered(-c4 * c2)))
self.assertTrue(
jordan_wigner(c2 * c4).isclose(jordan_wigner(-c4 * c2)))
def test_ccr_onsite(self):
c1 = FermionOperator(((1, 1), ))
a1 = hermitian_conjugated(c1)
self.assertTrue(
normal_ordered(
c1 *
a1).isclose(FermionOperator(()) - normal_ordered(a1 * c1)))
self.assertTrue(
jordan_wigner(
c1 * a1).isclose(QubitOperator(()) - jordan_wigner(a1 * c1)))
def test_jordan_wigner_one_body(self):
# Make sure it agrees with jordan_wigner(FermionTerm).
for p in range(self.n_qubits):
for q in range(self.n_qubits):
# Get test qubit operator.
test_operator = jordan_wigner_one_body(p, q)
# Get correct qubit operator.
fermion_term = FermionOperator(((p, 1), (q, 0)))
correct_op = jordan_wigner(fermion_term)
hermitian_conjugate = hermitian_conjugated(fermion_term)
if not fermion_term.isclose(hermitian_conjugate):
correct_op += jordan_wigner(hermitian_conjugate)
self.assertTrue(test_operator.isclose(correct_op))
def test_jordan_wigner_transm_op(self):
n = number_operator(self.n_qubits)
n_jw = jordan_wigner(n)
self.assertEqual(self.n_qubits + 1, len(n_jw.terms))
self.assertEqual(self.n_qubits / 2., n_jw.terms[()])
for qubit in range(self.n_qubits):
operators = ((qubit, 'Z'), )
self.assertEqual(n_jw.terms[operators], -0.5)
def test_jordan_wigner_interaction_op_with_zero_term(self):
test_op = FermionOperator('1^ 2^ 3 4')
test_op += hermitian_conjugated(test_op)
interaction_op = get_interaction_operator(test_op)
interaction_op.constant = 0.0
retransformed_test_op = reverse_jordan_wigner(
jordan_wigner(interaction_op))
def test_get_interaction_operator_identity(self):
interaction_operator = InteractionOperator(-2j, self.one_body,
self.two_body)
qubit_operator = jordan_wigner(interaction_operator)
self.assertTrue(qubit_operator.isclose(-2j * QubitOperator(())))
self.assertEqual(
interaction_operator,
get_interaction_operator(reverse_jordan_wigner(qubit_operator),
self.n_qubits))
def test_jordan_wigner_twobody_interaction_op_allunique(self):
test_op = FermionOperator('1^ 2^ 3 4')
test_op += hermitian_conjugated(test_op)
retransformed_test_op = reverse_jordan_wigner(
jordan_wigner(get_interaction_operator(test_op)))
self.assertTrue(
normal_ordered(retransformed_test_op).isclose(
normal_ordered(test_op)))
def test_transm_lower0(self):
lowering = jordan_wigner(FermionOperator(((0, 0), )))
correct_operators_x = ((0, 'X'), )
correct_operators_y = ((0, 'Y'), )
qtermx = QubitOperator(correct_operators_x, 0.5)
qtermy = QubitOperator(correct_operators_y, 0.5j)
self.assertEqual(lowering.terms[correct_operators_x], 0.5)
self.assertEqual(lowering.terms[correct_operators_y], 0.5j)
self.assertTrue(lowering.isclose(qtermx + qtermy))
def test_transm_raise3lower0(self):
# recall that creation gets -1j on Y and annihilation gets +1j on Y.
term = jordan_wigner(FermionOperator(((3, 1), (0, 0))))
self.assertEqual(term.terms[((0, 'X'), (1, 'Z'), (2, 'Z'), (3, 'Y'))],
0.25 * 1 * -1j)
self.assertEqual(term.terms[((0, 'Y'), (1, 'Z'), (2, 'Z'), (3, 'Y'))],
0.25 * 1j * -1j)
self.assertEqual(term.terms[((0, 'Y'), (1, 'Z'), (2, 'Z'), (3, 'X'))],
0.25 * 1j * 1)
self.assertEqual(term.terms[((0, 'X'), (1, 'Z'), (2, 'Z'), (3, 'X'))],
0.25 * 1 * 1)
def test_transm_raise1(self):
raising = jordan_wigner(FermionOperator(((1, 1), )))
correct_operators_x = ((0, 'Z'), (1, 'X'))
correct_operators_y = ((0, 'Z'), (1, 'Y'))
qtermx = QubitOperator(correct_operators_x, 0.5)
qtermy = QubitOperator(correct_operators_y, -0.5j)
self.assertEqual(raising.terms[correct_operators_x], 0.5)
self.assertEqual(raising.terms[correct_operators_y], -0.5j)
self.assertTrue(raising.isclose(qtermx + qtermy))
def test_jordan_wigner_two_body(self):
# Make sure it agrees with jordan_wigner(FermionTerm).
for p in range(self.n_qubits):
for q in range(self.n_qubits):
for r in range(self.n_qubits):
for s in range(self.n_qubits):
# Get test qubit operator.
test_operator = jordan_wigner_two_body(p, q, r, s)
# Get correct qubit operator.
fermion_term = FermionOperator(
((p, 1), (q, 1), (r, 0), (s, 0)))
correct_op = jordan_wigner(fermion_term)
hermitian_conjugate = hermitian_conjugated(
fermion_term)
if not fermion_term.isclose(hermitian_conjugate):
if p == r and q == s:
pass
else:
correct_op += jordan_wigner(
hermitian_conjugate)
self.assertTrue(test_operator.isclose(correct_op),
str(test_operator - correct_op))
def test_bad_input(self):
with self.assertRaises(TypeError):
jordan_wigner(3)
def test_transm_number(self):
n = number_operator(self.n_qubits, 3)
n_jw = jordan_wigner(n)
self.assertEqual(n_jw.terms[((3, 'Z'), )], -0.5)
self.assertEqual(n_jw.terms[()], 0.5)
self.assertEqual(len(n_jw.terms), 2)
def test_jordan_wigner_twobody_interaction_op_reversal_symmetric(self):
test_op = FermionOperator('1^ 2^ 2 1')
test_op += hermitian_conjugated(test_op)
self.assertTrue(
jordan_wigner(test_op).isclose(
jordan_wigner(get_interaction_operator(test_op))))
