Model Hamiltonians

QDK/Chemistry provides functionality to construct and manipulate model Hamiltonians used in quantum chemistry and condensed matter physics. These model Hamiltonians serve as simplified representations of complex quantum systems, allowing researchers to study their properties and behaviors using quantum computing techniques.

The definition of model Hamiltonians differs from that of regular Hamiltonians in that they do not need to link to a specific molecular structure. Hence, they also do not require the use of integrals derived from quantum chemistry calculations. Instead, model Hamiltonians are defined directly in terms of their parameters.

Creating model Hamiltonians

To define a model Hamiltonian in QDK/Chemistry, users can utilize the ModelOrbitals class, which is a simplified version of the Orbitals class that doesn’t require basis set information or molecular orbital coefficients. This is particularly useful for studying model systems like Hubbard models, Heisenberg models, or other phenomenological Hamiltonians.

Example: Hubbard model Hamiltonian

The following example demonstrates how to create a simple Hubbard model Hamiltonian using ModelOrbitals and the Hamiltonian class:

import numpy as np
import qdk_chemistry.algorithms as algorithms
from qdk_chemistry.data import (
    Hamiltonian,
    CanonicalFourCenterHamiltonianContainer,
    ModelOrbitals,
)

# Define a 4-site Hubbard chain with restricted "orbitals"
num_sites = 4
model_orbitals = ModelOrbitals(num_sites, restricted=True)

# Define model parameters
t = -1.0  # Hopping parameter
U = 4.0  # On-site interaction strength

# Construct one-body integrals (hopping terms)
# For a 1D chain with nearest-neighbor hopping
one_body = np.zeros((num_sites, num_sites))
for i in range(num_sites - 1):
    one_body[i, i + 1] = t
    one_body[i + 1, i] = t

# Construct two-body integrals (on-site repulsion)
# Two-body integrals are stored as a flattened vector
two_body = np.zeros(num_sites**4)
for i in range(num_sites):
    # On-site repulsion: U * n_i↑ * n_i↓
    # In physicist's notation: <ii|ii>
    idx = i * num_sites**3 + i * num_sites**2 + i * num_sites + i
    two_body[idx] = U

# Core energy (usually 0 for model Hamiltonians)
core_energy = 0.0

# Create empty inactive Fock matrix
inactive_fock = np.zeros((0, 0))

# Create the Hamiltonian
hamiltonian = Hamiltonian(
    CanonicalFourCenterHamiltonianContainer(
        one_body, two_body, model_orbitals, core_energy, inactive_fock
    )
)

Using model Hamiltonians with algorithms

Model Hamiltonians created with ModelOrbitals can be used with any QDK/Chemistry algorithm that accepts Hamiltonian objects, including:

Example with multi-configuration calculator:

# Create a multi-configuration calculator
mc_calculator = algorithms.create("multi_configuration_calculator", "macis_cas")

# Run calculation for 2 alpha and 2 beta electrons
energy, wavefunction = mc_calculator.run(hamiltonian, 2, 2)

print(f"Ground state energy: {energy} a.u.")

Further reading