2D Hubbard Model

This tutorial shows how to generate a Pauli Hamiltonian from a lattice-based Hubbard model, using isqham. The Hamiltonian is encoded using the Jordan-Wigner transformation.

Prerequisites

Make sure you’ve installed the package (isqham).

import numpy as np

from isqham.lattice.fermionLattice import (
    PrimaryLattice_HubbardModel,
    SuperLatticeHamiltonian,
)
from isqham.qubitEncoding import JordanWignerEncoding

Step 1: Construct the Superlattice Hamiltonian

def getSupH(U):
    basis = np.array([
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
        [0.0, 0.0, 1.0],
    ])

    t = -1.0
    mu = U / 2

    priH = PrimaryLattice_HubbardModel(basis=basis)
    priH.setOrbitPosition(idx=0, pos=[0.0, 0.0, 0.0])
    priH.setHopping(R=[1, 0, 0], orbit_i=0, orbit_j=0, tij=t)
    priH.setHopping(R=[0, 1, 0], orbit_i=0, orbit_j=0, tij=t)
    priH.setCoulombU(orbit_i=0, U=U)
    priH.setOnSide(orbit_i=0, m=-mu)

    supBasis = [
        [1, 1, 0],
        [1, -1, 0],
        [0, 0, 1],
    ]

    supH = SuperLatticeHamiltonian(priHam=priH, superLatticeIndex=supBasis)
    return supH

Step 2: Generate the Fermionic Hamiltonian

def getLatticeHam(U):
    supH = getSupH(U)
    return supH.get_ClusterH()

Step 3: Encode to Pauli Hamiltonian

def getHam(latticeHam):
    return latticeHam.exportPauliOperator(
        JordanWignerEncoding()
    ).exportPauliHamiltonian()

Step 4: Test the Result

ham = getHam(getLatticeHam(U=3.0))

# View coefficients
print("Factors:", ham.get_factor())

# View Pauli operators (encoded as int arrays)
print("Pauli Operators:", ham.get_pauliOperators())

# View constant offset
print("dH:", ham.getdH())

Factors: [0.5, 0.5, 0.5, 0.5, 0.75, 0.75]
Pauli Operators: [[1, 3, 1, 0], [2, 3, 2, 0], [0, 1, 3, 1], [0, 2, 3, 2], [3, 3, 0, 0], [0, 0, 3, 3]]
dH: -1.5

Summary

• Build a primary Hubbard model on a lattice

• Expand it into a superlattice

• Convert the fermionic model to a qubit Hamiltonian

• Export as Pauli operators using Jordan-Wigner encoding

You can now use this Pauli Hamiltonian in VQE, time evolution, or circuit synthesis.