BLTMD{
    L<:MoireReciprocalLattice,
    D<:Function,
    S<:OperatorGenerator,
    Q<:Quadraticization,
    H<:CategorizedGenerator{<:OperatorSum{<:Quadratic}}
} <: MoireSystem{NamedTuple{(:a₀, :m, :θ, :Vᶻ, :μ), NTuple{5, Float64}}, L, D, S, Q, H}

Twisted transition metal dichalcogenide homobilayers.

BLTMD(a₀::Number, m::Number, θ::Number, Vᶻ::Number, μ::Number, V::Number, ψ::Number, w::Number; truncation::Int=4)

Continuum model of twisted transition metal dichalcogenide homobilayers.

Here, the parameters are as follows:

• a₀: monolayer lattice constant (Å)
• m: effective mass of the conduction band (mₑ)
• θ: twist angle (°)
• Vᶻ: perpendicular displacement field (meV)
• μ: chemical potential (meV)
• V: amplitude of Moire potential (meV)
• ψ: phase of Moire potential (°)
• w: interlayer hopping amplitude (meV)

BareCoulomb(ϵ::Real)

Bare (unscreened) 2D Coulomb potential: V(q) = 2π e² / (ϵ aₘ |q|). q=0 skipped (returns 0).

CommensurateBilayerHoneycomb

Commensurate Moire superlattice composed of two layers of honeycomb lattices.

(coulomb::CoulombIntegral)(R::AbstractVector{<:Number}, potential=BareCoulomb(1.0))

Compute U(R) = (1/(Nk Ω)) Σq V(|q|, aₘ) |M(q)|² e^{iq·R} in meV.

potential is a callable potential(q::Real, aₘ::Real) -> Real, e.g. BareCoulomb(ϵ), ImageCoulomb(ϵ, d), TanhCoulomb(ϵ, d), or a user-defined function. Defaults to BareCoulomb(1.0) (unscreened, ε=1).

Returns an nband×nband Matrix{Float64} Coulomb interaction matrix.

CoulombIntegral{W<:MoireWannier}

Precomputed Coulomb form factor for a Wannier function.

Fields:

• wannier::W — reference to the Wannier function
• qs::Vector{SVector{2,Float64}} — unique q-vectors from the pairwise convolution
• formfactor::Vector{Matrix{ComplexF64}} — M(q)†M(q) / Nₖ² matrices at each q, (nband×nband)

CoulombIntegral(wannier::MoireWannier)

Construct by computing the form factor M(q) from Bloch coefficients via pairwise convolution.

Algorithm: compute gauge-transformed Bloch coefficients cn(p) for each Wannier function n at extended momenta p=k+G, then for each pair (n,m) accumulate M{m,n}(q) = Σp dot(cn(p+q), c_m(p)). The q-mesh emerges naturally from the G/G' truncation.

HoppingIntegral{W<:MoireWannier}

Hopping amplitude calculator for a Wannier function.

Fields:

• wannier::W — reference to the MoireWannier

Callable as (hopping::HoppingIntegral)(R::AbstractVector{<:Number}) -> Matrix{ComplexF64}:

\[t_{mn}(R) = (1/N) Σ_k exp(-ik·R) [U(k) diag(ε(k)) U†(k)]_{mn}\]

ImageCoulomb(ϵ::Real, d::Real)

Image-charge screened Coulomb: V(q) = 2π e² (1 - e^{-2dₘ|q|}) / (ϵ aₘ |q|) where dₘ = d/aₘ.

MoireHoneycomb{D<:Number} <: MoireSuperlattice{D}

Emergent honeycomb superlattice in Moire systems, composed of XM and MX stacking sites.

MoireReciprocalLattice{T<:Number} <: AbstractLattice{2, T, 0}

Abstract type for Moire reciprocal lattices.

MoireSpace <: SimpleInternal{MoireSpinor{Int, Int, Int, Rational{Int}}}

The internal degrees of freedom of Moire systems.

MoireSpinor{V<:Union{Int, Colon}, L<:Union{Int, Colon}, S<:Union{Int, Colon}, P<:Union{Rational{Int}, Colon}} <: InternalIndex

The index of the internal degrees of freedom of Moire systems.

MoireSuperlattice{D<:Number} <: AbstractLattice{2, D, 2}

Abstract type of the emergent superlattices in Moire systems, parameterized by coordinate type D.

MoireSystem{P<:Parameters, L<:MoireReciprocalLattice, D<:Function, S<:OperatorGenerator, Q<:Quadraticization, H<:CategorizedGenerator{<:OperatorSum{<:Quadratic}}} <: TBA{Fermionic{:TBA}, H, Nothing}

The continuum model of Moire systems.

MoireTriangular{D<:Number} <: MoireSuperlattice{D}

Emergent triangular superlattice in Moire systems.

MoireTriangularReciprocal{T<:Number} <: MoireReciprocalLattice{T}

Moire reciprocal lattice with truncation.

(wannier::MoireWannier)(r::AbstractVector{<:Number}, sublattice::Int=1) -> Vector{ComplexF64}

Evaluate the Wannier function at real-space position r for a given sublattice.

Formula: Wₙˡ(r) = (1/N√Ω) Σ{k, G, ν} bloch{G, l, ν}(k) · U_{ν, n}(k) · e^{i(k+G)·r}, where N is the number of k-points and Ω is the volume of the unit cell in the real space.

MoireWannier{L<:MoireSuperlattice, G<:MoireReciprocalLattice, B<:BrillouinZone}

Wannier function constructed on an emergent Moire superlattice.

Fields:

• aₘ::Float64 — lattice constant of the moire superlattice
• lattice::L — emergent superlattice (MoireTriangular or MoireHoneycomb)
• reciprocallattice::G — truncated plane-wave basis (G-vectors) from the continuum model
• brillouinzone::B — uniform k-point mesh over the moire Brillouin zone
• energies::Matrix{Float64} — raw band energies, (nband, nk)
• bloch::Array{ComplexF64, 4} — raw Bloch eigenvectors, (nlayer, nG, nband, nk), pre-gauge
• U::Array{ComplexF64, 3} — gauge transformation matrices, (nband, nband, nk)

MoireWannier(
    moiresystem::MoireSystem, lattice::MoireHoneycomb, brillouinzone::BrillouinZone;
    bands::UnitRange{Int}=dimension(moiresystem)-1:dimension(moiresystem), tol::Real=atol
)

Construct Wannier functions for a 2-band subspace on a honeycomb lattice.

Steps:

1. Extract raw Bloch states for the 2-band subspace
2. SU(2) rotation: maximize layer polarization via diagonalizing layer projectors
3. U(1) gauge fix: ψ₁(rXM) real positive (Wannier 1 at XM, bottom-layer), ψ₂(rMX) real positive (Wannier 2 at MX, top-layer)

MoireWannier(moiresystem::MoireSystem, lattice::MoireSuperlattice; nk=18, kwargs...)

Convenience constructor that auto-generates a BrillouinZone with nk k-points per dimension from lattice and delegates to the full constructor.

MoireWannier(moiresystem::MoireSystem, lattice::MoireTriangular, brillouinzone::BrillouinZone; band::Int=dimension(moiresystem), tol::Real=atol)

Construct the Wannier function for a single band on a triangular lattice.

Gauge fixing: U(1) phase such that the bottom-layer component at r=0 (MM site) is real and positive.

MoireWannier(moiresystem::Algorithm{<:MoireSystem}, args...; kwargs...)

Forward to the wrapped MoireSystem frontend.

OnsiteAmplitude{N, D} <: Function

Onsite amplitude.

Matches a self-bond to the registered set of reference onsite bonds via QuantumLattices.isparallel and returns 1 (match) or 0 (no match).

RealZone{N, S<:SVector, V<:Number}

A rectangular zone in real space.

Alias for ReciprocalZone with the space-type parameter K = :r.

SpinOrbitalCouplingAmplitude{N, D} <: Function

Spin-orbital-coupling hopping amplitude under translation equivalence.

Matches a bond to the registered reference bonds via QuantumLattices.isparallel, which yields a parity $r = \pm 1$. The final SOC factor is $i \cdot s \cdot r$, where $s$ is the relative sign of the SOC coefficient $\lambda$ between bonds in the same $(t, |\lambda|)$ group (precomputed by terms and stored in signs).

SublatticeAmplitude{N, D} <: Function

Spin-independent hopping amplitude.

Matches a bond to the registered set of reference bonds via QuantumLattices.isparallel and returns 1 (match) or 0 (no match).

TanhCoulomb(ϵ::Real, d::Real)

Gate-screened Coulomb: V(q) = 2π e² tanh(dₘ|q|) / (ϵ aₘ |q|) where dₘ = d/aₘ.

Algorithm(name::Symbol, bltmd::BLTMD, parameters::Parameters; kwargs...)

Construct an Algorithm with a BLTMD as the frontend.

Lattice(moire::CommensurateBilayerHoneycomb, type::Symbol)

Get the minimum unit of the top/bottom layer of a commensurate Moire superlattice composed of two layers of honeycomb lattices.

angle(moire::CommensurateBilayerHoneycomb) -> Float64

Get the twist angle of a commensurate Moire superlattice composed of two layers of honeycomb lattices.

count(moire::CommensurateBilayerHoneycomb) -> Int

Count the number of honeycomb unitcells contained in the unitcell of a commensurate Moire superlattice composed of two layers of honeycomb lattices.

The total number of atoms in the unitcell of the Moire superlattice is 4 times this result because of the AB sublattice and the top/bottom layer degrees of freedom.

count(wannier::MoireWannier) -> Int

Return the number of Wannier orbitals ($n_{\rm band}$).

terms(coulomb::CoulombIntegral, potential=BareCoulomb(1.0); order::Int, ismodulatable::Bool=true, atol::Real=1e-3, rtol::Real=1e-3) -> Tuple{Vararg{Term}}

Generate Coulomb interaction terms from a CoulombIntegral.

potential is a callable potential(q::Real, aₘ::Real) -> Real.

Algorithm

1. Reference bonds — All translationally-inequivalent bonds up to order from bonds(lattice, order).
2. Per-bond extraction — For each neighbor order $k$, coefficient $V = coulomb(R, potential)[i, j]$ extracted per-bond.
3. Grouping — Entries grouped by $V$ value using isapprox with atol/rtol.
4. Term construction — Each group yields a Coulomb term with SublatticeAmplitude.
5. Onsite — Diagonal $coulomb(0, potential)[i, i]$ → Hubbard onsite repulsion.

Naming

• R > 0, single group per shell: V₁, V₂, …
• R > 0, multiple groups per shell: V₁₋₁, V₁₋₂, …
• R = 0 (onsite): U (all equal) or U₁, U₂, … (per-sublattice).

terms(hopping::HoppingIntegral; order::Int, ismodulatable::Bool=true, atol::Real=1e-3, rtol::Real=1e-3) -> Tuple{Vararg{Term}}

Generate spin-independent and spin-orbital-coupling Hopping terms and Onsite terms from a HoppingIntegral.

Algorithm

1. Reference bonds — All translationally-inequivalent bonds up to order from bonds(lattice, order).
2. Per-bond extraction — For each neighbor order $k$, coefficient $t + iλ = hopping(R)[i,j]$ extracted per-bond.
3. Grouping — Entries grouped by $(t, |λ|)$ using isapprox with atol/rtol. Relative signs among grouped $λ$ values are precomputed.
4. Term construction — Each group yields two terms:
   • t → Hopping with SublatticeAmplitude.
   • λ → Hopping with $σᶻ$ coupling and SpinOrbitalCouplingAmplitude.
5. Onsite — Diagonal $hopping(0)[i, i]$ → Onsite chemical potentials.

Naming

• Single group per shell: t₁, λ₁, t₂, λ₂, …
• Multiple groups per shell: t₁₋₁, t₁₋₂, … and λ₁₋₁, λ₁₋₂, …
• Onsite: μ (all equal) or μ₁, μ₂, … (per-sublattice).

truncation(lattice::MoireReciprocalLattice) -> Int

Get the truncation (number of shells) of a Moire reciprocal lattice.

vectors(moire::CommensurateBilayerHoneycomb) -> SVector{2, SVector{2, Float64}}

Get the translation vectors of a commensurate Moire superlattice composed of two layers of honeycomb lattices.

reciprocals(lattice::MoireReciprocalLattice) -> SVector{2, SVector{2, scalartype(lattice)}}

Get the reciprocal translation vectors of a Moire reciprocal lattice.

reciprocals(::Type{<:MoireHoneycomb}, [T=Float64]) -> SVector{2, SVector{2, T}}

Delegates to MoireTriangularReciprocal (shared triangular Bravais lattice).

reciprocals(::Type{<:MoireTriangularReciprocal}, [T=Float64]) -> SVector{2, SVector{2, T}}

Reciprocal-lattice translation vectors for the triangular Bravais lattice underlying Moire superlattices.

reciprocals(::Type{<:MoireTriangular}, [T=Float64]) -> SVector{2, SVector{2, T}}

Delegates to MoireTriangularReciprocal (shared triangular Bravais lattice).