Real-Space Tight-Binding Model

• Real-space tight-binding models are quantum lattice methods defined by localized basis states and operators acting on discrete sites.
• They leverage sparse matrix representations and iterative solvers to efficiently simulate boundary, disorder, and superconducting effects.
• Benchmarking shows linear scaling in memory and time, making these models practical for simulating millions of lattice sites.

A real-space tight-binding model is a formalism in condensed matter physics for describing quantum systems with a discrete set of localized basis states situated at lattice sites, defining the Hamiltonian directly in terms of creation and annihilation operators acting on these sites and their internal degrees of freedom. This approach contrasts with momentum-space treatments and is foundational for both analytic theory and large-scale computational modeling, especially for spatially inhomogeneous materials, confined structures, and systems where boundary and disorder effects are critical. The following sections present the mathematical structure, computational methodologies, physical interpretability, efficiency strategies for large-scale models, and key technical benchmarks as evidenced in "Bodge: Python package for efficient tight-binding modeling of superconducting nanostructures" (Ouassou, 11 Oct 2024).

1. Mathematical Structure of Real-Space Tight-Binding Hamiltonians

The canonical single-orbital, spinless tight-binding Hamiltonian defined on a lattice with $N$ sites is

$$H = \sum_i \varepsilon_i\,c_i^\dagger c_i + \sum_{\langle i, j \rangle} t_{ij}\,c_i^\dagger c_j$$

where $\varepsilon_i$ is the on-site energy of site $i$, $t_{ij}$ is the hopping amplitude between sites $i$ and $j$, and $c_i^\dagger$, $c_i$ are standard fermionic creation and annihilation operators. The sum over $\langle i, j \rangle$ typically covers nearest neighbors but can be systematically extended to longer ranges:

$$H = \sum_i \varepsilon_i\,c_i^\dagger c_i + \sum_{i \neq j} t_{ij}\,c_i^\dagger c_j$$

For systems with internal degrees of freedom (spin or Nambu space for Bogoliubov–de Gennes models), the Hamiltonian is a block-matrix of dimension $dN \times dN$, with $d=2$ for spin and $d=4$ for BdG (particle-hole Nambu spinors).

2. Computational Representation and Implementation

The real-space formalism is ideally suited for computational modeling as algorithms can exploit sparsity, locality, and direct mapping from physical geometry to matrix indices. In Bodge, the key components are:

• Lattice and Sites: Defined by base classes (e.g., Lattice, CubicLattice). lattice.sites() yields all site indices, typically tuples of integer coordinates, and lattice.bonds() produces all hoppable neighbor pairs.
• Hamiltonian Object Construction: The model is instantiated as
  • $H_{\text{sparse}} \in \mathbb{C}^{dN \times dN}$: normal part.
  • $A_{\text{sparse}} \in \mathbb{C}^{dN \times dN}$: anomalous/superconducting part (for BdG).
• Context Manager for Matrix Filling: Direct block-wise assignment:

  with system as (H, A): H[i, j] = ... A[i, j] = ...

  $H[i, j]$ returns a small $d \times d$ numpy view between sites $i, j$.
• Matrix Export: To interface with solvers:

  H_csr = system.matrix(format="csr")

  yields the full $2dN \times 2dN$ CSR matrix for further numerical analysis.

3. Efficiency, Scaling, and Sparse Matrix Techniques

The real-space construction paradigm is optimized for scalability:

• Construction and Storage Cost: Each site and bond is visited once ($O(N)$ for $N$ sites). For $d$-dimensional cubic lattices, the number of nonzero matrix elements is $\sim 2dN$.
• Diagonalization: Standard dense diagonalization is prohibitive for large $N$ ($O(D^3)$ time, $O(D^2)$ memory, $D \sim 4N$ for BdG), so sparse iterative methods (Krylov, Chebyshev polynomial expansion) are essential, scaling like $O(NM)$ for $M$ iterations or moments.
• Benchmark Data: Assembly of $N \sim 10^5$ lattices occurs in milliseconds; handling $N \sim 10^6$ sites requires only a few GB of RAM, and computational performance matches leading packages such as Kwant.

4. Practical Construction Worked Examples

The flexibility of the real-space approach is illustrated by simple code snippets:

1D Chain (BdG, spinful):

from bodge import CubicLattice, Hamiltonian import numpy as np N = 100 t = 1.0 mu = 0.5 Delta = 0.2 lattice = CubicLattice((N, 1, 1)) system = Hamiltonian(lattice) with system as (H, A): for i, j in lattice.bonds(): H[i, j] = -t * np.eye(2) for i in lattice.sites(): H[i, i] = -mu * np.eye(2) A[i, i] = -Delta * np.array([[0, 1], [-1, 0]])

2D Square Lattice with Longer-Range Hopping:

from bodge import CubicLattice, Hamiltonian import numpy as np Lx, Ly = 50, 50 lattice = CubicLattice((Lx, Ly, 1)) system = Hamiltonian(lattice) t1 = 1.0 # nearest t2 = 0.2 # next-nearest with system as (H, A): for i, j in lattice.bonds(): H[i, j] = -t1 * np.eye(2) for i in lattice.sites(): x, y, _ = i for dx, dy in [(1,1), (1,-1),(-1,1),(-1,-1)]: j = (x+dx, y+dy, 0) if lattice.is_valid_site(j): H[i, j] = -t2 * np.eye(2) for i in lattice.sites(): H[i, i] = -0.5 * np.eye(2)

5. Design Choices for Large-Scale Models

Key algorithmic and representational features for handling large systems:

• Sparse-First Principle: All real-space operators are formulated as CSR sparse matrices ($O(N)$ memory). Direct compatibility with sparse linear-algebra solvers.
• Extensible Lattice Framework: Custom lattices (e.g., hexagonal, triangular) can be accommodated by subclassing and defining appropriate sites(), bonds(), edges().
• Pluggable Backends: Both dense numpy arrays and sparse matrices are supported; GPU integration (e.g., CuPy) is in development.
• Solver Interfacing: The framework is agnostic to downstream algorithms; after matrix construction, users may invoke iterative solvers (KPM, Krylov, etc.), building on the $O(N)$ assembly cost.

6. Performance Benchmarks and Comparative Analysis

The following benchmark metrics and comparisons are established (Ouassou, 11 Oct 2024):

N (lattice sites)	Build Time (nearest-neighbor BdG)	Memory Usage (BdG, 4×4 block)	Performance Relative to Kwant
$10^5$	$\lesssim 10$ ms	$\lesssim 50$ MB	Comparable
$10^6$	$\sim$ seconds	$\sim$ 500 MB	Comparable

• Build time scales strictly linearly; memory consumption is also $O(N)$.
• For $N \sim 10^6$, full BdG models can be constructed and diagonalized (iteratively) within available resources. Chebyshev and Krylov solvers exhibit expected $O(N M)$ or $O(N \log N)$ scaling, enabling disorder studies for superconductors far beyond $10^6$ sites.
• The export capability guarantees that constructed matrices interface seamlessly with advanced solver libraries in Python and offer direct compatibility with bespoke numerical routines and external simulation environments.

---

In sum, real-space tight-binding models deliver direct, efficient, and extensible representations of quantum lattice Hamiltonians, whose key advantages—sparse data structures, computational tractability for large $N$, transparent mapping from physical geometry, and compatibility with both analytic and advanced numerical techniques—are exemplified in the Bodge package framework (Ouassou, 11 Oct 2024). This methodology is foundational for the simulation of superconducting heterostructures, nanostructures, and materials with spatially resolved physical phenomena.