def test_two_by_two_spinful_phs(self):
hubbard_model = fermi_hubbard(
self.x_dimension, self.y_dimension, self.tunneling, self.coulomb,
self.chemical_potential, self.magnetic_field,
self.periodic, self.spinless, False)
hubbard_model_phs = fermi_hubbard(
self.x_dimension, self.y_dimension, self.tunneling, self.coulomb,
self.chemical_potential, self.magnetic_field,
self.periodic, self.spinless, True)
# Compute difference between the models with and without
# spin symmetry.
difference = hubbard_model_phs - hubbard_model
# Check constant term in difference.
self.assertAlmostEqual(difference.terms[()], 1.0)
# Check up spin on site terms in difference.
self.assertAlmostEqual(difference.terms[((0, 1), (0, 0))], -.50)
self.assertAlmostEqual(difference.terms[((2, 1), (2, 0))], -.50)
self.assertAlmostEqual(difference.terms[((4, 1), (4, 0))], -.50)
self.assertAlmostEqual(difference.terms[((6, 1), (6, 0))], -.50)
# Check down spin on site terms in difference.
self.assertAlmostEqual(difference.terms[((1, 1), (1, 0))], -.50)
self.assertAlmostEqual(difference.terms[((3, 1), (3, 0))], -.50)
self.assertAlmostEqual(difference.terms[((5, 1), (5, 0))], -.50)
self.assertAlmostEqual(difference.terms[((7, 1), (7, 0))], -.50)
def test_two_by_two_spinless_periodic_rudimentary(self):
hubbard_model = fermi_hubbard(
self.x_dimension, self.y_dimension, self.tunneling, self.coulomb,
self.chemical_potential, self.magnetic_field,
periodic=True, spinless=True, particle_hole_symmetry=False)
hubbard_model = fermi_hubbard(
self.x_dimension, self.y_dimension, self.tunneling, self.coulomb,
self.chemical_potential, self.magnetic_field,
periodic=True, spinless=True, particle_hole_symmetry=True)
def setUp(self):
self.x_dimension = 2
self.y_dimension = 3
# Create a Hamiltonian with nearest-neighbor hopping terms
self.ferm_op = fermi_hubbard(self.x_dimension, self.y_dimension, 1.,
0., 0., 0., False, True)
# Get the ground energy and ground state
self.ferm_op_sparse = get_sparse_operator(self.ferm_op)
self.ferm_op_ground_energy, self.ferm_op_ground_state = (
get_ground_state(self.ferm_op_sparse))
# Transform the FermionOperator to a QubitOperator
self.transformed_op = verstraete_cirac_2d_square(
self.ferm_op,
self.x_dimension,
self.y_dimension,
add_auxiliary_hamiltonian=True,
snake=False)
# Get the ground energy and state of the transformed operator
self.transformed_sparse = get_sparse_operator(self.transformed_op)
self.transformed_ground_energy, self.transformed_ground_state = (
get_ground_state(self.transformed_sparse))
def setUp(self):
self.x_dimension = 6
self.y_dimension = 6
# Create a Hubbard Hamiltonian
self.ferm_op = fermi_hubbard(self.x_dimension, self.y_dimension, 1.0,
4.0, 0.0, 0.0, False, True)
# Transform the FermionOperator to a QubitOperator without including
# the auxiliary Hamiltonian
self.transformed_op_no_aux = verstraete_cirac_2d_square(
self.ferm_op,
self.x_dimension,
self.y_dimension,
add_auxiliary_hamiltonian=False,
snake=False)
self.transformed_op_no_aux.compress()
# Transform the FermionOperator to a QubitOperator, including
# the auxiliary Hamiltonian
self.transformed_op_aux = verstraete_cirac_2d_square(
self.ferm_op,
self.x_dimension,
self.y_dimension,
add_auxiliary_hamiltonian=True,
snake=False)
self.transformed_op_aux.compress()
def test_fermion_operator_hermitian(self):
op = FermionOperator('0^ 1 2^ 3')
op += FermionOperator('3^ 2 1^ 0')
self.assertTrue(is_hermitian(op))
op = fermi_hubbard(2, 2, 1., 1.)
self.assertTrue(is_hermitian(op))
def test_get_ground_state_rdm_from_qubit_op(self):
# Given
n_sites = 2
U = 5.0
fhm = fermi_hubbard(
x_dimension=n_sites,
y_dimension=1,
tunneling=1.0,
coulomb=U,
chemical_potential=U / 2,
magnetic_field=0,
periodic=False,
spinless=False,
particle_hole_symmetry=False,
)
fhm_qubit = jordan_wigner(fhm)
fhm_int = get_interaction_operator(fhm)
e, wf = jw_get_ground_state_at_particle_number(
get_sparse_operator(fhm), n_sites
)
# When
rdm = get_ground_state_rdm_from_qubit_op(
qubit_operator=fhm_qubit, n_particles=n_sites
)
# Then
self.assertAlmostEqual(e, rdm.expectation(fhm_int))
def test_fermi_hubbard_2x2_spinless():
hubbard_model = fermi_hubbard(2,
2,
1.0,
4.0,
chemical_potential=0.5,
spinless=True)
assert str(hubbard_model).strip() == """
-0.5 [0^ 0] +
4.0 [0^ 0 1^ 1] +
4.0 [0^ 0 2^ 2] +
-1.0 [0^ 1] +
-1.0 [0^ 2] +
-1.0 [1^ 0] +
-0.5 [1^ 1] +
4.0 [1^ 1 3^ 3] +
-1.0 [1^ 3] +
-1.0 [2^ 0] +
-0.5 [2^ 2] +
4.0 [2^ 2 3^ 3] +
-1.0 [2^ 3] +
-1.0 [3^ 1] +
-1.0 [3^ 2] +
-0.5 [3^ 3]
""".strip()
def test_three_by_two_spinless_periodic_rudimentary(self):
hubbard_model = fermi_hubbard(
3, 2, self.tunneling, self.coulomb,
self.chemical_potential, self.magnetic_field,
periodic=True, spinless=True, particle_hole_symmetry=False)
# Check up top/bottom hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (0, 0))],
-self.tunneling)
def test_sum_of_ordered_terms_equals_full_hamiltonian_odd_side_len(self):
hamiltonian = normal_ordered(
fermi_hubbard(5, 5, 1.0, -0.3, periodic=False))
hamiltonian.compress()
terms = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)[0]
terms_total = sum(terms, FermionOperator.zero())
self.assertTrue(terms_total == hamiltonian)
def test_two_by_two_spinful(self):
# Initialize the Hamiltonians.
hubbard_model = fermi_hubbard(self.x_dimension, self.y_dimension,
self.tunneling, self.coulomb,
self.chemical_potential,
self.magnetic_field, self.periodic,
self.spinless, False)
# Check up spin on site terms.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (0, 0))], -.75)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (2, 0))], -.75)
self.assertAlmostEqual(hubbard_model.terms[((4, 1), (4, 0))], -.75)
self.assertAlmostEqual(hubbard_model.terms[((6, 1), (6, 0))], -.75)
# Check down spin on site terms.
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (1, 0))], .25)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (3, 0))], .25)
self.assertAlmostEqual(hubbard_model.terms[((5, 1), (5, 0))], .25)
self.assertAlmostEqual(hubbard_model.terms[((7, 1), (7, 0))], .25)
# Check up right/left hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (2, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (0, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((4, 1), (6, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((6, 1), (4, 0))], -2.)
# Check up top/bottom hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (4, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((4, 1), (0, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (6, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((6, 1), (2, 0))], -2.)
# Check down right/left hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (3, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (1, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((5, 1), (7, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((7, 1), (5, 0))], -2.)
# Check down top/bottom hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (5, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((5, 1), (1, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (7, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((7, 1), (3, 0))], -2.)
# Check on site interaction term.
self.assertAlmostEqual(
hubbard_model.terms[((0, 1), (0, 0), (1, 1), (1, 0))], 1.)
self.assertAlmostEqual(
hubbard_model.terms[((2, 1), (2, 0), (3, 1), (3, 0))], 1.)
self.assertAlmostEqual(
hubbard_model.terms[((4, 1), (4, 0), (5, 1), (5, 0))], 1.)
self.assertAlmostEqual(
hubbard_model.terms[((6, 1), (6, 0), (7, 1), (7, 0))], 1.)
def test_fermi_hubbard_square_special_general_equivalence(
x_dimension, y_dimension, tunneling, coulomb,
chemical_potential, spinless, periodic, magnetic_field):
hubbard_model_special = fermi_hubbard(
x_dimension, y_dimension, tunneling, coulomb,
chemical_potential=chemical_potential, spinless=spinless,
periodic=periodic, magnetic_field=magnetic_field)
hubbard_model_general = fermi_hubbard_from_general(
x_dimension, y_dimension, tunneling, coulomb,
chemical_potential=chemical_potential, spinless=spinless,
periodic=periodic, magnetic_field=magnetic_field)
assert hubbard_model_special == hubbard_model_general
def test_total_length_odd_side_length_full_hubbard(self):
hamiltonian = normal_ordered(
fermi_hubbard(5, 5, -1., -0.3, periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, _, _ = result
self.assertEqual(len(terms), 105)
def test_total_length_even_side_length_onsite_only(self):
hamiltonian = normal_ordered(
fermi_hubbard(4, 4, 0., -0.3, periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
self.assertEqual(len(terms), 16)
def test_sum_of_ordered_terms_equals_full_side_length_2_hopping_only(self):
hamiltonian = normal_ordered(
fermi_hubbard(2, 2, 1., 0.0, periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, _, _ = result
terms_total = sum(terms, FermionOperator.zero())
self.assertTrue(terms_total == hamiltonian)
def test_error_bound_using_info_even_side_length(self):
# Generate the Hamiltonian.
hamiltonian = normal_ordered(
fermi_hubbard(4, 4, 0.5, 0.2, periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
self.assertAlmostEqual(
low_depth_second_order_trotter_error_bound(terms, indices,
is_hopping), 13.59)
def test_restrict_interaction_hamiltonian(self):
"""Test restricting a coulomb repulsion Hamiltonian to a specified
Sz manifold."""
x_dim = 3
y_dim = 2
interaction_term = fermi_hubbard(x_dim, y_dim, 0., 1.)
interaction_sparse = get_sparse_operator(interaction_term)
sz_value = 2
interaction_restricted = jw_sz_restrict_operator(interaction_sparse,
sz_value)
restricted_interaction_values = set([
int(value.real) for value in interaction_restricted.diagonal()])
# Originally the eigenvalues run from 0 to 6 but after restricting,
# they should run from 0 to 2
self.assertEqual(restricted_interaction_values, {0, 1, 2})
def test_is_hopping_operator_terms_with_info(self):
hamiltonian = normal_ordered(
fermi_hubbard(5, 5, 1., -1., periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, _, is_hopping = result
for i in range(len(terms)):
single_term = list(terms[i].terms)[0]
is_hopping_term = not (single_term[1][1]
or single_term[0][0] == single_term[1][0])
self.assertEqual(is_hopping_term, is_hopping[i])
def test_strong_interaction_hubbard_VT_order_gives_larger_error(self):
hamiltonian = normal_ordered(fermi_hubbard(4, 4, 1., 10.0))
TV_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='T+V'))
TV_error_bound = numpy.sum(
numpy.absolute(list(TV_error_operator.terms.values())))
VT_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='V+T'))
VT_error_bound = numpy.sum(
numpy.absolute(list(VT_error_operator.terms.values())))
self.assertGreater(VT_error_bound, TV_error_bound)
def test_hubbard(self):
x_dim = 4
y_dim = 5
tunneling = 2.
coulomb = 3.
chemical_potential = 7.
magnetic_field = 11.
periodic = False
hubbard_model = fermi_hubbard(x_dim, y_dim, tunneling, coulomb,
chemical_potential, magnetic_field,
periodic)
self.assertTrue(
jordan_wigner(hubbard_model) == jordan_wigner(
get_diagonal_coulomb_hamiltonian(hubbard_model)))
def test_intermediate_interaction_hubbard_TV_order_has_larger_error(self):
hamiltonian = normal_ordered(fermi_hubbard(4, 4, 1., 4.0))
TV_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='T+V'))
TV_error_bound = numpy.sum(
numpy.absolute(list(TV_error_operator.terms.values())))
VT_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='V+T'))
VT_error_bound = numpy.sum(
numpy.absolute(list(VT_error_operator.terms.values())))
self.assertAlmostEqual(TV_error_bound, 1706.66666666666)
self.assertAlmostEqual(VT_error_bound, 1365.33333333333)
def test_two_by_two_spinless(self):
# Initialize the Hamiltonian.
hubbard_model = fermi_hubbard(self.x_dimension,
self.y_dimension,
self.tunneling,
self.coulomb,
self.chemical_potential,
self.magnetic_field,
self.periodic,
spinless=True)
# Check on site terms and magnetic field.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (0, 0))], -0.25)
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (1, 0))], -0.25)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (2, 0))], -0.25)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (3, 0))], -0.25)
# Check right/left hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (1, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (0, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (2, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (3, 0))], -2.)
# Check top/bottom hopping terms.
self.assertAlmostEqual(hubbard_model.terms[((0, 1), (2, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((2, 1), (0, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((3, 1), (1, 0))], -2.)
self.assertAlmostEqual(hubbard_model.terms[((1, 1), (3, 0))], -2.)
# Check left/right Coulomb terms.
self.assertAlmostEqual(
hubbard_model.terms[((0, 1), (0, 0), (1, 1), (1, 0))], 1.)
self.assertAlmostEqual(
hubbard_model.terms[((2, 1), (2, 0), (3, 1), (3, 0))], 1.)
# Check top/bottom Coulomb terms.
self.assertAlmostEqual(
hubbard_model.terms[((0, 1), (0, 0), (2, 1), (2, 0))], 1.)
self.assertAlmostEqual(
hubbard_model.terms[((1, 1), (1, 0), (3, 1), (3, 0))], 1.)
# Check that there are no other Coulomb terms.
self.assertNotIn(((0, 1), (0, 0), (3, 1), (3, 0)), hubbard_model.terms)
self.assertNotIn(((1, 1), (1, 0), (2, 1), (2, 0)), hubbard_model.terms)
def test_correct_indices_terms_with_info(self):
hamiltonian = normal_ordered(
fermi_hubbard(5, 5, 1., -1., periodic=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_hubbard_terms_with_info(
hamiltonian)
terms, indices, _ = result
for i in range(len(terms)):
term = list(terms[i].terms)
term_indices = set()
for single_term in term:
term_indices = term_indices.union(
[single_term[j][0] for j in range(len(single_term))])
self.assertEqual(term_indices, indices[i])
def set_1D_hubbard(x_dim):
""" Returns a 1D Fermi-Hubbard Hamiltonian.
"""
y_dim = 1
tunneling = 1.0
coulomb = 1.0
magnetic_field = 0.0
chemical_potential = 0.0
periodic = False
spinless = False
num_orbitals = 2 * x_dim * y_dim
hubbard_model = fermi_hubbard(x_dim, y_dim, tunneling, coulomb,
chemical_potential, magnetic_field, periodic,
spinless)
return hubbard_model, num_orbitals
def setUp(self):
# Set up molecule.
geometry = [('Li', (0., 0., 0.)), ('H', (0., 0., 1.45))]
basis = 'sto-3g'
multiplicity = 1
filename = os.path.join(THIS_DIRECTORY, 'data',
'H1-Li1_sto-3g_singlet_1.45')
self.molecule = MolecularData(
geometry, basis, multiplicity, filename=filename)
self.molecule.load()
# Get molecular Hamiltonian.
self.molecular_hamiltonian = self.molecule.get_molecular_hamiltonian()
self.hubbard_hamiltonian = fermi_hubbard(
2, 2, 1.0, 4.0,
chemical_potential=.2,
magnetic_field=0.0,
spinless=False)
def test_hubbard_trotter_error_matches_low_depth_trotter_error(self):
hamiltonian = normal_ordered(fermi_hubbard(3, 3, 1., 2.3))
error_operator = (
fermionic_swap_trotter_error_operator_diagonal_two_body(
hamiltonian))
error_operator.compress()
# Unpack result into terms, indices they act on, and whether
# they're hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
old_error_operator = low_depth_second_order_trotter_error_operator(
terms, indices, is_hopping, jellium_only=True)
old_error_operator -= error_operator
self.assertEqual(old_error_operator, FermionOperator.zero())
def test_fermi_hubbard_2x3_spinless():
hubbard_model = fermi_hubbard(2,
3,
1.0,
4.0,
chemical_potential=0.5,
spinless=True)
assert str(hubbard_model).strip() == """
-0.5 [0^ 0] +
4.0 [0^ 0 1^ 1] +
4.0 [0^ 0 2^ 2] +
-1.0 [0^ 1] +
-1.0 [0^ 2] +
-1.0 [0^ 4] +
-1.0 [1^ 0] +
-0.5 [1^ 1] +
4.0 [1^ 1 3^ 3] +
-1.0 [1^ 3] +
-1.0 [1^ 5] +
-1.0 [2^ 0] +
-0.5 [2^ 2] +
4.0 [2^ 2 3^ 3] +
4.0 [2^ 2 4^ 4] +
-1.0 [2^ 3] +
-1.0 [2^ 4] +
-1.0 [3^ 1] +
-1.0 [3^ 2] +
-0.5 [3^ 3] +
4.0 [3^ 3 5^ 5] +
-1.0 [3^ 5] +
-1.0 [4^ 0] +
-1.0 [4^ 2] +
-0.5 [4^ 4] +
4.0 [4^ 4 0^ 0] +
4.0 [4^ 4 5^ 5] +
-1.0 [4^ 5] +
-1.0 [5^ 1] +
-1.0 [5^ 3] +
-1.0 [5^ 4] +
-0.5 [5^ 5] +
4.0 [5^ 5 1^ 1]
""".strip()
def test_fermi_hubbard_3x2_spinless():
hubbard_model = fermi_hubbard(3,
2,
1.0,
4.0,
chemical_potential=0.5,
spinless=True)
assert str(hubbard_model).strip() == """
-0.5 [0^ 0] +
4.0 [0^ 0 1^ 1] +
4.0 [0^ 0 3^ 3] +
-1.0 [0^ 1] +
-1.0 [0^ 2] +
-1.0 [0^ 3] +
-1.0 [1^ 0] +
-0.5 [1^ 1] +
4.0 [1^ 1 2^ 2] +
4.0 [1^ 1 4^ 4] +
-1.0 [1^ 2] +
-1.0 [1^ 4] +
-1.0 [2^ 0] +
-1.0 [2^ 1] +
-0.5 [2^ 2] +
4.0 [2^ 2 0^ 0] +
4.0 [2^ 2 5^ 5] +
-1.0 [2^ 5] +
-1.0 [3^ 0] +
-0.5 [3^ 3] +
4.0 [3^ 3 4^ 4] +
-1.0 [3^ 4] +
-1.0 [3^ 5] +
-1.0 [4^ 1] +
-1.0 [4^ 3] +
-0.5 [4^ 4] +
4.0 [4^ 4 5^ 5] +
-1.0 [4^ 5] +
-1.0 [5^ 2] +
-1.0 [5^ 3] +
-1.0 [5^ 4] +
-0.5 [5^ 5] +
4.0 [5^ 5 3^ 3]
""".strip()
def test_fermi_hubbard_3x1_spinless():
hubbard_model = fermi_hubbard(3,
1,
1.0,
4.0,
chemical_potential=0.5,
spinless=True)
assert str(hubbard_model).strip() == """
-0.5 [0^ 0] +
4.0 [0^ 0 1^ 1] +
-1.0 [0^ 1] +
-1.0 [0^ 2] +
-1.0 [1^ 0] +
-0.5 [1^ 1] +
4.0 [1^ 1 2^ 2] +
-1.0 [1^ 2] +
-1.0 [2^ 0] +
-1.0 [2^ 1] +
-0.5 [2^ 2] +
4.0 [2^ 2 0^ 0]
""".strip()
def test_fermi_hubbard_2x2_spinful_phs():
hubbard_model = fermi_hubbard(2,
2,
1.0,
4.0,
chemical_potential=0.5,
magnetic_field=0.3,
spinless=False,
particle_hole_symmetry=True)
assert str(hubbard_model).strip() == """
4.0 [] +
-2.8 [0^ 0] +
4.0 [0^ 0 1^ 1] +
-1.0 [0^ 2] +
-1.0 [0^ 4] +
-2.2 [1^ 1] +
-1.0 [1^ 3] +
-1.0 [1^ 5] +
-1.0 [2^ 0] +
-2.8 [2^ 2] +
4.0 [2^ 2 3^ 3] +
-1.0 [2^ 6] +
-1.0 [3^ 1] +
-2.2 [3^ 3] +
-1.0 [3^ 7] +
-1.0 [4^ 0] +
-2.8 [4^ 4] +
4.0 [4^ 4 5^ 5] +
-1.0 [4^ 6] +
-1.0 [5^ 1] +
-2.2 [5^ 5] +
-1.0 [5^ 7] +
-1.0 [6^ 2] +
-1.0 [6^ 4] +
-2.8 [6^ 6] +
4.0 [6^ 6 7^ 7] +
-1.0 [7^ 3] +
-1.0 [7^ 5] +
-2.2 [7^ 7]
""".strip()
def test_fermi_hubbard_2x2_spinful_aperiodic():
hubbard_model = fermi_hubbard(2,
2,
1.0,
4.0,
chemical_potential=0.5,
magnetic_field=0.3,
spinless=False,
periodic=False)
assert str(hubbard_model).strip() == """
-0.8 [0^ 0] +
4.0 [0^ 0 1^ 1] +
-1.0 [0^ 2] +
-1.0 [0^ 4] +
-0.2 [1^ 1] +
-1.0 [1^ 3] +
-1.0 [1^ 5] +
-1.0 [2^ 0] +
-0.8 [2^ 2] +
4.0 [2^ 2 3^ 3] +
-1.0 [2^ 6] +
-1.0 [3^ 1] +
-0.2 [3^ 3] +
-1.0 [3^ 7] +
-1.0 [4^ 0] +
-0.8 [4^ 4] +
4.0 [4^ 4 5^ 5] +
-1.0 [4^ 6] +
-1.0 [5^ 1] +
-0.2 [5^ 5] +
-1.0 [5^ 7] +
-1.0 [6^ 2] +
-1.0 [6^ 4] +
-0.8 [6^ 6] +
4.0 [6^ 6 7^ 7] +
-1.0 [7^ 3] +
-1.0 [7^ 5] +
-0.2 [7^ 7]
""".strip()
