def test_q_squared(self):
b = self.hbar * (BosonOperator('0^ 0^') + BosonOperator('0 0') +
BosonOperator('') + 2 * BosonOperator('0^ 0')) / 2
q = normal_ordered(get_quad_operator(b, hbar=self.hbar),
hbar=self.hbar)
expected = QuadOperator('q0 q0')
self.assertTrue(q == expected)
def get_boson_operator(operator, hbar=1.):
"""Convert to BosonOperator.
Args:
operator: QuadOperator.
hbar (float): the value of hbar used in the definition
of the commutator [q_i, p_j] = i hbar delta_ij.
By default hbar=1.
Returns:
boson_operator: An instance of the BosonOperator class.
"""
boson_operator = BosonOperator()
if isinstance(operator, QuadOperator):
for term, coefficient in operator.terms.items():
tmp = BosonOperator('', coefficient)
for i, d in term:
if d == 'q':
coeff = numpy.sqrt(hbar / 2)
sign = 1
elif d == 'p':
coeff = -1j * numpy.sqrt(hbar / 2)
sign = -1
tmp *= coeff * (BosonOperator(((i, 0))) + BosonOperator(
((i, 1)), sign))
boson_operator += tmp
else:
raise TypeError("Only QuadOperator is currently "
"supported for get_boson_operator.")
return boson_operator
def test_p_squared(self):
b = self.hbar * (-BosonOperator('1^ 1^') - BosonOperator('1 1') +
BosonOperator('') + 2 * BosonOperator('1^ 1')) / 2
q = normal_ordered(get_quad_operator(b, hbar=self.hbar),
hbar=self.hbar)
expected = QuadOperator('p1 p1')
self.assertTrue(q == expected)
def test_two_mode(self):
q = QuadOperator('p2 q0')
b = get_boson_operator(q, hbar=self.hbar)
expected = -1j*self.hbar/2 \
* (BosonOperator('0') + BosonOperator('0^')) \
* (BosonOperator('2') - BosonOperator('2^'))
self.assertTrue(b == expected)
def load_operator(file_name=None, data_directory=None, plain_text=False):
"""Load FermionOperator or QubitOperator from file.
Args:
file_name: The name of the saved file.
data_directory: Optional data directory to change from default data
directory specified in config file.
plain_text: Whether the input file is plain text
Returns:
operator: The stored FermionOperator, BosonOperator,
QuadOperator, or QubitOperator
Raises:
TypeError: Operator of invalid type.
"""
file_path = get_file_path(file_name, data_directory)
if plain_text:
with open(file_path, 'r') as f:
data = f.read()
operator_type, operator_terms = data.split(":\n")
if operator_type == 'FermionOperator':
operator = FermionOperator(operator_terms)
elif operator_type == 'BosonOperator':
operator = BosonOperator(operator_terms)
elif operator_type == 'QubitOperator':
operator = QubitOperator(operator_terms)
elif operator_type == 'QuadOperator':
operator = QuadOperator(operator_terms)
else:
raise TypeError('Operator of invalid type.')
else:
with open(file_path, 'rb') as f:
data = marshal.load(f)
operator_type = data[0]
operator_terms = data[1]
if operator_type == 'FermionOperator':
operator = FermionOperator()
for term in operator_terms:
operator += FermionOperator(term, operator_terms[term])
elif operator_type == 'BosonOperator':
operator = BosonOperator()
for term in operator_terms:
operator += BosonOperator(term, operator_terms[term])
elif operator_type == 'QubitOperator':
operator = QubitOperator()
for term in operator_terms:
operator += QubitOperator(term, operator_terms[term])
elif operator_type == 'QuadOperator':
operator = QuadOperator()
for term in operator_terms:
operator += QuadOperator(term, operator_terms[term])
else:
raise TypeError('Operator of invalid type.')
return operator
def test_hermitian_conjugated_complex_const(self):
op = FermionOperator('2^ 2', 3j)
op_hc = FermionOperator('2^ 2', -3j)
self.assertEqual(op_hc, hermitian_conjugated(op))
op = BosonOperator('2^ 2', 3j)
op_hc = BosonOperator('2^ 2', -3j)
self.assertEqual(op_hc, hermitian_conjugated(op))
def test_commutes_number_operators(self):
com = commutator(FermionOperator('4^ 3^ 4 3'), FermionOperator('2^ 2'))
com = normal_ordered(com)
self.assertEqual(com, FermionOperator.zero())
com = commutator(BosonOperator('4^ 3^ 4 3'), BosonOperator('2^ 2'))
com = normal_ordered(com)
self.assertTrue(com == BosonOperator.zero())
def test_boson_triple(self):
op_132 = BosonOperator(((1, 1), (3, 0), (2, 0)))
op_123 = BosonOperator(((1, 1), (2, 0), (3, 0)))
op_321 = BosonOperator(((3, 0), (2, 0), (1, 1)))
self.assertTrue(op_132 == normal_ordered(op_123))
self.assertTrue(op_132 == normal_ordered(op_132))
self.assertTrue(op_132 == normal_ordered(op_321))
def test_hermitian_conjugated_multiterm(self):
op = FermionOperator('1^ 2') + FermionOperator('2 3 4')
op_hc = FermionOperator('2^ 1') + FermionOperator('4^ 3^ 2^')
self.assertEqual(op_hc, hermitian_conjugated(op))
op = BosonOperator('1^ 2') + BosonOperator('2 3 4')
op_hc = BosonOperator('2^ 1') + BosonOperator('4^ 3^ 2^')
self.assertEqual(op_hc, hermitian_conjugated(op))
def test_commutator_hopping_operators(self):
com = commutator(3 * FermionOperator('1^ 2'), FermionOperator('2^ 3'))
com = normal_ordered(com)
self.assertEqual(com, FermionOperator('1^ 3', 3))
com = commutator(3 * BosonOperator('1^ 2'), BosonOperator('2^ 3'))
com = normal_ordered(com)
self.assertTrue(com == BosonOperator('1^ 3', 3))
def test_hermitian_conjugate_empty(self):
op = FermionOperator()
op = hermitian_conjugated(op)
self.assertEqual(op, FermionOperator())
op = BosonOperator()
op = hermitian_conjugated(op)
self.assertEqual(op, BosonOperator())
def test_hermitian_conjugated_simple(self):
op = FermionOperator('0')
op_hc = FermionOperator('0^')
self.assertEqual(op_hc, hermitian_conjugated(op))
op = BosonOperator('0')
op_hc = BosonOperator('0^')
self.assertEqual(op_hc, hermitian_conjugated(op))
def test_two_term(self):
b = BosonOperator('0^ 0') + BosonOperator('0 0^')
q = get_quad_operator(b, hbar=self.hbar)
expected = (QuadOperator('q0') - 1j*QuadOperator('p0')) \
* (QuadOperator('q0') + 1j*QuadOperator('p0')) \
+ (QuadOperator('q0') + 1j*QuadOperator('p0')) \
* (QuadOperator('q0') - 1j*QuadOperator('p0'))
expected /= 2 * self.hbar
self.assertTrue(q == expected)
def test_commutes_identity(self):
com = commutator(FermionOperator.identity(),
FermionOperator('2^ 3', 2.3))
self.assertEqual(com, FermionOperator.zero())
com = commutator(BosonOperator.identity(), BosonOperator('2^ 3', 2.3))
self.assertTrue(com == BosonOperator.zero())
com = commutator(QuadOperator.identity(), QuadOperator('q2 p3', 2.3))
self.assertTrue(com == QuadOperator.zero())
def test_hermitian_conjugate_complex_const(self):
op = FermionOperator('1^ 3', 3j)
op_hc = -3j * FermionOperator('3^ 1')
op = hermitian_conjugated(op)
self.assertEqual(op, op_hc)
op = BosonOperator('1^ 3', 3j)
op_hc = -3j * BosonOperator('3^ 1')
op = hermitian_conjugated(op)
self.assertEqual(op, op_hc)
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.assertEqual(op, op_hc)
op = BosonOperator('1 3^ 3 3^', 3j)
op_hc = -3j * BosonOperator('3 3^ 3 1^')
op = hermitian_conjugated(op)
self.assertEqual(op, op_hc)
def test_hermitian_conjugate_simple(self):
op = FermionOperator('1^')
op_hc = FermionOperator('1')
op = hermitian_conjugated(op)
self.assertEqual(op, op_hc)
op = BosonOperator('1^')
op_hc = BosonOperator('1')
op = hermitian_conjugated(op)
self.assertEqual(op, op_hc)
def test_commutes_no_intersection(self):
com = commutator(FermionOperator('2^ 3'), FermionOperator('4^ 5^ 3'))
com = normal_ordered(com)
self.assertEqual(com, FermionOperator.zero())
com = commutator(BosonOperator('2^ 3'), BosonOperator('4^ 5^ 3'))
com = normal_ordered(com)
self.assertTrue(com == BosonOperator.zero())
com = commutator(QuadOperator('q2 p3'), QuadOperator('q4 q5 p3'))
com = normal_ordered(com)
self.assertTrue(com == QuadOperator.zero())
def test_number_operator_nosite(self):
op = number_operator(4, parity=-1)
expected = (FermionOperator(((0, 1), (0, 0))) + FermionOperator(
((1, 1), (1, 0))) + FermionOperator(
((2, 1), (2, 0))) + FermionOperator(((3, 1), (3, 0))))
self.assertEqual(op, expected)
op = number_operator(4, parity=1)
expected = (BosonOperator(((0, 1), (0, 0))) + BosonOperator(
((1, 1), (1, 0))) + BosonOperator(((2, 1), (2, 0))) + BosonOperator(
((3, 1), (3, 0))))
self.assertTrue(op == expected)
def test_two_mode(self):
b = BosonOperator('0^ 2')
q = get_quad_operator(b, hbar=self.hbar)
expected = QuadOperator('q0') - 1j * QuadOperator('p0')
expected *= (QuadOperator('q2') + 1j * QuadOperator('p2'))
expected /= 2 * self.hbar
self.assertTrue(q == expected)
def test_two_term(self):
q = QuadOperator('p0 q0') + QuadOperator('q0 p0')
b = get_boson_operator(q, hbar=self.hbar)
expected = -1j*self.hbar/2 \
* ((BosonOperator('0') + BosonOperator('0^'))
* (BosonOperator('0') - BosonOperator('0^'))
+ (BosonOperator('0') - BosonOperator('0^'))
* (BosonOperator('0') + BosonOperator('0^')))
self.assertTrue(b == expected)
def test_symmetric_one_term_multimode(self):
op = BosonOperator('0^ 1^ 2 3')
res = symmetric_ordering(op)
self.assertTrue(res == op)
op = QuadOperator('q0 q1 p2 p3')
res = symmetric_ordering(op)
self.assertTrue(res == op)
def test_symmetric_two_term_same(self):
op = BosonOperator('0^ 0^')
res = symmetric_ordering(op)
self.assertTrue(res == op)
op = QuadOperator('q0 q0')
res = symmetric_ordering(op)
self.assertTrue(res == op)
def test_reorder_boson(self):
shift_by_one = lambda x, y: (x + 1) % y
operator = BosonOperator('1^ 2^ 3 4', -3.17)
reordered = reorder(operator, shift_by_one)
self.assertEqual(reordered.terms,
{((0, 0), (2, 1), (3, 1), (4, 0)): -3.17})
reordered = reorder(operator, shift_by_one, reverse=True)
self.assertEqual(reordered.terms,
{((0, 1), (1, 1), (2, 0), (3, 0)): -3.17})
def test_hermitian_conjugated_semihermitian(self):
op = (FermionOperator() + 2j * FermionOperator('1^ 3') +
FermionOperator('3^ 1') * -2j + FermionOperator('2^ 2', 0.1j))
op_hc = (FermionOperator() + FermionOperator('1^ 3', 2j) +
FermionOperator('3^ 1', -2j) + FermionOperator('2^ 2', -0.1j))
self.assertEqual(op_hc, hermitian_conjugated(op))
op = (BosonOperator() + 2j * BosonOperator('1^ 3') +
BosonOperator('3^ 1') * -2j + BosonOperator('2^ 2', 0.1j))
op_hc = (BosonOperator() + BosonOperator('1^ 3', 2j) +
BosonOperator('3^ 1', -2j) + BosonOperator('2^ 2', -0.1j))
self.assertEqual(op_hc, hermitian_conjugated(op))
def setUp(self):
self.fermion_term = FermionOperator('1^ 2^ 3 4', -3.17)
self.fermion_operator = self.fermion_term + hermitian_conjugated(
self.fermion_term)
self.boson_term = BosonOperator('1^ 2^ 3 4', -3.17)
self.boson_operator = self.boson_term + hermitian_conjugated(
self.boson_term)
self.quad_term = QuadOperator('q0 p0 q1 p0 p0', -3.17)
self.quad_operator = self.quad_term + hermitian_conjugated(
self.quad_term)
self.qubit_operator = jordan_wigner(self.fermion_operator)
def test_eigenspectrum(self):
fermion_eigenspectrum = eigenspectrum(self.fermion_operator)
qubit_eigenspectrum = eigenspectrum(self.qubit_operator)
interaction_eigenspectrum = eigenspectrum(self.interaction_operator)
for i in range(2**self.n_qubits):
self.assertAlmostEqual(fermion_eigenspectrum[i],
qubit_eigenspectrum[i])
self.assertAlmostEqual(fermion_eigenspectrum[i],
interaction_eigenspectrum[i])
with self.assertRaises(TypeError):
_ = eigenspectrum(BosonOperator())
with self.assertRaises(TypeError):
_ = eigenspectrum(QuadOperator())
def setUp(self):
self.n_qubits = 5
self.fermion_term = FermionOperator('1^ 2^ 3 4', -3.17)
self.fermion_operator = self.fermion_term + hermitian_conjugated(
self.fermion_term)
self.boson_term = BosonOperator('1^ 2^ 3 4', -3.17)
self.boson_operator = self.boson_term + hermitian_conjugated(
self.boson_term)
self.quad_term = QuadOperator('q0 p0 q1 p0 p0', -3.17)
self.quad_operator = self.quad_term + hermitian_conjugated(
self.quad_term)
self.qubit_operator = jordan_wigner(self.fermion_operator)
self.file_name = "test_file"
self.bad_operator_filename = 'bad_file.data'
bad_op = "A:\nB"
with open(os.path.join(DATA_DIRECTORY, self.bad_operator_filename),
'w') as fid:
fid.write(bad_op)
def test_canonical_boson_commutation_relations(self):
op_1 = BosonOperator('3')
op_1_dag = BosonOperator('3^')
op_2 = BosonOperator('4')
op_2_dag = BosonOperator('4^')
zero = BosonOperator()
one = BosonOperator('')
self.assertTrue(one == normal_ordered(commutator(op_1, op_1_dag)))
self.assertTrue(zero == normal_ordered(commutator(op_1, op_2)))
self.assertTrue(zero == normal_ordered(commutator(op_1, op_2_dag)))
self.assertTrue(zero == normal_ordered(commutator(op_1_dag, op_2)))
self.assertTrue(zero == normal_ordered(commutator(op_1_dag, op_2_dag)))
self.assertTrue(one == normal_ordered(commutator(op_2, op_2_dag)))
def test_symmetric_non_hermitian(self):
op = BosonOperator('0^ 0')
res = symmetric_ordering(op)
expected = BosonOperator('0^ 0', 0.5) \
+ BosonOperator('0 0^', 0.5)
self.assertTrue(res == expected)
self.assertTrue(is_hermitian(res))
op = BosonOperator('0^ 0', 0.5)
res = symmetric_ordering(op, ignore_coeff=False)
expected = BosonOperator('0^ 0', 0.25) \
+ BosonOperator('0 0^', 0.25)
self.assertTrue(res == expected)
self.assertTrue(is_hermitian(res))
op = QuadOperator('q0 p0')
res = symmetric_ordering(op)
expected = QuadOperator('q0 p0', 0.5) \
+ QuadOperator('p0 q0', 0.5)
self.assertTrue(res == expected)
self.assertTrue(is_hermitian(res))
