def test_isclose_different_terms(self):
a = FermionOperator(((1, 0),), -0.1j)
b = FermionOperator(((1, 1),), -0.1j)
self.assertTrue(a.isclose(b, rel_tol=1e-12, abs_tol=0.2))
self.assertFalse(a.isclose(b, rel_tol=1e-12, abs_tol=0.05))
self.assertTrue(b.isclose(a, rel_tol=1e-12, abs_tol=0.2))
self.assertFalse(b.isclose(a, rel_tol=1e-12, abs_tol=0.05))
def test_isclose_rel_tol(self):
a = FermionOperator('0', 1)
b = FermionOperator('0', 2)
self.assertTrue(a.isclose(b, rel_tol=2.5, abs_tol=0.1))
# Test symmetry
self.assertTrue(a.isclose(b, rel_tol=1, abs_tol=0.1))
self.assertTrue(b.isclose(a, rel_tol=1, abs_tol=0.1))
def test_normal_ordered_triple(self):
op_132 = FermionOperator(((1, 1), (3, 0), (2, 0)))
op_123 = FermionOperator(((1, 1), (2, 0), (3, 0)))
op_321 = FermionOperator(((3, 0), (2, 0), (1, 1)))
self.assertTrue(op_132.isclose(normal_ordered(-op_123)))
self.assertTrue(op_132.isclose(normal_ordered(op_132)))
self.assertTrue(op_132.isclose(normal_ordered(op_321)))
def test_itruediv_and_idiv_npcomplex128(self):
op = FermionOperator(((1, 1), (3, 0), (8, 1)), 0.5)
divisor = numpy.complex128(12.3 + 7.4j)
original = copy.deepcopy(op)
correct = op * (1. / divisor)
op /= divisor
self.assertTrue(op.isclose(correct))
# Test if done in-place
self.assertFalse(op.isclose(original))
def test_isclose_abs_tol(self):
a = FermionOperator('0^', -1.)
b = FermionOperator('0^', -1.05)
c = FermionOperator('0^', -1.11)
self.assertTrue(a.isclose(b, rel_tol=1e-14, abs_tol=0.1))
self.assertFalse(a.isclose(c, rel_tol=1e-14, abs_tol=0.1))
a = FermionOperator('0^', -1.0j)
b = FermionOperator('0^', -1.05j)
c = FermionOperator('0^', -1.11j)
self.assertTrue(a.isclose(b, rel_tol=1e-14, abs_tol=0.1))
self.assertFalse(a.isclose(c, rel_tol=1e-14, abs_tol=0.1))
def test_add(self):
term_a = ((1, 1), (3, 0), (8, 1))
term_b = ((1, 0), (3, 0), (8, 1))
a = FermionOperator(term_a, 1.0)
b = FermionOperator(term_b, 0.5)
res = a + b + b
self.assertEqual(len(res.terms), 2)
self.assertEqual(res.terms[term_a], 1.0)
self.assertEqual(res.terms[term_b], 1.0)
# Test out of place
self.assertTrue(a.isclose(FermionOperator(term_a, 1.0)))
self.assertTrue(b.isclose(FermionOperator(term_b, 0.5)))
def test_mul_out_of_place(self):
op1 = FermionOperator(((0, 1), (3, 1), (3, 0), (11, 1)), 3.j)
op2 = FermionOperator(((1, 1), (3, 1), (8, 0)), 0.5)
op3 = op1 * op2
correct_coefficient = 3.0j * 0.5
correct_term = ((0, 1), (3, 1), (3, 0), (11, 1),
(1, 1), (3, 1), (8, 0))
self.assertTrue(op1.isclose(FermionOperator(
((0, 1), (3, 1), (3, 0), (11, 1)), 3.j)))
self.assertTrue(op2.isclose(FermionOperator(((1, 1), (3, 1), (8, 0)),
0.5)))
self.assertTrue(op3.isclose(FermionOperator(correct_term,
correct_coefficient)))
def test_pow_zero_term(self):
coeff = 6.7j
ops = ((3, 1), (1, 0), (4, 1))
term = FermionOperator(ops, coeff)
zerod = term ** 0
expected = FermionOperator(())
self.assertTrue(expected.isclose(zerod))
def test_pow_high_term(self):
coeff = 6.7j
ops = ((3, 1), (1, 0), (4, 1))
term = FermionOperator(ops, coeff)
high = term ** 10
expected = FermionOperator(ops * 10, coeff ** 10)
self.assertTrue(expected.isclose(high))
def test_neg(self):
op = FermionOperator(((1, 1), (3, 1), (8, 1)), 0.5)
_ = -op
# out of place
self.assertTrue(op.isclose(FermionOperator(((1, 1), (3, 1), (8, 1)),
0.5)))
correct = -1.0 * op
self.assertTrue(correct.isclose(-op))
def test_truediv_and_div_npcomplex128(self):
op = FermionOperator(((1, 1), (3, 0), (8, 1)), 0.5)
divisor = numpy.complex128(566.4j + 0.3)
original = copy.deepcopy(op)
res = op / divisor
correct = op * (1. / divisor)
self.assertTrue(res.isclose(correct))
# Test if done out of place
self.assertTrue(op.isclose(original))
def test_identity_is_multiplicative_identity(self):
u = FermionOperator.identity()
f = FermionOperator(((0, 1), (5, 0), (6, 1)), 0.6j)
g = FermionOperator(((0, 0), (5, 0), (6, 1)), 0.3j)
h = f + g
self.assertTrue(f.isclose(u * f))
self.assertTrue(f.isclose(f * u))
self.assertTrue(g.isclose(u * g))
self.assertTrue(g.isclose(g * u))
self.assertTrue(h.isclose(u * h))
self.assertTrue(h.isclose(h * u))
u *= h
self.assertTrue(h.isclose(u))
self.assertFalse(f.isclose(u))
# Method always returns new instances.
self.assertFalse(FermionOperator.identity().isclose(u))
def test_zero_is_additive_identity(self):
o = FermionOperator.zero()
f = FermionOperator(((0, 1), (5, 0), (6, 1)), 0.6j)
g = FermionOperator(((0, 0), (5, 0), (6, 1)), 0.3j)
h = f + g
self.assertTrue(f.isclose(o + f))
self.assertTrue(f.isclose(f + o))
self.assertTrue(g.isclose(o + g))
self.assertTrue(g.isclose(g + o))
self.assertTrue(h.isclose(o + h))
self.assertTrue(h.isclose(h + o))
o += h
self.assertTrue(h.isclose(o))
self.assertFalse(f.isclose(o))
# Method always returns new instances.
self.assertFalse(FermionOperator.zero().isclose(o))
def test_hermitian_conjugated_simple(self):
op = FermionOperator('0')
op_hc = FermionOperator('0^')
self.assertTrue(op_hc.isclose(hermitian_conjugated(op)))
def test_hermitian_conjugated_empty(self):
op = FermionOperator()
self.assertTrue(op.isclose(hermitian_conjugated(op)))
def test_hermitian_conjugate_notordered(self):
op = FermionOperator('1 3^ 3 3^', 3j)
op_hc = -3j * FermionOperator('3 3^ 3 1^')
op = hermitian_conjugated(op)
self.assertTrue(op.isclose(op_hc))
def test_hermitian_conjugate_complex_const(self):
op = FermionOperator('1^ 3', 3j)
op_hc = -3j * FermionOperator('3^ 1')
op = hermitian_conjugated(op)
self.assertTrue(op.isclose(op_hc))
def test_hermitian_conjugate_simple(self):
op = FermionOperator('1^')
op_hc = FermionOperator('1')
op = hermitian_conjugated(op)
self.assertTrue(op.isclose(op_hc))
def test_isclose_zero_terms(self):
op = FermionOperator('1^ 0', -1j) * 0
self.assertTrue(op.isclose(FermionOperator((), 0.0),
rel_tol=1e-12, abs_tol=1e-12))
self.assertTrue(FermionOperator().isclose(
op, rel_tol=1e-12, abs_tol=1e-12))
def test_normal_ordered_double_create_separated(self):
op = FermionOperator(((3, 1), (2, 0), (3, 1)))
expected = FermionOperator((), 0.0)
self.assertTrue(expected.isclose(normal_ordered(op)))
def test_normal_ordered_offsite(self):
op = FermionOperator(((3, 1), (2, 0)))
self.assertTrue(op.isclose(normal_ordered(op)))
def test_normal_ordered_number(self):
number_op2 = FermionOperator(((2, 1), (2, 0)))
self.assertTrue(number_op2.isclose(normal_ordered(number_op2)))
def test_normal_ordered_single_term(self):
op = FermionOperator('4 3 2 1') + FermionOperator('3 2')
self.assertTrue(op.isclose(normal_ordered(op)))
def test_pow_one_term(self):
coeff = 6.7j
ops = ((3, 1), (1, 0), (4, 1))
term = FermionOperator(ops, coeff)
self.assertTrue(term.isclose(term ** 1))
def test_hermitian_conjugated_complex_const(self):
op = FermionOperator('2^ 2', 3j)
op_hc = FermionOperator('2^ 2', -3j)
self.assertTrue(op_hc.isclose(hermitian_conjugated(op)))
def test_hermitian_conjugated_multiterm(self):
op = FermionOperator('1^ 2') + FermionOperator('2 3 4')
op_hc = FermionOperator('2^ 1') + FermionOperator('4^ 3^ 2^')
self.assertTrue(op_hc.isclose(hermitian_conjugated(op)))
def test_FermionOperator(self):
op = FermionOperator((), 3.)
self.assertTrue(op.isclose(FermionOperator(()) * 3.))
