2.3. Model Hamiltonians

2.3.1. Supported features

The current version of PyBEST supports the 1-dimensional Hubbard model Hamiltonian with open and periodic boundary conditions. Note that only DenseLinalgFactory is supported for model Hamiltonians (see also PyBEST objects: the LinalgFactory).

2.3.2. The Hubbard model Hamiltonian

The Hubbard model Hamiltonian is the simplest model of interacting particles on a lattice and reads

(2.2)\[\hat{H}_{\rm Hub} = -t\sum_{j,\sigma} \left( a_{(j+1)\sigma}^{\dagger}a_{j\sigma} + a_{j\sigma}^{\dagger}a_{(j+1)\sigma} \right ) +U\sum_j n_{j\uparrow} n_{j\downarrow},\]

where the first term is a one-electron term and accounts for the nearest-neighbor hopping, while the second term is the repulsive on-site interaction. \(t\) and \(U\) are user specified parameters and \(\sigma\) is the electron spin.

2.3.2.1. Preliminaries

In contrast to the molecular Hamiltonian, the Hubbard model Hamiltonian does not require a molecular geometry and atomic basis set to be defined. Thus, no GOBasis instance is needed. Instead, the matrix representation of the Hubbard model Hamiltonian can be immediately evaluated. To do so, an instance of DenseLinalgFactory has to be created,

# create LinalgFactory instance for n sites
lf = DenseLinalgFactory(n)

where n is the number of sites in the Hubbard model.

Note

CholeskyLinalgFactory is not supported for the Hubbard model Hamiltonian.

2.3.2.2. Defining the Hamiltonian and boundary conditions (open or periodic)

In order to calculate the hopping and on-site repulsion terms, an instance of the Hubbard class has to be created, where an instance of the DenseLinalgFactory has to be passed,

# create an instance of the Hubbard class with PBC
modelham = Hubbard(lf)

By default, the Hubbard Hamiltonian is constructed with periodic boundary conditions. Open boundary conditions can be enforced during the initialization using

# create an instance of the Hubbard class with open boundary conditions
modelham = Hubbard(lf, pbc=False)

The nearest-neighbor hopping term (\(t\) in eq. (2.2)) is calculated using the method compute_one_body() of the Hubbard class,

# strength of hopping term
t = -1.0
# calculate hopping term
hopping = modelham.compute_one_body(t)

The method requires the strength of the hopping term \(t\) as argument.

Note

The negative sign of the hopping term \(t\) as shown in eq. (2.2) is not taken into account. Thus, if the hopping term is negative, \(t\) has to be chosen negative as well.

The on-site repulsion term \(U\) is calculated using the method compute_one_body() of the Hubbard class,

# strength of the on-site interactions
U = 2.0
# calculate on-site interaction
onsite = modelham.compute_one_body(U)

Similar to the hopping term, the method requires the strength of the on-site interaction \(U\) as argument. If \(U\) is positive, the on-site interaction is repulsive.

Note

The hopping term is a two-index object of DenseLinalgFactory, while the on-site interaction is a four-index object of DenseLinalgFactory

2.3.2.3. Filling the lattice

The number of electrons/spin-half particles on the lattice is assigned in the Aufbau occupation number model and specifying the total number of electrons using the nel keyword argument. An instance of the AufbauOccModel class is used for setting the occupations in all electronic structure modules.

# define the number of doubly filled lattice sites for m electrons
occ_model = AufbauOccModel(lf, nel=m)

See also The Occupation Model in PyBEST for more details on the occupation model used in PyBEST.

Note

The number of electrons/spin-half particles must be even and the orbital basis (or the on-site basis) must be restricted.

2.3.2.4. Generating the orbital basis and the overlap matrix

In all electronic structure calculations with the Hubbard model Hamiltonian, the model Hamiltonian is evaluated for the local on-site basis and the orbitals represent the transformation from the on-site basis to the molecular orbital basis. Note that the on-site basis is orthonormal. As for the molecular Hamiltonian, the orbitals (or, equivalently, the on-site basis) are initialized using the create_orbital() method of the DenseOrbital class.

# initialize orbitals for n sites (assuming lf = DenseLinalgFactory(n))
orb = lf.create_orbital()

See alse Working with Orbitals in PyBEST for more details on orbitals and how to work with orbitals in PyBEST. The overlap matrix of the Hubbard model can be computed using the compute_overlap() method of the Hubbard class,

# calculate overlap matrix for the on-site basis
olp = modelham.compute_overlap()

2.3.3. Example Python script

2.3.3.1. The 1-dim Hubbard model Hamiltonian with PBC

This example shows how to set up the Hamiltonian, orbitals, and overlap matrix for the half-filled Hubbard model with 6 sites (and hence 3 doubly occupied sites). The hopping term \(t\) is set to -1, while the on-site interaction \(U\) is equal to 2. Periodic boundary conditions are used.

Listing 2.5 data/examples/hamiltonian/hubbard.py

from pybest.linalg import DenseLinalgFactory
from pybest.modelhamiltonians import Hubbard
from pybest.occ_model import AufbauOccModel

# Define LinalgFactory for 6 sites
# --------------------------------
lf = DenseLinalgFactory(6)

# Define Occupation model and expansion coefficients
# --------------------------------------------------
occ_model = AufbauOccModel(lf, nel=6)
orb = lf.create_orbital()


# Initialize Hubbard class
# ------------------------
modelham = Hubbard(lf, pbc=True)


# One and two-body interaction terms defined for the on-site basis
# ----------------------------------------------------------------
# t-param, t = -1
hopping = modelham.compute_one_body(-1)
# U-param, U = 2
onsite = modelham.compute_two_body(2)