AbstractQAtlas.jl

AbstractQAtlas

The model-independent layer of the QAtlas ecosystem, in the spirit of AbstractFFTs: concrete atlases (QAtlas) implement this package, never the reverse.

Layers:

1. core/ — the abstract type vocabulary for physical quantities: AbstractQAtlasModel, BoundaryCondition (Infinite/OBC/PBC), AbstractQuantity and its hierarchy, the abstract fields, the generic fetch verb (+ its fetch_cached memoization), and the Universality machinery — so atlases and third packages share dispatch types without depending on a full atlas.

2. structure/ — the model-independent definitional correspondences between the core quantities: the transition classification, the quantity⇄exponent map behind the scaling forms, the response-function derivative genealogy (derivative_edge, rooted at FreeEnergy / GrandPotential), the spectral and Fourier graphs, and the Maxwell relations derived from the potentials.

3. relations/ — generic, model-independent physics relations as first-class tested objects with a uniform three-verb interface (residual / check / solve): scaling laws, fluctuation–dissipation identities, Wick's theorem, topological invariants, the spectral/Keldysh web, and finite-size scaling forms.

4. seams — generic verbs whose numerics/values live at the leaves: fetch (reference values, in QAtlas), report→Card (reported values), principal_value_hilbert/spectral_moment (functional numerics), and thermal_derivative/thermal_gradient (AD, in the ForwardDiff/Zygote extensions) — plus the KnowledgeGraph graph layer.

Values do not live here, and neither do model-specific laws. This package owns only what holds universally within a domain — independent of the system's symmetry, Hamiltonian, or any individual detail (Wick's theorem, the fluctuation–dissipation and Maxwell relations, the entropy inequalities, Kramers–Kronig, the scaling laws, …). Reference numbers (critical temperatures, exact magnetizations, exponent tables) AND model-specific relations (the Drude mobility μ=eτ/m, the ±J Nishimori- line energy, the SK de Almeida–Thouless line, single-band R_H=1/ne, …) belong to the implementing atlas (QAtlas), not here. The library is a universal yardstick: apply its relations to measured quantities to check whether a system obeys the laws that must hold regardless of its details.

REPORT_ROUTES

The recognized routes a Card may carry — the how of the value. The cross-check routes are adopted verbatim from QAtlas's schema-v2 verify vocabulary; the measurement routes (:monte_carlo, :dmrg, :mps_qmc, :nrg, :tpq) are for the oracle reporters that push cards into the registry.

RelationVariable

Union of the identity-bearing kinds a relation variable can key on: AbstractQuantity, AbstractField, AbstractCoordinate, AbstractExponent. The type is the variable's identity; the formula letter in the relation body is a private local binding.

AbstractCoordinate

Parent for evaluation-coordinate variables — a frequency ω, a momentum q: the point at which a quantity is evaluated, not a subject of the identity. Coordinates usually appear as lightweight supplied slots rather than typed keys (design note R3); the type exists so they can be keyed when it matters.

AbstractDistribution

Abstract parent type for statistical distributions and state families — the ρ an expectation value is taken against. Concrete subtypes carry their defining parameters as typed fields: the three classical ensembles (MicroCanonical, Canonical, GrandCanonical) and parameterized state families (Squeezed).

AbstractEntanglementMeasure <: AbstractQuantity

Entanglement measures (von Neumann / Rényi entropies, negativity, mutual information, …).

AbstractExponent

Parent for critical-exponent variables (α, β, γ, δ, ν, η, z). Typing exponents separates the critical-exponent β from the inverse temperature InverseTemperature — the two :βs a symbol key conflates. Concrete exponents are introduced when the criticality domain migrates.

AbstractField

Abstract parent type for the intensive control fields a thermodynamic potential depends on. Concrete singleton tags — Temperature, InverseTemperature, MagneticField, ChemicalPotential — name the variable a response function is differentiated with respect to.

AbstractGap <: AbstractQuantity

Spectral gaps (mass, charge, spin channels).

AbstractIndex

Abstract parent for the internal degrees of freedom a tensor quantity's indices run over. Concrete singleton tags — SpinAxis, SpatialDirection, OrbitalIndex — name what an index is, so index_spaces can report a quantity's index structure without enumerating the (model-dependent) range of values.

AbstractInequality <: AbstractRelation

A relation asserting an inequality rather than an equality. Its residual is the slack in the ≥ 0 form: the relation holds iff residual ≥ 0 (within tolerance), so check tests that direction instead of abs(residual) ≤ atol. solve still returns the saturation value — where the slack vanishes, i.e. the tight bound (e.g. solve(Subadditivity(), Val(:S_AB)) gives the maximum S_A + S_B). Declared with @bound, which also records the statement's roles — bounded_slot, bounding_slot, bound_direction.

AbstractMagnetization <: AbstractQuantity

Order-parameter expectation values ⟨M_α⟩ and their site-resolved variants.

AbstractNonlinearProcess

A named nonlinear process, i.e. a choice of frequency arguments for χ⁽ⁿ⁾(ω₁, …, ωₙ). WaveMixing is the general (and currently only) concrete form.

A process is not a quantity — it is a cut through one. The quantity is the order-n DynamicalSusceptibility (or DynamicalConductivity in the current channel); the process says which of its frequency arguments to evaluate.

AbstractPropagator <: AbstractQuantity

Single-particle propagators — retarded/advanced/Matsubara Green's functions and the self-energy — the (q, ω)-resolved objects the Dyson equation relates.

AbstractQAtlasModel

Abstract parent type for every atlas model. Concrete subtypes carry their physics parameters as typed fields, e.g.

struct TFIM <: AbstractQAtlasModel
    J::Float64
    h::Float64
end

Implementing packages (QAtlas and friends) subtype this and register fetch methods per (model, quantity, bc) triple.

AbstractQuantity

Abstract parent type for quantities. Concrete quantity structs (e.g. struct SpecificHeat <: AbstractQuantity end, or the index- parametric Susceptibility{A,B} for tensor quantities) make dispatch static and naming explicit (axis, entropy variant, …). Tensor character is carried by the tensor_rank / index_spaces / indices traits.

AbstractRelation

Abstract parent type for physics relations. Concrete relations are declared with @relation and implement the three verbs:

• residual(rel; vars...) — signed violation; 0 ⇔ satisfied.
• check(rel; atol=0, vars...) — |residual| ≤ atol.
• solve(rel, Val(:x); vars...) — the value of x implied by the remaining variables.

The three verbs also have a type-keyed form — residual(rel, b::Bag), check(rel, b), solve(rel, Q::Type, b) — that reads variables from a bag by their quantity/field TYPE instead of a formula symbol; see Bag.

Exact-arithmetic contract: residual and solve must not promote their inputs — Rational in ⇒ Rational out, so exactly-known values (e.g. the 2D Ising exponents) satisfy their relations exactly (residual == 0//1), not merely to floating-point tolerance.

Relations whose variables include an inverse temperature accept either β or T (exactly one) at every public verb; the normalization happens once, in the verb layer — kernels only ever see β.

AbstractRepresentation

The space a quantity is expressed in. Spatial: RealSpace r ↔ MomentumSpace q. Temporal: TimeDomain t ↔ FrequencyDomain ω. Fourier-conjugate spaces are paired by fourier_conjugate.

AbstractResponse

Parent type for a representation of a response FUNCTION over frequency (or (q, ω)) — an (ω, values) grid, an analytic pole–residue rep, … — that the functional sibling can transform. AbstractQAtlas owns only this abstract type and the evaluation verbs (principal_value_hilbert, spectral_moment); the concrete representations and their methods live in the functional package (the fetch-style seam: the interface here, the numerics there).

AbstractStructureFactor <: AbstractQuantity

Momentum-space structure factors S(q).

AbstractSusceptibility <: AbstractQuantity

Linear and nonlinear response susceptibilities χ⁽ⁿ⁾_{α;β₁…βₙ} — see Susceptibility for the arbitrary-order tensor.

AbstractThermalPotential <: AbstractQuantity

Scalar thermodynamic potentials and their densities (energy, free energy, entropy, specific heat, …).

AbstractTransition

Abstract parent type for phase-transition kinds. Concrete subtypes (FirstOrder, ContinuousTransition, KosterlitzThouless) are singleton tags carrying the generic classification traits (ehrenfest_order, has_order_parameter, has_latent_heat, has_critical_exponents).

The classification is anchored in the free energy: an n-th order transition is one whose n-th free-energy derivative is the first to be discontinuous or divergent.

AbstractTwoPointCorrelation <: AbstractQuantity

Two-point correlation functions ⟨Oi Oj⟩ (connected or full).

AbstractVelocity <: AbstractQuantity

Characteristic velocities (Fermi, Luttinger, Lieb-Robinson, …).

AdvancedGreensFunction() <: AbstractPropagator

The advanced single-particle Green's function G^A(q, ω). The adjoint partner of the retarded one, G^A = (G^R)† (scalar: G^A(ω) = conj(G^R(ω))), so G^R − G^A = 2i Im G^R is the (un-normalized) spectral weight. Part of the Keldysh triple (G^R, G^A, G^K) — see relations/keldysh.jl.

AdvancedSelfEnergy() <: AbstractPropagator

The advanced self-energy Σ^A(q, ω) = (Σ^R)† — the advanced member of the Keldysh RAK triple; the self-energy counterpart of AdvancedGreensFunction.

AnyOf{G}

Slot quantifier: the relation holds for one member of the abstract group G, and the caller says which (check(rel, b; subject = MassGap)).

Unlike EachOf, such a relation is not auto-discoverable: the engine cannot know which member a one-member law is about, so relation_report does not instantiate it and applicable_relations does not list it. ambiguous_relations lists them instead — the pending work is visible rather than silently absent.

BB84KeyRate() <: AbstractQuantity

The BB84 asymptotic secret-key rate R(e) = 1 − 2 H₂(e) at qubit error rate e, with H₂ the binary entropy (Shor & Preskill, [1]) — a provably ACHIEVABLE rate, so it bounds the extractable secret-key fraction from below; positive for e < 11%. A bounding value, and a LOWER one.

Bounds SecretKeyRateBound.

Bag

A type-keyed data bag: Dict{VariableKey,Any} mapping a variable's VariableKey to its value. Build one with bag.

BekensteinBound() <: AbstractQuantity

The Bekenstein universal ceiling on the entropy of a system of radius R and energy E, S_max = 2π R E in units ħ = c = k_B = 1 ([2]). A bounding value.

Bounds BekensteinEntropyBound.

BerryCurvature() <: AbstractQuantity

The Berry curvature Ω(k) of a band — the momentum-space field strength Ω = ∂_{k_x} A_y − ∂_{k_y} A_x of the Berry connection (Berry, [3]). Its Brillouin-zone integral is the ChernNumber; it also drives the intrinsic anomalous Hall effect (Xiao, Chang & Niu, [4]).

Note (scope): the Berry curvature is the imaginary part of the quantum geometric tensor; the real part (the quantum metric) and the mixed-state / Uhlmann generalizations are deliberately out of this package's scope.

Bosonic()

Bose–Einstein exchange statistics tag.

BoundaryCondition

Abstract parent type. The three concrete subtypes carry system-size information where applicable, so fetch can read it from the BC instead of kwargs:

• Infinite — thermodynamic limit; no size.
• PBC(N::Int) — periodic boundary conditions at finite N.
• OBC(N::Int) — open boundary conditions at finite N.

For backward compatibility, the zero-argument constructors PBC() and OBC() exist and set N = 0, which signals "caller will pass N via kwargs" — legacy fetch methods still look at kwargs[:N]. New fetch methods read bc.N directly.

BoundaryModeCount() <: AbstractQuantity

The number of protected boundary (edge / surface) modes of a topological phase — fixed by the bulk topological invariant through the bulk–boundary correspondence, n = |ν| (Hasan & Kane, [5]). See BulkBoundary.

CHSHBound() <: AbstractQuantity

The largest CHSH correlator S = E(a,b) + E(a,b′) + E(a′,b) − E(a′,b′) a given physical theory admits: 2 for local hidden variables ([6]), 2√2 for quantum mechanics (Tsirelson, [7]), 4 for any no-signalling theory (Popescu–Rohrlich, [8]). A bounding value; which regime a fetched number belongs to is a scheme distinction on the consumer's registry row, not a separate quantity.

Bounds CHSHInequality.

Canonical(β)
Canonical(; β=nothing, T=nothing)

Canonical (Gibbs) ensemble at inverse temperature β, weight w(E) = e^{−βE}. Constructible from either β or T.

Card

One schema-v2 verification/report card: a computed subject value for hub = "TypeName(model)/TypeName(quantity)/TypeName(bc)", obtained via route, with its error_bar, independence class, status, any independent cross-check values, atol, refs, and a provenance discriminant. Build one with report; serialize a stream with card_jsonl.

status is :divergent (and subject is nothing) when the reported value is non-finite — a NaN/Inf is never emitted as a raw token.

CarrierDensity() <: AbstractQuantity

The charge-carrier number density n — sets the electrical conductivity through the mobility (σ = n e μ) and the Hall coefficient (R_H = 1/n e).

CentralCharge() <: AbstractQuantity

Central charge c of the critical theory's CFT.

ChaosBound() <: AbstractQuantity

The Maldacena–Shenker–Stanford ceiling on the OTOC Lyapunov exponent, λ_max = 2π/β in units ħ = k_B = 1 ([9]) — saturated by holographic and large-N SYK models. A bounding value.

Bounds LyapunovChaosBound.

ChargeGap() <: AbstractGap

Charge (Mott) gap of an electron system,

Δ_c = E₀(N+1) + E₀(N−1) − 2 E₀(N),

the cost of adding a particle plus the cost of removing one — equivalently the gap to the lowest charged excitation. Strictly positive in a Mott insulator and zero in a metal; rigorous closed form for the half-filled 1D Hubbard chain (Lieb & Wu, [10]).

Sector-resolved, and so not interchangeable with MassGap: the two agree only when the lowest excitation of the whole spectrum happens to be the charged one.

ChemicalPotential <: AbstractField

The chemical potential μ. Conjugate to the particle number (N = −∂Ω/∂μ for the grand potential Ω); the defining field of the GrandCanonical ensemble.

ChernNumber() <: AbstractQuantity

The (first) Chern number C ∈ ℤ of a set of bands — the Brillouin-zone integral of the Berry curvature, C = (1/2π) ∫_BZ Ω(k) d²k (Thouless, Kohmoto, Nightingale & den Nijs, [11]). It sets the quantized Hall conductance (TKNN) and, via the bulk–boundary correspondence, the number of chiral edge modes.

ChiralCondensate() <: AbstractQuantity

Vacuum expectation value ⟨ψ̄ψ⟩ of a fermion bilinear, signalling spontaneous (anomalous) chiral-symmetry breaking. The massless Schwinger model is the canonical 1+1-D example: even though the classical Lagrangian is chirally symmetric, the anomaly forces a non-zero condensate

⟨ψ̄ψ⟩ = − exp(γ_E) · e / (2π^{3/2}),    m_γ = e/√π.

(Schwinger 1962; Coleman-Jackiw-Susskind 1975.)

Concurrence() <: AbstractEntanglementMeasure

The two-qubit concurrence C ∈ [0, 1] (Wootters, [12]) — an entanglement monotone; C = 0 for separable, C = 1 for a Bell pair. Its square is the Tangle.

ConditionalEntropy() <: AbstractEntanglementMeasure

The conditional entropy S(A|B) = S(AB) − S(B) — can be negative quantum-mechanically (a signature of entanglement), unlike its classical counterpart.

Conductivity{I}() <: AbstractQuantity
Conductivity(μ, ν₁, …, νₙ)            # each a Symbol

The DC (static) electrical conductivity of arbitrary response order — the n-th order current response j_μ = Σ σ⁽ⁿ⁾_{μ; ν₁…νₙ} E_{ν₁}…E_{νₙ}, a rank-(n+1) tensor in SpatialDirection space with one current direction μ and n field directions. response_order = length(I) − 1:

• Conductivity(:x, :y) — linear σ_xy (order 1); its Hall component is quantized by TKNN;
• Conductivity(:x, :y, :z) — second-order σ⁽²⁾, and so on.

This is the zero-frequency response (frequency_arguments == 0), the current-channel analogue of the static Susceptibility; like it, it carries intrinsic permutation symmetry over its field indices (at zero frequency). Its ω → 0 limit fixes it from the frequency-resolved AC DynamicalConductivity σ⁽ⁿ⁾(ω₁, …, ωₙ) (optical σ(ω), the photogalvanic σ⁽²⁾(ω₁, ω₂), Drude / f-sum rule) — the current-channel mirror of DynamicalSusceptibility.

ConnectedSpinCorrelation{A,B}() <: AbstractTwoPointCorrelation
ConnectedSpinCorrelation(a::Symbol, b::Symbol)

The connected (cumulant) two-point spin correlation ⟨S^A_i S^B_j⟩_c = ⟨S^A_i S^B_j⟩ − ⟨S^A_i⟩⟨S^B_j⟩ — the disconnected product subtracted off, so it decays to zero at large separation even in a symmetry-broken phase. The connected companion of the (full) SpinCorrelation {A,B}; ConnectedSpinCorrelation(:z, :z) is ⟨σᶻ_i σᶻ_j⟩_c.

ContinuousTransition <: AbstractTransition

A continuous (second-order / critical) transition: the free energy and its first derivatives are continuous, while second derivatives — the SpecificHeat C = −T ∂²F/∂T² and the susceptibility χ = −∂²F/∂h² — diverge. The correlation length diverges, so the singularities are power laws governed by CriticalExponents; the critical_scaling correspondence assigns each observable its exponent.

CorrelationLength() <: AbstractQuantity

Correlation length ξ (units of lattice spacing). In a gapped phase it is set by the gap and velocity, ξ = v/Δ (CorrelationLengthGap).

CriticalExponents() <: AbstractQuantity

Standard set of equilibrium critical exponents {α, β, γ, δ, ν, η} of a universality class. Returns a NamedTuple.

For exact values: fields are Rational{Int}. For numerical estimates: fields are Float64 with corresponding _err fields (e.g., β_err) giving the uncertainty.

The scaling relations these exponents must satisfy are first-class objects in this package — see Rushbrooke, Widom, Fisher, Josephson and the convenience gate exponents_consistent.

CriticalScaling(exponent, power)

The reduced-temperature critical law of a quantity: Q ∼ |t|^{power·e} where t = (T − T_c)/T_c and e is the critical exponent named exponent (a field of a CriticalExponents NamedTuple). power = +1 for a quantity that vanishes at criticality (e.g. the order parameter, M ∼ |t|^{+β}), power = −1 for one that diverges (e.g. χ ∼ |t|^{−γ}, ξ ∼ |t|^{−ν}, C ∼ |t|^{−α}).

CriticalTemperature() <: AbstractQuantity

Critical temperature T_c of a finite-temperature phase transition.

Generic home for a tag that previously lived inside a model file.

CurrentCorrelation{I}() <: AbstractQuantity
CurrentCorrelation(μ, ν₁, …, νₙ)              # each a Symbol

The n-time current–current correlation — the microscopic Kubo kernel of the DynamicalConductivity, the current-channel analogue of the DynamicalCorrelation. The linear CurrentCorrelation(:x, :y) is the two-point ⟨j_x(t) j_y(0)⟩ whose retarded part gives σ_xy(ω); the order-n term is the (n+1)-point current correlation with n independent time differences (frequency_arguments == n), matching the order of the conductivity it feeds (order-faithful Kubo edge).

CurrentNoise{I}() <: AbstractQuantity
CurrentNoise(μ, ν)                            # each a Symbol

The (symmetrized) current-noise spectral density S^j_μν(q, ω) — the current-channel structure factor: the space-time Fourier transform of the CurrentCorrelation (mirroring DynamicalStructureFactor ↔ DynamicalCorrelation) and the fluctuation partner of the dissipative Re σ_μν(ω) via the Johnson–Nyquist fluctuation–dissipation theorem (Nyquist, [13]; Callen & Welton, [14]). frequency_arguments == 1.

CurrentResponseKernel{I}() <: AbstractQuantity
CurrentResponseKernel(α, β₁, …, βₙ)          # each a Symbol

The current-channel mirror of ResponseKernel: the time-domain kernel whose Fourier transform is DynamicalConductivity. Same causal support, same order parametrisation; it exists so the response and current channels each have both sides of their Fourier edge, as the spin and current correlation channels already do.

DensityOfStates() <: AbstractQuantity

The density of states ρ(ω) = (1/N) Σ_q A(q, ω) — the Brillouin-zone average of the SpectralFunction.

DerivationStep(relation, output, inputs)

One directed edge of the derivation graph: relation computes the variable output::Symbol from the variables inputs::Tuple{Vararg{Symbol}} (its other variables), via solve(relation, Val(output); inputs...).

DerivationTrace

The meta-information returned by derive(...; debug=true): the target symbol, its computed value, the ordered steps that produced it, and indirect — false only when the target was among the supplied knowns (a direct value), true when it was derived through one or more relations. The trace exists for SAFETY: an indirectly derived value is auditable by its route rather than trusted blindly.

DerivativeEdge(parent, field)

One edge of the response genealogy: the quantity carrying this edge is, up to a model-independent prefactor, ∂(parent)/∂(field) — a derivative of quantity type parent with respect to field type field. The exact prefactor/sign is supplied by the corresponding relation (e.g. GibbsHelmholtz for the energy's β-edge).

DiffusionConstant() <: AbstractQuantity

The (charge / particle) diffusion constant D — tied to the mobility by the Einstein relation μ = e D / k_B T and to the conductivity by σ = e² D N(ε_F).

DrudeWeight{I}() <: AbstractQuantity
DrudeWeight(μ, ν)                             # each a Symbol

The Drude weight (charge stiffness) tensor D_μν — the coefficient of the zero-frequency delta in the real optical conductivity, Re σ_μν(ω) = π D_μν δ(ω) + σ^reg_μν(ω) (Scalapino, White & Zhang, [15]). A rank-2 tensor in SpatialDirection space; D_μν > 0 signals a (perfect) conductor. Fixed by the DynamicalConductivity via the optical sum rule.

DynamicalConductivity{I}() <: AbstractQuantity
DynamicalConductivity(μ, ν₁, …, νₙ)           # each a Symbol

The AC (frequency-resolved) electrical conductivity of arbitrary response order — the current-channel mirror of DynamicalSusceptibility and the frequency-resolved counterpart of the DC Conductivity (its ω → 0 limit).

The linear DynamicalConductivity(:x, :y) is the optical conductivity σ_xy(ω) (Drude peak, f-sum rule, Kramers–Kronig between Re and Im). The n-th order term DynamicalConductivity(μ, ν₁, …, νₙ) is σ⁽ⁿ⁾_{μ; ν₁…νₙ}(ω₁, …, ωₙ): the field acts at n distinct times, so the response is intrinsically multi-time — frequency_arguments == n == response_order. DynamicalConductivity(:x, :y, :z) is the second-order σ⁽²⁾(ω₁, ω₂) of the photogalvanic / second-harmonic response. Its microscopic Kubo expression is the retarded n-time current–current correlation (CurrentCorrelation; see structure/spectral.jl).

DynamicalCorrelation{I}() <: AbstractQuantity
DynamicalCorrelation(α, β₁, …, βₙ)             # each a Symbol

The space-and-time-resolved correlation of arbitrary order — the microscopic kernel of the Kubo response, carrying the same order as the DynamicalSusceptibility it feeds.

The linear DynamicalCorrelation(:x, :y) is the two-point ⟨A^x(r, t) A^y(0, 0)⟩ whose space-time Fourier transform is the DynamicalStructureFactor S(q, ω) — one time difference, frequency_arguments == 1.

The n-th order term DynamicalCorrelation(α, β₁, …, βₙ) is the (n+1)-point function ⟨A^α(t) A^{β₁}(t₁) ⋯ A^{βₙ}(tₙ)⟩ — n+1 operators at n independent time differences, so it is intrinsically n-time (frequency_arguments == n == response_order). Its n-fold nested-commutator (retarded) part is exactly the Kubo kernel of the order-n DynamicalSusceptibility(α, β₁, …, βₙ) (Kubo, [16] for n = 1; the n-th order generalisation is Peterson, [17]): an n-th order response is an n-time correlation.

DynamicalExponent() <: AbstractQuantity

The dynamical critical exponent z relating spatial and temporal scaling at a quantum critical point, Δ ∼ ξ^{−z} (equivalently ω ∼ k^z). z = 1 for a Lorentz-invariant (relativistic) critical point.

DynamicalSpinStructureFactor{A,B}() <: AbstractStructureFactor
DynamicalSpinStructureFactor(a::Symbol, b::Symbol)

The axis-resolved dynamical spin structure factor S^{AB}(q, ω) — the space-time Fourier transform of the SpinCorrelation ⟨S^A_i S^B_j⟩, a rank-2 tensor in SpinAxis space (DynamicalSpinStructureFactor(:z, :z) = S^{zz}(q, ω)). The component-resolved companion of the axis-agnostic DynamicalStructureFactor; its frequency integral gives the static SpinStructureFactor {A,B}.

DynamicalStructureFactor() <: AbstractStructureFactor

The dynamical structure factor S(q, ω) — the space-time Fourier transform of the DynamicalCorrelation; obeys detailed balance S(q, −ω) = e^{−βω} S(q, ω) and the fluctuation–dissipation link to the DynamicalSusceptibility.

DynamicalSusceptibility{I}() <: AbstractSusceptibility
DynamicalSusceptibility(α, β₁, …, βₙ)          # each a Symbol

The dynamical susceptibility of arbitrary response order — the frequency-domain (multi-time) counterpart of the static Susceptibility. The linear DynamicalSusceptibility(:x, :y) is χ_xy(ω), one frequency argument, and its imaginary part χ''(q, ω) is the dissipative response of the fluctuation–dissipation theorem and the NMR relaxation rate.

The n-th order term DynamicalSusceptibility(α, β₁, …, βₙ) is χ⁽ⁿ⁾_{α;β₁…βₙ}(ω₁, …, ωₙ): the field is applied at n distinct times, so the response is intrinsically multi-time — frequency_arguments == n (response_order). DynamicalSusceptibility(:x, :y, :z) is the second-order χ⁽²⁾(ω₁, ω₂) of two-dimensional coherent spectroscopy (Wan & Armitage, [18]). Its microscopic Kubo expression is the n-fold nested-commutator response function (Kubo, [16] is the linear n = 1 case; the general n-th order formal theory is Peterson, [17]); see structure/spectral.jl.

The static Susceptibility{I} of the same order is the zero-frequency limit, χ⁽ⁿ⁾(0, …, 0).

EachOf{G}

Slot quantifier: the relation holds for every member of the abstract group G. Written as a slot key, g::EachOf{AbstractGap}, it behaves exactly like a parametric-family slot — relation_report auto-discovers each concrete member present in a bag and emits one row per member.

Use it only when the law really is member-agnostic (every gap ≥ 0). For a law about one member, use AnyOf — stating it with EachOf reports the other members as violated purely because they share a supertype.

EffectiveMass() <: AbstractQuantity

The band effective mass m* — the inertial mass entering the Drude mobility μ = e τ / m*.

ElectricCurrent() <: AbstractQuantity

The electric (charge) current density j_μ — a rank-1 vector in SpatialDirection space; the response half of the Conductivity (j_μ = σ_μν E_ν) and one of the two currents of the Onsager transport matrix (with HeatCurrent).

Energy{G}() <: AbstractThermalPotential
Energy()                 # G = :natural — model-and-BC-natural granularity
Energy(:total)           # explicit ⟨H⟩
Energy(:per_site)        # explicit ⟨H⟩ / N

Ground-state / thermal energy expectation. The type parameter G makes the granularity (total vs per-site) a dispatch axis instead of a hidden docstring contract.

Energy() resolves to the model's native granularity via the native_energy_granularity trait. Use the explicit constructors when the caller needs a specific granularity.

EnergyVariance() <: AbstractQuantity

The energy variance Var(H) = ⟨H²⟩ − ⟨H⟩² — zero iff the state is an exact eigenstate, the convergence metric of a variational / DMRG calculation.

FermiVelocity = Velocity{:fermi}

Fermi velocity v_F = ∂ε/∂k |_{k = k_F} — the slope of the dispersion at the Fermi level. Well defined for a non-interacting or mean-field band structure (tight-binding lattices, Bogoliubov–de Gennes spectra, Dirac cones).

A kind of Velocity rather than a type of its own, so it reaches every relation whose v slot is typed on the family.

Fermionic()

Fermi–Dirac exchange statistics tag.

FermionicEntanglementEntropy() <: AbstractEntanglementMeasure

The von Neumann entropy of the state restricted to the fermionic algebra of a region, S_f(A) = −Tr(ρ^f_A ln ρ^f_A), where ρ^f_A is obtained by restricting the Majorana covariance matrix to A's Majorana indices.

Distinct from VonNeumannEntropy and not interchangeable with it. Under a Jordan–Wigner map, the spin operators of a region carry a string that leaves the region unless the region is a single contiguous interval, so the spin algebra of A and the fermion algebra of A are the same algebra only in that case. Measured on the open Δ = 0 XXZ chain at N = 12 (QAtlas):

Exact agreement on the contiguous region, and a gap of 0.1–0.2 nats on the disconnected ones — a gap that does not cancel in the mutual information (there I_spin is roughly twice I_f). Nothing in the entropy inequalities would flag a route that returned one where the other was asked for: both are honest von Neumann entropies of honest states, so both satisfy every one of them. That is why this is a separate quantity rather than a keyword on VonNeumannEntropy — a shared VariableKey would let the two mix inside one bag, and region_report keys its auto-discovery on that.

This is the quantity the multi-interval Calabrese–Cardy / Casini–Huerta closed forms predict: for free fermions the entanglement entropy of an arbitrary union of intervals is a signed sum of the bipartite chord kernel over the endpoint pairs, and the object it reproduces is S_f, not the spin entropy.

FidelitySusceptibility() <: AbstractQuantity

Fidelity susceptibility χ_F(λ) = −∂²⟨ψ(λ)|ψ(λ + δλ)⟩/∂δλ².

FillingFactor() <: AbstractQuantity

The Landau-level filling factor ν = n h /(e B) — the number of filled Landau levels; quantizes the Hall resistance R_xy = h/(ν e²).

FirstOrder <: AbstractTransition

A first-order (discontinuous) transition: the first derivative of the free energy jumps. Concretely — a discontinuity in the order parameter M = −∂F/∂h and/or the entropy S = −∂F/∂T (the latter giving a latent heat L = T ΔS). No diverging correlation length, hence no critical exponents in the continuous-transition sense.

FractalDimension() <: AbstractQuantity

Hausdorff dimension d_H of the random geometric set associated with a model — e.g. the SLEκ curve's `dH(κ) = min(2, 1 + κ/8)` (Beffara 2008). Real-valued, dimensionless, capped at the ambient space dimension.

FreeEnergy() <: AbstractThermalPotential

Helmholtz free energy per site, f = -β⁻¹ log Z / N.

Frequency <: AbstractCoordinate

The frequency ω at which a dynamical quantity is evaluated.

FrequencyDomain <: AbstractRepresentation

Frequency-domain representation (ω) — conjugate to TimeDomain.

Global <: Support

The trivial support: a bulk, whole-system quantity with no region/point decoration. The default support of every variable.

GrandCanonical(β, μ)
GrandCanonical(; μ, β=nothing, T=nothing)

Grand-canonical ensemble at inverse temperature β and chemical potential μ, weight w(E, N) = e^{−β(E − μN)}.

GrandPotential() <: AbstractThermalPotential

The grand potential Ω = −β⁻¹ log Ξ = F − μN — the generating potential of the grand-canonical ensemble, the Legendre transform of the FreeEnergy that trades the particle number N for the chemical potential μ. It is the second root of the response genealogy: the particle number is its μ-derivative, N = −∂Ω/∂μ (the grand-canonical analogue of M = −∂F/∂h).

GreaterGreensFunction() <: AbstractPropagator

The greater Green's function G^>(q, ω) ∼ −i⟨A(t)A†(0)⟩. With its lesser partner it builds the RAK components: G^R − G^A = G^> − G^< and G^K = G^> + G^<; in equilibrium the two obey the KMS/detailed-balance relation G^<(ω) = ζ e^{−βω} G^>(ω) (ζ = +1 bosons, −1 fermions).

GroundStateDegeneracy() <: AbstractQuantity

Dimension of the ground-state subspace as an Int. In topologically ordered phases this is a robust, lattice-independent invariant determined by the ambient surface (e.g. 4^g on a closed orientable genus-g surface for the toric code) and is set by the kwarg genus on the fetch call. Trivially 1 for any gapped, symmetry-unbroken phase.

GrowthExponents() <: AbstractQuantity

KPZ-type growth / roughness / dynamic exponents. Returns (β_growth, α_rough, z) instead of the equilibrium set.

HallCoefficient() <: AbstractQuantity

The Hall coefficient R_H = E_y / (j_x B_z) — for a single carrier band R_H = 1/(n e), fixing the carrier density and sign from the transverse (Hall) voltage.

HeatCurrent() <: AbstractQuantity

The heat (thermal energy) current density j^Q_μ — a rank-1 vector in SpatialDirection space; the current driven by a temperature gradient (j^Q_μ = −κ_μν ∂_ν T at zero electric current) and the Onsager partner of the ElectricCurrent.

Infinite()

Thermodynamic-limit boundary condition — no finite size.

InverseTemperature <: AbstractField

The inverse temperature β = 1/T. The natural variable of the Gibbs–Helmholtz relation U = ∂(βF)/∂β.

IsobaricSpecificHeat() <: AbstractThermalPotential

Specific heat at constant pressure, c_p. Exceeds the constant-volume SpecificHeat c_v by c_p − c_v = T v α² / κ_T (HeatCapacityDifference).

IsothermalCompressibility() <: AbstractQuantity

The isothermal compressibility κ_T = −(1/V)(∂V/∂p)_T.

KeldyshGreensFunction() <: AbstractPropagator

The Keldysh component G^K(q, ω) of the contour-ordered Green's function in the retarded–advanced–Keldysh (RAK) rotation. G^K = G^> + G^< carries the occupation/distribution information; in equilibrium it is fixed by the fluctuation–dissipation theorem G^K = h(ω)(G^R − G^A) with h = coth(βω/2) (bosons) or tanh(βω/2) (fermions) — see relations/keldysh.jl.

KeldyshSelfEnergy() <: AbstractPropagator

The Keldysh component of the self-energy Σ^K(q, ω) = Σ^> + Σ^< — the statistical (distribution-carrying) member of the RAK triple; the self-energy counterpart of KeldyshGreensFunction. In equilibrium it is locked to the broadening by the fluctuation–dissipation tie Σ^K = h(ω)(Σ^R − Σ^A).

KineticEnergy() <: AbstractThermalPotential

The kinetic-energy expectation ⟨T⟩ — the T of the virial theorem 2⟨T⟩ = n⟨V⟩ (homogeneous potential of degree n).

KnowledgeGraph{N}(edges)

A knowledge graph over nodes of type N: a list of TypedEdges. The generic parent the quantity / derivation / model graphs instantiate; iterate it to get its edges (for e in g, length(g), collect(g)). Query it with graph_nodes, graph_neighbors, graph_reachable, graph_shortest_path; export it with graph_jsonl.

KosterlitzThouless <: AbstractTransition

The Berezinskii–Kosterlitz–Thouless transition (2D XY and relatives): an infinite-order transition with an essential singularity in the free energy (ξ ∼ exp(c/√(T−T_c)), not a power law) and no local order parameter (Mermin–Wagner). The standard equilibrium critical exponents do not apply; the transition is characterized instead by the universal helicity-modulus jump.

LatentHeat() <: AbstractQuantity

The latent heat L = T ΔS of a first-order transition — the entropy jump across the phase boundary times the temperature. Enters the Clausius–Clapeyron relation (ClausiusClapeyron).

LesserGreensFunction() <: AbstractPropagator

The lesser Green's function G^<(q, ω) ∼ ±i⟨A†(0)A(t)⟩. The occupied-state counterpart of GreaterGreensFunction; see there for the RAK and KMS relations tying the two.

LiebRobinsonVelocity() <: AbstractVelocity

The Lieb–Robinson velocity v_LR setting the linear light cone for information propagation in a local lattice quantum system: for local operators A_x, B_y separated by |x − y|,

‖[A_x(t), B_y(0)]‖ ≤ C exp(−μ (|x − y| − v_LR t)).

For free-fermion-mappable spin chains (TFIM, XY, the XX limit of XXZ) the bound is saturated and v_LR equals the maximum single-particle group velocity max_k |dΛ/dk|.

This is the v_LR slot of LiebRobinsonBound. The bound CHARACTER lives in that inequality — v ≤ v_LR — and not in a second quantity: an atlas that also wants to record "this number is a saturating upper bound" says so on the registry row (status = :bound), which is what the row's scheme key is for. QAtlas carried a separate LiebRobinsonBound quantity returning the identical closed form 2 min(|J|, |h|) for that reason, which made it a second type for one physical quantity.

Lieb & Robinson, [19]; Hastings & Koma, [20].

LogarithmicNegativity() <: AbstractEntanglementMeasure

Logarithmic negativity E_N = log Tr|ρ^{T_B}|, the trace norm of the partial transpose. A mixed-state entanglement measure: unlike VonNeumannEntropy it stays meaningful when the two subsystems are not complementary halves of a pure state (finite β, or a traced-out remainder).

LoschmidtAmplitude() <: AbstractQuantity

The Loschmidt echo L(t) = |⟨ψ₀|e^{-i H_f t}|ψ₀⟩|² ∈ [0, 1] after a sudden quench, at finite N. Not meaningful in the thermodynamic limit, where it vanishes identically because its cumulants are extensive — the intensive statement there is LoschmidtRateFunction.

Note the square: this is the echo itself, not the overlap.

LoschmidtRateFunction() <: AbstractQuantity

The Loschmidt rate function

λ(t) = -log L(t) / N          (finite N)
λ(t) = -lim_{N→∞} log L(t)/N  (thermodynamic limit)

the intensive counterpart of LoschmidtAmplitude. Non-analytic cusps in λ(t) are dynamical quantum phase transitions (Heyl, Polkovnikov & Kehrein, [21]; review: Heyl, [22]).

LuttingerParameter() <: AbstractQuantity

Luttinger liquid parameter K. Meaningful for critical 1D models with U(1) symmetry (e.g. XXZ in the critical regime |Δ| < 1).

LuttingerVelocity = Velocity{:luttinger}

Luttinger-liquid (bosonisation) velocity u of the linear-dispersion mode of a 1D critical interacting system (Giamarchi, [23]). Coincides with FermiVelocity for free fermions; for an interacting system it carries the Luttinger renormalisation, so the two are distinct kinds rather than two names for one number.

MagneticField <: AbstractField

The magnetic field h. Conjugate (via M = −∂F/∂h) to the magnetization — see conjugate_field.

MagneticFluxDensity() <: AbstractQuantity

The magnetic flux density B — sets the cyclotron frequency ω_c = eB/m and, in 2D, the Landau-level filling ν = n h / (e B).

Magnetization{A}() <: AbstractMagnetization
Magnetization(a::Symbol)

Uniform magnetization component ⟨M_A⟩ per site — a rank-1 tensor in SpinAxis space, A ∈ {:x, :y, :z, …}. Magnetization(:z) replaces the old MagnetizationZ.

MarkovEntropy() <: AbstractEntanglementMeasure

The conditional mutual information I(A:C|B) = S(AB) + S(BC) − S(ABC) − S(B) — the deviation of ρ_ABC from a quantum Markov chain A–B–C (zero iff Markov). Non-negative by strong subadditivity (StrongSubadditivity); its vanishing is the structure theorem of Hayden, Jozsa, Petz & Winter, [24].

MassGap() <: AbstractGap

The spectral (mass) gap Δ = E₁ − E₀ between the ground state and the first excitation. Sets the correlation length ξ = v/Δ in a gapped phase, and vanishes as Δ ∼ ξ^{−z} (dynamical exponent z) on approach to a quantum critical point.

MaxwellRelation(potential, lhs, rhs, coeff)

The Maxwell relation DERIVED from a potential: ∂cₓ/∂y = coeff · ∂c_y/∂x, where lhs = (cₓ, y) names the derivative ∂cₓ/∂y, rhs = (c_y, x) names ∂c_y/∂x, and coeff = sₓ·s_y ∈ {+1,−1}. Its residual (zero ⇔ satisfied) is ∂cₓ/∂y − coeff·∂c_y/∂x. Built by maxwell_relation.

MeasurementEntropy() <: AbstractEntanglementMeasure

The post-measurement (dephasing) entropy S(Δρ), where a projective measurement in a basis {|i⟩} maps ρ → Δρ = Σ_i ⟨i|ρ|i⟩ |i⟩⟨i|. Never below the pre-measurement S(ρ) (measurement does not decrease entropy), and the increase is exactly the relative entropy to the dephased state, S(Δρ) − S(ρ) = S(ρ‖Δρ) (Ohya & Petz; Vedral, [25]).

MerminGHZBound() <: AbstractQuantity

The largest Mermin three-party operator value |⟨M₃⟩| a theory admits: 2 under local realism, 4 in quantum mechanics, saturated by the GHZ state (Mermin, [26]). A bounding value, regime-selected the same way as CHSHBound.

Bounds MerminInequality.

MicroCanonical(E; ΔE=0)

Microcanonical ensemble: equal weight on states in the energy window |Eᵢ − E| ≤ ΔE/2 (ΔE = 0 ⇒ exactly-degenerate shell).

Mobility() <: AbstractQuantity

The carrier mobility μ = v_drift / E — the drift response to a field; μ = e τ / m in the Drude picture, and μ = e D / k_B T by the Einstein relation.

Momentum <: AbstractCoordinate

The momentum / wavevector q at which a quantity is evaluated.

MomentumSpace <: AbstractRepresentation

Momentum / reciprocal-space representation (wavevector q) — conjugate to RealSpace.

MutualInformation() <: AbstractEntanglementMeasure

The quantum mutual information I(A:B) = S(A) + S(B) − S(AB) — the total (classical + quantum) correlation between A and B; non-negative by subadditivity (Subadditivity).

NMRRelaxationExponent() <: AbstractQuantity

The low-temperature scaling exponent θ_NMR of 1/T₁ ∝ T^{θ_NMR}, fixed by the operator scaling dimension via θ_NMR = 2Δ_op − 1.

NMRSpinRelaxationRate() <: AbstractQuantity

The NMR spin–lattice relaxation rate 1/T₁ — set by the low-frequency limit of the dissipative dynamical susceptibility (Moriya), 1/T₁ ∝ T · lim_{ω→0} Σ_q |A_hf(q)|² χ''(q, ω)/ω.

OBC(N::Int)
OBC(; N::Int = 0)

Open boundary condition. N is the chain length. N = 0 is a legacy sentinel meaning "size unspecified — caller passes it via kwargs"; fetch methods that accept OBC(0) must look up kwargs[:N].

OptimalCloningFidelity() <: AbstractQuantity

The optimal universal 1 → 2 qubit cloning fidelity F = 5/6 (Bužek & Hillery, [27]) — the no-cloning theorem made quantitative. A bounding value, and an UPPER one.

Bounds CloningFidelityBound.

OrbitalIndex <: AbstractIndex

An orbital / band / sublattice index — the matrix index of single- particle propagators (G_ab, Σ_ab, A_ab). Its range is set by the model, so the interface names the space without enumerating it.

OrderSupport(order) <: Support

The support of a quantity that is a one-parameter FAMILY — the Rényi entropy S_α, the Tsallis entropy S_q — where the order is what distinguishes one member from another.

It exists because a VariableKey is (type, support) and the type alone cannot tell two orders apart. Carrying the order in a plain field does NOT help: _as_key builds the key from typeof(v), and typeof erases a non-parametric struct's field, so before this existed

bag(RenyiEntropy(2) => 0.5, RenyiEntropy(3) => 0.7)

silently kept only 0.7 — same key, second write wins, no error. MEASURED.

This is the order twin of RegionSupport: the support slot already existed for exactly this purpose, "same quantity, different instance", so a one-parameter family belongs in it rather than in a new type parameter per order.

PBC(N::Int)
PBC(; N::Int = 0)

Periodic boundary condition. See OBC for the N = 0 sentinel.

PageEntropy() <: AbstractEntanglementMeasure

Average subsystem entropy of a Haar-random pure state on H_A ⊗ H_B: with m = dim H_A ≤ n = dim H_B,

⟨S_A⟩ = Σ_{k=n+1}^{mn} 1/k − (m−1)/(2n),

which is log m − 1/2 at m = n (Page, [28]). The reference value for "as entangled as a random state", hence the yardstick used in thermalisation and Page-curve arguments.

ParticleNumber() <: AbstractQuantity

The particle number N = −(∂Ω/∂μ)_{T,V} — conjugate to the chemical potential (ChemicalPotential).

ParticleStatistics

Abstract tag for exchange statistics: Fermionic or Bosonic. Used to dispatch statistics-dependent relations (occupation functions; Wick contractions — the current wick_contraction determinant is the fermionic case, the bosonic permanent is tracked as a follow-up).

PartitionFunction() <: AbstractThermalPotential

The partition function Z(β) = Σ exp(-βE) itself (finite systems).

Generic home for a tag that previously lived inside a model file: any statistical-mechanics model with a finite configuration space can register it.

PeltierCoefficient{I}() <: AbstractQuantity
PeltierCoefficient(μ, ν)                      # each a Symbol

The Peltier coefficient tensor Π_μν — the heat current carried per unit electric current, j^Q_μ = Π_μν j_ν. Rank-2 in SpatialDirection space; the Kelvin (second Thomson) relation ties it to the Thermopower, Π = T S.

Polarization() <: AbstractQuantity

The bulk polarization density (or order parameter) per site. In an ordered phase it is the spontaneous polarization; where the order is staggered it is the spontaneous staggered polarization, which is why the sign convention belongs to the model rather than to the name.

PotentialEnergy() <: AbstractThermalPotential

The potential-energy expectation ⟨V⟩ — the V of the virial theorem 2⟨T⟩ = n⟨V⟩.

PotentialTerm(variable, conjugate, sign)

One term of a thermodynamic potential's differential: dΦ ⊃ sign · conjugate · d(variable). The state variable conjugate is conjugate to the natural variable, carried with its sign (+1/−1).

Pressure() <: AbstractQuantity

The pressure p = −(∂F/∂V)_T — conjugate to the Volume.

Purity() <: AbstractQuantity

The purity Tr(ρ_A²) ∈ (0, 1] of a (reduced) density matrix — 1 for a pure state, 1/d for the maximally mixed one. Fixes the Rényi-2 entropy via S_2 = −ln Tr ρ_A².

QuantityEdge

A TypedEdge of the quantity-relationship graph (an alias for TypedEdge{Type}, nodes are quantity families). Its kind is one of

• :derivative — to is the potential/quantity from is a field-derivative of (the response genealogy, derivative_edge); detail names the field ("∂/∂MagneticField", …).
• :spectral — from is obtained from to by the dynamical-graph operation in detail (spectral_origin's via: dyson, neg_im_over_pi, …).
• :fourier — from and to are Fourier conjugates (fourier_conjugate_quantity); detail == "fourier".
• :law — from and to are co-constrained by a universal relation (they appear together in some quantities(rel)); detail names the relation ("SusceptibilityFDT", …).

QuantumSpeedLimit() <: AbstractQuantity

The minimum time in which a state can evolve to an orthogonal one — the tighter of the Margolus–Levitin π/(2⟨E − E₀⟩) ([29]) and Mandelstam–Tamm π/(2ΔE) forms. A bounding value, and a LOWER one: it bounds the orthogonalization time from below.

Bounds OrthogonalizationTimeBound. The two closed forms themselves are MargolusLevitinBound and MandelstamTammBound, which state the bound directly from the energy data rather than from a fetched value.

RealSpace <: AbstractRepresentation

Real-space representation (position r / site index) — conjugate to MomentumSpace under the spatial Fourier transform.

Region(sites...)
Region(::AbstractSet)

A subsystem: a set of lattice sites, dimension-agnostic — a site is any hashable label (Int in 1D, NTuple{D,Int} in ND, a named block, …). Supports ∪, ∩, ⊆, disjoint, isempty, length. The support a VonNeumannEntropy is evaluated on; build a region-entropy bag key with entanglement_entropy.

A, B = Region(1, 2), Region(3, 4)
disjoint(A, B)          # true
A ∪ B                   # Region(1, 2, 3, 4)
Region(1) ⊆ A           # true

RegionReportRow

One row of a region_report: the relation (an entropy inequality), the pairwise-disjoint regions it was auto-instantiated on ((A, B) for the bipartite inequalities, (A, B, C) for the triple ones — strong subadditivity and weak monotonicity), the slack (its residual; ≥ 0 ⇔ satisfied), and pass.

RegionSupport(region::Region) <: Support

The Support of a variable evaluated on a Region: VariableKey(VonNeumannEntropy, RegionSupport(A)) keys the entanglement entropy S(A). Value-based ==/hash (the Support contract), so two content-identical regions key the same bag entry.

RegionTEERow

One row of a region_tee_report: the pairwise-disjoint tripartition regions (A, B, C) it was auto-instantiated on, the tripartite information tripartite_information (I₃), and the Kitaev–Preskill topological entanglement entropy topological_entanglement_entropy (γ = −I₃).

RelativeEntropy() <: AbstractEntanglementMeasure

The quantum relative entropy S(ρ‖σ) = Tr ρ(ln ρ − ln σ) — the distinguishability of ρ from σ; non-negative (Klein's inequality) and monotone under CPTP maps (Lindblad, [30]; Vedral, [25]).

RenyiEntropy(α::Real) <: AbstractEntanglementMeasure

The Rényi entanglement entropy S_α = (1−α)⁻¹ ln Tr(ρ_A^α). α = 2 is fixed by the Purity (S_2 = −ln Tr ρ_A²), and α → 1 recovers the VonNeumannEntropy.

The order is carried in the type's field rather than supplied separately at use: two Rényi entropies of different order are different quantities, and a bag keyed by type alone could not hold both. α = 1 is refused rather than silently aliased — S_1 is the limit, i.e. VonNeumannEntropy.

ResidualEntropy() <: AbstractThermalPotential

Zero-temperature configurational entropy density,

s_res = lim_{T → 0⁺} S(T) / N,

the entropy of the (possibly degenerate) ground-state manifold. Non-negative, and nonzero exactly when the ground state carries an extensive degeneracy — the antiferromagnetic Ising model on the triangular lattice (Wannier, [31]) and the hexagonal-lattice family (Houtappel, [32]) are the classic examples, as are the ice-rule models.

Kept separate from ThermalEntropy, which is the finite-β thermodynamic entropy: the T → 0 limit is its own closed form, not a β → ∞ extrapolation of the finite-β one.

Resistivity{I}() <: AbstractQuantity
Resistivity(μ, ν)                             # each a Symbol

The resistivity tensor ρ_μν — the matrix inverse of the Conductivity σ_μν. Rank-2 in SpatialDirection space; in a magnetic field the 2×2 inversion gives ρ_xx = σ_xx/(σ_xx²+σ_xy²), ρ_xy = σ_xy/(σ_xx²+σ_xy²) — so a dissipationless Hall state (σ_xx = 0) has ρ_xy = 1/σ_xy, ρ_xx = 0.

ResponseKernel{I}() <: AbstractQuantity
ResponseKernel(α, β₁, …, βₙ)          # each a Symbol

The time-domain nonlinear response kernel — the Volterra kernel χ⁽ⁿ⁾_{α;β₁…βₙ}(t̄₁, …, t̄ₙ) whose Fourier transform is DynamicalSusceptibility. This is the object a real-time method produces directly: the response is ⟨Q_α⟩⁽ⁿ⁾(t) = ∫ dt̄₁⋯dt̄ₙ χ⁽ⁿ⁾(t̄₁,…,t̄ₙ) f_{β₁}(t−t̄₁)⋯f_{βₙ}(t−t̄ₙ), and its microscopic form is the n-fold nested commutator ([16] is the linear n = 1 case; the general n-th order formal theory is Peterson, [17]).

It is not the frequency-domain object with the arguments renamed. The retarded kernel is supported only on the causally ordered region 0 ≤ t̄₁ ≤ ⋯ ≤ t̄ₙ (causally_ordered), so — unlike its transform — it is not permutation symmetric; the symmetrisation that produces χ̄⁽ⁿ⁾ happens on the frequency side. Integrating over the ordered region is what turns the kernel into the nested denominators of χ⁽ⁿ⁾(ω₁,…,ωₙ).

Order-parametric exactly like DynamicalSusceptibility: n time arguments for an n-th order response.

RetardedGreensFunction() <: AbstractPropagator

The retarded single-particle Green's function G^R(q, ω). Its spectral representation A = −Im G^R/π and the Dyson equation G^{-1} = G₀^{-1} − Σ are in relations/spectral.jl.

RetardedSelfEnergy() <: AbstractPropagator

The retarded self-energy Σ^R(q, ω) — the Σ of the retarded Dyson equation, and the retarded member of the Keldysh RAK triple (Σ^R, Σ^A, Σ^K). Its anti-Hermitian part Σ^R − Σ^A is (minus) the level broadening.

ScalingDimension() <: AbstractQuantity

The scaling dimension Δ_op of a local operator at a quantum critical point — the input to dynamical scaling relations such as the NMR exponent θ_NMR = 2Δ_op − 1.

ScalingDimensions(y_t, y_h, d)

The renormalization-group data of a continuous transition: the thermal and magnetic relevant eigenvalues y_t, y_h (the RG-flow exponents of the reduced temperature and the ordering field) and the spatial dimension d. These are the two-and-a-bit numbers the whole equilibrium exponent set is a function of, via the homogeneity of the singular free energy f_s(t,h) = b^{-d} f_s(b^{y_t}t, b^{y_h}h) — see critical_exponents.

Arguments are promoted to a common type; pass Rationals for an exact set (ScalingDimensions(1//1, 15//8, 2) is 2D Ising) or Float64 for a numerical fixed point.

critical_exponents(ScalingDimensions(1//1, 15//8, 2))
# (α = 0//1, β = 1//8, γ = 7//4, δ = 15//1, ν = 1//1, η = 1//4)   ← 2D Ising, exact

ScatteringTime() <: AbstractQuantity

The transport (momentum-relaxation) time τ — the Drude scattering time setting the mobility μ = e τ / m.

ScramblingTime() <: AbstractQuantity

The fast-scrambling time t_* = (β/2π) log N for a thermal system of N degrees of freedom (Sekino & Susskind, [33]) — the conjectured floor on how fast local information can be scrambled into global entanglement, saturated by black holes. A bounding value, and a LOWER one.

Bounds FastScramblingBound.

SelfEnergy() <: AbstractPropagator

The single-particle self-energy Σ(q, ω) — the Dyson correction G^{-1} = G₀^{-1} − Σ between the bare and full propagators.

SpatialDirection <: AbstractIndex

A spatial / Cartesian direction index μ — the index of currents and transport tensors (e.g. the conductivity σ_μν).

SpecificHeat() <: AbstractThermalPotential

Specific heat (per site) at constant volume, c_v(β) = β² (⟨H²⟩ − ⟨H⟩²) / N.

Defining identities: the fluctuation form SpecificHeatFDT c_v = β² Var(E) / N, the entropy form SpecificHeatFromEntropy c_v = T ∂s/∂T, and the difference from the constant-pressure heat capacity HeatCapacityDifference.

SpectralFunction() <: AbstractQuantity

The single-particle spectral function A(q, ω) = −(1/π) Im G^R(q, ω), normalized by ∫ A(q, ω) dω = 1.

SpectralOrigin(from, via)

One edge of the dynamical-quantity graph: the quantity carrying it is obtained from quantity type from by the operation named via — one of :dyson, :neg_im_over_pi, :bz_average, :spacetime_fourier, :low_frequency_limit, :kubo, :spatial_integral_q0.

SpinAxis <: AbstractIndex

A spin / order-parameter component index α ∈ {x, y, z, …} — the index of magnetizations, susceptibilities, spin correlations, structure factors.

SpinCorrelation{A,B}() <: AbstractTwoPointCorrelation
SpinCorrelation(a::Symbol, b::Symbol)

Two-point spin correlation ⟨S^A_i S^B_j⟩ — a rank-2 tensor in SpinAxis space (SpinCorrelation(:z, :z) replaces the old ZZCorrelation). At criticality its decay is governed by the anomalous dimension η — see the correlation_decay correspondence.

SpinGap() <: AbstractGap

Spin gap of an electron or spin system,

Δ_s = E₀(Sᶻ = 1) − E₀(Sᶻ = 0),

the lowest excitation energy at fixed particle number that flips one spin. Zero whenever the spinon branch is gapless — rigorously so for the half-filled 1D Hubbard chain (Lieb & Wu, [10]) — and positive in a spin-gapped phase (Haldane chain, BCS superconductor).

Sector-resolved like ChargeGap. A model can be gapless in the spin sector while gapped in the charge sector, which is why these are two quantities rather than one gap with a sector keyword.

SpinStructureFactor{A,B}() <: AbstractStructureFactor
SpinStructureFactor(a::Symbol, b::Symbol)

The axis-resolved static spin structure factor S^{AB}(q) — the spatial Fourier transform of the SpinCorrelation ⟨S^A_i S^B_j⟩, a rank-2 tensor in SpinAxis space (SpinStructureFactor(:z, :z) = S^{zz}(q)). The component-resolved companion of the axis-agnostic StaticStructureFactor; its q → 0 limit fixes the component susceptibility χ_{AB} = β S^{AB}(q → 0) (classical).

SpinWaveVelocity

Alias of LuttingerVelocity: in a gapless spin chain the bosonisation velocity IS the spin-wave velocity, so this is one quantity under two names and not a second slot.

SpontaneousMagnetization() <: AbstractMagnetization

The spontaneous (symmetry-broken) order-parameter magnitude M(T) in the ordered phase; identically zero above T_c. A scalar — the magnitude, not a spin component — so tensor_rank == 0; its critical exponent is β (see critical_scaling).

Squeezed(r; φ=0.0)

Single-mode squeezed-vacuum state family with squeezing parameter r and squeezing angle φ (φ = 0: x-quadrature squeezed). Not an ensemble but a parameterized pure-state family — included because its moments obey generic closed-form identities (see relations/statistics.jl: squeezed_variances, squeezed_mean_photons).

StaticStructureFactor() <: AbstractStructureFactor

The static (equal-time) structure factor S(q) — the frequency integral of the DynamicalStructureFactor, S(q) = ∫ S(q, ω) dω/(2π) (Van Hove, [34]). Its q → 0 limit fixes the static susceptibility (χ = β S(q→0), classical). Rank-2 in spin space, one frequency integrated out (frequency_arguments == 0).

StringOrderParameter() <: AbstractQuantity

Kennedy-Tasaki non-local (string) order parameter

O_str = lim_{|i-j| -> infty} -<S^z_i exp[i pi sum_{i<k<j} S^z_k] S^z_j>

for S=1 chains. Detects the hidden Z2 x Z2 symmetry breaking that defines the Haldane phase (T. Kennedy and H. Tasaki, Phys. Rev. B 45, 304 (1992)). At the AKLT point the closed-form value is O_str = 4/9 (AKLT 1988), making it the canonical analytic test bed for any implementation that aims to detect topologically non-trivial gapped phases of integer-spin chains.

Support

Where / on what a variable is evaluated. Global — the whole system, no decoration — is the default and the only support the type-keyed prototype uses; region / point / pair supports arrive with the entanglement layer.

Susceptibility{I}() <: AbstractSusceptibility
Susceptibility(α, β₁, …, βₙ)          # each a Symbol

Susceptibility of arbitrary response order — the n-th order term of the order-parameter response to its conjugate field,

χ⁽ⁿ⁾_{α; β₁…βₙ} = ∂ⁿ⟨M_α⟩ / ∂h_{β₁}…∂h_{βₙ},

a rank-(n+1) tensor in SpinAxis space whose index parameter I = (α, β₁, …, βₙ) carries one response direction α and n field directions. The response order is n = length(I) − 1 (response_order):

• Susceptibility(:x, :y) — linear χ_xy = ∂M_x/∂h_y (order 1), the off-diagonal component the fused SusceptibilityXX/ZZ names could not express;
• Susceptibility(:x, :y, :z) — second-order nonlinear χ⁽²⁾_{x;yz} = ∂²M_x/∂h_y∂h_z (order 2);
• Susceptibility(:x, :x, :x, :x) — third-order χ⁽³⁾, and so on.

The genealogy is recursive: χ⁽ⁿ⁾ ⟵ χ⁽ⁿ⁻¹⁾ ⟵ … ⟵ M ⟵ F (derivative_edge), so derivative_order(χ⁽ⁿ⁾, MagneticField) == n + 1. The linear component's defining identity is SusceptibilityFDT χ_AB = β·Cov(M_A, M_B).

Tangle() <: AbstractEntanglementMeasure

The tangle τ = C² — the squared Concurrence; the bipartite entanglement measure obeying the CKW monogamy inequality τ(A:BC) ≥ τ(A:B) + τ(A:C).

Temperature <: AbstractField

The temperature T. Conjugate (via S = −∂F/∂T) to the entropy.

ThermalAverage(quantity, distribution) <: AbstractQuantity

Marker pairing a quantity with the distribution it is averaged in — ⟨Q⟩_D at the type level. Being itself an AbstractQuantity, it composes with the fetch verb, so an atlas can make the ensemble an explicit dispatch axis:

fetch(model, ThermalAverage(Energy(), Canonical(β)), bc)

instead of the implicit "a β kwarg means canonical" convention. The tensor traits (indices, tensor_rank, index_spaces) pass through to the wrapped quantity, so a component average ⟨χ_xy⟩_D keeps its index structure through the marker.

Fields: quantity, distribution (accessed directly).

ThermalConductivity{I}() <: AbstractQuantity
ThermalConductivity(μ, ν)                     # each a Symbol

The (DC) thermal conductivity tensor κ_μν — the heat-current response to a temperature gradient, j^Q_μ = −κ_μν ∂_ν T. Rank-2 in SpatialDirection space; its ratio to the electrical Conductivity is fixed by the Wiedemann–Franz law.

ThermalEntropy() <: AbstractThermalPotential

Thermal entropy per site, s = β(ε − f).

ThermalExpansionCoefficient() <: AbstractQuantity

The (isobaric, volumetric) thermal-expansion coefficient α = (1/V)(∂V/∂T)_p.

ThermodynamicPotential(name, x::PotentialTerm, y::PotentialTerm)

A thermodynamic potential Φ of the two natural variables x.variable, y.variable, with differential dΦ = x.sign·x.conjugate·d(x.variable) + y.sign·y.conjugate·d(y.variable). The four standard potentials are thermodynamic_potentials; the Maxwell relation falls out via maxwell_relation.

Thermopower{I}() <: AbstractQuantity
Thermopower(μ, ν)                             # each a Symbol

The thermopower (Seebeck coefficient) tensor S_μν — the electric field generated per unit temperature gradient at zero current, E_μ = S_μν ∂_ν T. Rank-2 in SpatialDirection space; fixed by the Mott formula and linked to the PeltierCoefficient by the Kelvin relation.

ThreeTangle() <: AbstractEntanglementMeasure

The residual three-tangle τ₃ = τ(A:BC) − τ(A:B) − τ(A:C) (Coffman, Kundu & Wootters, [35]) — the genuinely tripartite entanglement left over after the monogamy budget; τ₃ = 1 for GHZ, 0 for W.

TimeDomain <: AbstractRepresentation

Time-domain representation (t) — conjugate to FrequencyDomain under the temporal Fourier transform.

TopologicalEntanglementEntropy() <: AbstractEntanglementMeasure

The topological entanglement entropy γ = ln D (D the total quantum dimension) — the universal constant subleading term of the area law S(∂) = α|∂| − γ, extracted from a tripartition by the Kitaev–Preskill combination (Kitaev & Preskill, [36]; Levin & Wen 2006); nonzero signals topological order.

TopologicalInvariant() <: AbstractQuantity

The model's topological invariant (winding number, Chern number, ℤ₂ index, Pfaffian sign, … — the concrete meaning is declared by the implementing model). Generic computations of standard invariants on Bloch maps live in this package's relations layer (winding_number, chern_number).

TripartiteInformation() <: AbstractEntanglementMeasure

The tripartite information I₃(A:B:C) = I(A:B) + I(A:C) − I(A:BC) — can be negative (a diagnostic of scrambling / multipartite correlation).

TsallisEntropy(q::Real) <: AbstractEntanglementMeasure

The Tsallis entropy S_q = (1 − Tr ρ_A^q)/(q − 1) (Tsallis, [37]) — the other one-parameter deformation of the VonNeumannEntropy (q → 1 limit), non-additive across independent subsystems.

The order lives in the type's field, and keys through OrderSupport, for the same reason RenyiEntropy does: two Tsallis entropies of different order are different quantities, and a bag keyed by type alone would hold only the last one written. q = 1 is refused rather than silently aliased — it is the von Neumann limit.

TypedEdge{N}(kind, from, to, detail, directed=true)

One typed edge of a KnowledgeGraph: a kind-labeled connection from node from to node to (both of type N), a human-readable detail, and whether it is directed (traversed from → to only) or symmetric (both ways).

TypedStep(relation, output::VariableKey, inputs::Vector{VariableKey})

One directed edge of the TYPE-keyed derivation graph: relation computes the identity variable output (a VariableKey) from its other identity slots inputs (plus its supplied slots, provided as extras), via the type-keyed solve.

Universality{C}

Parametric dispatch tag for universality classes. C is a Symbol identifying the class (:Ising, :XY, :Heisenberg, :Potts3, :Potts4, :Percolation, :KPZ, etc.).

Use with CriticalExponents (equilibrium) or GrowthExponents (KPZ-type) and a d keyword to select the spatial dimension:

fetch(Universality(:Ising), CriticalExponents(); d=2)   # exact Rational
fetch(Universality(:Ising), CriticalExponents(); d=3)   # numerical + _err

UniversalityClass() <: AbstractQuantity

The universality class a model's transition belongs to (returned as a Universality tag by implementing atlases).

VariableKey(type::Type, support::Support = Global())

The identity of a relation variable: the quantity / field / coordinate / exponent type together with its support. This — never a formula-letter Symbol — is what the type-keyed bag, relation_report, and the derivation graph match on, so distinct types (and, later, distinct supports of one type) can never collide.

VectorPotential(components::Real...)
VectorPotential(a::Real)                # one dimension

The optical vector potential A, with its dimension in the type.

N IS THE DIMENSION OF THE SPACE DISPLACEMENTS LIVE IN — the ambient space the sites are embedded in — because peierls_phase contracts A with r_i - r_j. It is not a property of the site SET, and in particular it is not a Hausdorff dimension: a Sierpiński gasket drawn in the plane has sites whose set is log3/log2-dimensional and displacements that are ordinary 2-vectors, so its A is VectorPotential{2}.

For a cut-and-project quasicrystal it is the PARALLEL dimension (D_par in QuasiCrystal.jl's cut_and_project_dimensions), not the hyperspace D_hyper: a Fibonacci chain has D_par = 1, D_hyper = 2, and its optical A is VectorPotential{1} because the hops it multiplies are displacements in the physical line. A drive along the PERPENDICULAR directions is a phason, not a vector potential, and does not belong in this type — conflating the two is the mistake N exists to make impossible to write.

A bare number could say none of this.

VectorPotentialField <: AbstractField

The optical vector potential A. Conjugate (via j = −∂H/∂A) to the ElectricCurrent — the velocity-gauge analogue of M = −∂F/∂h, with the Hamiltonian in place of the free energy because A couples to the hopping rather than to a thermodynamic variable.

A VECTOR field: unlike the scalar tags above it carries a direction, and its values are VectorPotentials whose dimension is the number of SpatialDirection slots the model ranges over. See structure/velocity_gauge.jl for the phase it enters through and the length unit that phase depends on.

Velocity{K}() <: AbstractVelocity
Velocity()                # K = :characteristic — the unspecified one
Velocity(:fermi)          # [`FermiVelocity`](@ref)
Velocity(:luttinger)      # [`LuttingerVelocity`](@ref) / [`SpinWaveVelocity`](@ref)
Velocity(:sound)

A characteristic propagation velocity — the v of the correlation length ξ = v/Δ (CorrelationLengthGap) and of the CFT finite-size forms (FiniteSizeGap, CasimirCentralCharge).

The type parameter K makes which velocity a dispatch axis, exactly as G does for Energy's granularity. It is not decoration: a slot typed on the bare Velocity is a parametric family, so a bag holding Velocity(:fermi) matches it by auto-discovery. Before K existed the specific velocities were separate structs, typeof made them different bag keys from Velocity, and a relation typed on Velocity could not see them — the three relations above were unreachable for every atlas hub that knows its Fermi or Luttinger velocity rather than an anonymous "velocity".

LiebRobinsonVelocity is deliberately NOT a Velocity{K}: it bounds information propagation rather than naming the mode that propagates, and it is only equal to a characteristic velocity when the bound happens to be saturated. Keeping it outside the family keeps it out of ξ = v/Δ.

Volume() <: AbstractQuantity

The volume V — conjugate to the Pressure.

VonNeumannEntropy() <: AbstractEntanglementMeasure

The von Neumann entanglement entropy S = −Tr(ρ_A ln ρ_A) of a subsystem — the n → 1 limit of the RenyiEntropy. In a gapped phase it obeys an area law (Eisert, Cramer & Plenio, [38]); at a 1D critical point it grows logarithmically with the subsystem size, S = (c/3) ln ℓ (Calabrese & Cardy, J. Stat. Mech. (2004) P06002).

WaveMixing(plus, minus)

A general wave-mixing process: M = length(plus) drive frequencies, where drive k enters the response plus[k] times as +ω_k and minus[k] times as −ω_k. The total response order is sum(plus) + sum(minus) and the emitted frequency is Σ (plus[k] − minus[k]) ω_k.

Every named process below is a constructor for one of these, so the layer covers arbitrary order and arbitrary numbers of colours without new machinery:

Processes that are a special evaluation point rather than a distinct multiplicity pattern do not need their own name: the Pockels effect is SumFrequencyGeneration() at ω₂ = 0, and electric-field-induced second-harmonic generation is FourWaveMixing()-shaped with one drive held at zero frequency.

A drive that never enters is rejected — it would make the arity of process_frequencies disagree with the process being described.

CrossPhaseModulation()

Cross-phase modulation: χ⁽³⁾(ω₁, −ω₁, ω₂), emitting at ω₂ — a pump at ω₁ modulating a probe at ω₂. The pump enters twice with opposite signs, so it contributes no net frequency; this is the pump–probe shape.

DifferenceFrequencyGeneration()

Difference-frequency generation: χ⁽²⁾(ω₁, −ω₂), emitting at ω₁ − ω₂. OpticalRectification is its ω₂ = ω₁ case.

FourWaveMixing()

Four-wave mixing: χ⁽³⁾(ω₁, ω₁, −ω₂), emitting at 2ω₁ − ω₂ — the third-order two-colour process behind coherent anti-Stokes Raman scattering ([39] for the permutation bookkeeping it obeys).

Optical phase conjugation is not this cut: it needs the fully degenerate case, all four waves at one frequency, which is KerrEffect here. At ω₁ ≠ ω₂ the output at 2ω₁ − ω₂ is in general not even at the probe's own frequency.

HarmonicGeneration(q)

q-th harmonic generation: all q arguments equal, χ⁽q⁾(ω, …, ω), emitting at qω. q = 2 is second-harmonic generation ([40], the first observation of a nonlinear optical process); large q is high-harmonic generation, which needs no separate type.

KerrEffect()

The optical Kerr effect / self-phase modulation: χ⁽³⁾(ω, ω, −ω), emitting back at ω — an intensity-dependent refractive index. Single-colour, third order, degeneracy factor 3.

OpticalRectification()

Optical rectification: χ⁽²⁾(ω, −ω), emitting at zero frequency — a static response induced by an oscillating field ([41]). The photovoltaic / photogalvanic effect is its current-channel counterpart.

The distinction this layer exists for is visible here: the frequency arguments are (ω, −ω) and nonzero, the emitted frequency is 0, and the degeneracy factor is 2. All three are different numbers.

SumFrequencyGeneration()

Sum-frequency generation: χ⁽²⁾(ω₁, ω₂), emitting at ω₁ + ω₂. The generic second-order two-colour cut — HarmonicGeneration(2) is its ω₂ = ω₁ case, and the Pockels effect is its ω₂ = 0 case.

_bc_size(bc::BoundaryCondition, kwargs) -> Int

Return the effective system size for bc. Prefers bc.N when it is positive; otherwise looks up kwargs[:N]; otherwise throws. Legacy fetch methods can use this helper to accept both OBC(N=24) and OBC(); N=24 call forms.

_beta(; β=nothing, T=nothing)

Resolve the β-or-T keyword convention used throughout this package: callers may pass either the inverse temperature β or the temperature T (exactly one). Private helper shared by constructors and relations.

An unbounded stand-in used only to re-check arithmetic; identity where none is needed.

all_relations(; domain=nothing) -> Vector{AbstractRelation}

Every relation declared with @relation in this package, optionally filtered by domain. The registry is what makes the package adoptable in one call: a consumer never hand-lists relations (see relation_report).

also_constrains(rel::AbstractRelation) -> Tuple{Vararg{Type}}

Extra quantity TYPES a relation constrains that do NOT appear as a typed identity slot — a quantity entering only through a SUPPLIED variance or derivative. The Var(M) in the susceptibility FDT constrains Magnetization; the dlnσ/dε in the Mott formula constrains Conductivity. Auto-derivation from variable_types cannot see these, so they are hand-declared and unioned into quantities (which keeps the physics graph complete without a full hand-written link). Defaults to ().

ambiguous_relations(b::Bag; domain=nothing, extras...) -> Vector{AbstractRelation}

Relations this bag could satisfy once you name a member — every slot is fillable, but one is an AnyOf group and the law is about ONE of its members, which the engine cannot choose:

check(rel, b; subject = MassGap)     # the caller says which

Disjoint from applicable_relations by construction, and that is the point: an AnyOf relation is deliberately excluded from auto-discovery, so without this query it would be absent from every report rather than pending in one. A gap you can list is a gap you can close.

applicable_relations(b::Bag; domain=nothing, extras...) -> Vector{AbstractRelation}

The type-keyed analogue of applicable_relations: every registered type-keyed relation whose identity variables' TYPES are all present in b (with Temperature ⇄ InverseTemperature accepted) and whose supplied slots are all in extras. No string matching, hence no cross-quantity collision — domain is only for scoping, never disambiguation.

applicable_relations(data::NamedTuple; domain=nothing) -> Vector{AbstractRelation}

The registered relations whose required variables are all present in data (after β-or-T normalization), optionally filtered by domain. This is how a consumer package discovers what can be checked against its observables — no hand-listing.

Pass domain when mixing families in one data set: variable names are matched literally, and physics overloads symbols across families (the critical exponent β vs the inverse temperature β).

bag(pairs...) -> Bag

Build a type-keyed Bag: bag(SpectralFunction => a, RetardedGreensFunction => g). A Type key (or a quantity/field INSTANCE, e.g. Susceptibility(:z, :z)) becomes VariableKey(Type) (global support); a VariableKey key is used as-is. The bag is matched by TYPE, never by a string — two distinct quantities can never share a key. A nothing value is rejected: a bag holds concrete measured values, and an absent variable must be omitted, not stored as nothing (which would be indistinguishable from absent).

b = bag(KeldyshGreensFunction => gk, GreaterGreensFunction => gg, LesserGreensFunction => gl)
residual(KeldyshComponent(), b)      # G^K − (G^> + G^<)

bound_direction(rel::AbstractRelation) -> Union{Nothing,Symbol}

Which way the bound constrains its subject:

• :upper — declared bounded ≤ bounding (the subject is bounded from above),
• :lower — declared bounded ≥ bounding,
• :slack — declared in the bare slack form, where no direction was stated,
• nothing — not a bound at all (an equality relation).

Declared, so a consumer's own direction field can be checked against the statement instead of maintained beside it.

bounded_slot(rel::AbstractRelation) -> Union{Nothing,Symbol}

The variable a bound constrains — its subject, the quantity being bounded. nothing for an equality, and for a bound whose bounded side is an expression rather than a single declared variable (S_ABC + S_B ≤ S_AB + S_BC bounds no one variable). Filled in by @bound from the left of the declared comparison. See bounding_slot, bound_direction.

bounding_constant(rel::AbstractRelation) -> Union{Nothing,Number}

The literal on the bounding side, for a bound stated against a constant (C ≥ 0 → 0; kFℓ ≥ 1 → 1). nothing when the bounding side is a variable or an expression.

bounding_slot(rel::AbstractRelation) -> Union{Nothing,Symbol}

The variable that DOES the bounding — the right of the declared comparison, when that side is a single declared variable. nothing when the bound is a constant (see bounding_constant) or an expression, and for every equality.

Together with bounded_slot this is what makes "what bounds this?" a machine question: the roles are declared, not inferred from the sign of a slack expression.

bounds_on(q) -> Vector{AbstractInequality}

Every registered bound whose subject is the quantity q — the answer to "what bounds this?". Matches on the identity type of bounded_slot, so a concrete component is found by a bound declared on its family. Accepts a quantity instance or its type.

The complement of relations_constraining, which is role-blind: a bound's bounding quantity (LiebRobinsonVelocity) is constrained by it too, but is not the thing being bounded.

bounds_on(SpecificHeat)   # [SpecificHeatPositivity()]

canonical_component(χ) -> typeof(χ)

The canonical representative of χ's intrinsic-permutation-symmetry class: the same response tensor with its field indices sorted (the response index — the first — is fixed). Two components are forced equal by the symmetry iff they share a canonical_component (permutation_equivalent):

canonical_component(Susceptibility(:x, :z, :y)) === Susceptibility(:x, :y, :z)

card_jsonl([io=stdout], cards) -> nothing

Stream cards (any iterable of Cards) as JSONL — one schema-v2 object per line — for the registry sink / a documenter. NaN/Inf-safe (a non-finite subject/error_bar is null, the card's status already :divergent). Matches the ecosystem *_jsonl idiom (graph_jsonl) so one consumer renders models ⊕ quantities ⊕ derivations ⊕ cards.

causally_ordered(t̄...) -> Bool

Whether the time arguments lie in the support of a retarded response kernel: 0 ≤ t̄₁ ≤ t̄₂ ≤ ⋯ ≤ t̄ₙ, with t̄ᵢ = t − tᵢ the delay from each field application to the measurement.

The kernel ResponseKernel vanishes outside this region — the fields must act before the measurement and, in the ordered form, in sequence. Two consequences a consumer should not have to rediscover: the kernel is not permutation symmetric (the ordering breaks it), while its Fourier transform is symmetrised into χ̄⁽ⁿ⁾; and integrating over the ordered region is what produces the nested denominators of the frequency-domain response.

check(rel::AbstractRelation, b::Bag; atol=0, extras...) -> Bool

Type-keyed check: residual(rel, b; extras...) within atol (equalities |·| ≤ atol, inequalities · ≥ −atol).

check(rel::AbstractRelation; atol=0, vars...) -> Bool

abs(residual(rel; vars...)) ≤ atol. With the default atol = 0 this is an exact test — appropriate for Rational inputs; pass an explicit atol for floating-point / error-bar data.

check_all(b::Bag; atol=0, domain=nothing, extras...) -> Bool

true iff every applicable type-keyed relation passes on the bag b — and at least one applies (an empty match is false).

clear_fetch_cache!()

Empty the fetch_cached memoization cache — e.g. after a model's parameters change, invalidating stored values. Returns nothing.

collapse_coordinates(quantity, T, L, Tc; exponents::NamedTuple) -> (x, scale)

The finite-size-scaling data-collapse transform for quantity, with both exponent combinations derived from the correspondence. For an observable obeying O(T, L) = L^{−ρ} f((T − T_c)·L^{1/ν}) (with ρ = −fss_size_exponent), plotting O·scale against x collapses all sizes onto the universal curve f:

• x = (T − Tc)·L^{1/ν},
• scale = L^{−fss_size_exponent} = L^{ρ}.

At T = Tc, x = 0 for every L (the collapse pivot). The residual spread of the collapsed data across sizes is the quantitative universality test — and the exponents used are exactly the atlas's, never hand-typed.

conditional_mutual_information(b::Bag, A::Region, B::Region, C::Region) -> Number

The conditional mutual information I(A:C|B) = S(A∪B) + S(B∪C) − S(A∪B∪C) − S(B), computed from the region entropies in b for pairwise-disjoint A, B, C (the StrongSubadditivity / MarkovEntropyDefinition slack; ≥ 0 by SSA). Errors if the regions are not a tripartition or if any of the four entropies is absent.

conjugate_field(quantity) -> AbstractField
conjugate_field(::Type{<:AbstractQuantity}) -> AbstractField

The field a quantity is thermodynamically conjugate to: the field whose derivative of the free energy is (up to sign) that quantity. The magnetization is conjugate to the MagneticField (M = −∂F/∂h); the entropy to the Temperature. Undefined for quantities that are not first field-derivatives of the free energy.

correlation_decay(::Type{<:AbstractTwoPointCorrelation}) -> Symbol

The anomalous-dimension exponent: at T_c the two-point function decays as G(r) ∼ r^{−(d−2+η)}. Returns the exponent symbol :η (the full decay power needs the spatial dimension d, supplied at use).

critical_exponent(name::Symbol, s::ScalingDimensions) -> Real

A single derived exponent (:α, :β, :γ, :δ, :ν, or :η) of s — a keyed view of critical_exponents.

critical_exponents(s::ScalingDimensions) -> NamedTuple

The full equilibrium exponent set (α, β, γ, δ, ν, η) DERIVED from the RG eigenvalues in s — nothing hand-entered:

• ν = 1/y_t (correlation length, ξ ∼ |t|^{-ν})
• α = 2 − d/y_t (specific heat, C ∼ |t|^{-α})
• β = (d − y_h)/y_t (order parameter, M ∼ |t|^{+β})
• γ = (2y_h − d)/y_t (susceptibility, χ ∼ |t|^{-γ})
• δ = y_h/(d − y_h) (critical isotherm, M ∼ h^{1/δ})
• η = d + 2 − 2y_h (anomalous dimension, G(r) ∼ r^{-(d-2+η)})

With Rational eigenvalues the result is exact, and it satisfies Rushbrooke, Widom, Fisher and Josephson with residual ≡ 0 for any s (exponents_consistent is true by construction).

critical_isotherm(::Type{SpontaneousMagnetization}) -> Symbol

The critical-isotherm exponent: exactly at T_c, the order parameter responds to its conjugate field as M ∼ h^{1/δ}. Returns the exponent symbol :δ. A distinct functional form from the reduced-temperature laws, hence its own accessor.

critical_scaling(quantity) -> Union{CriticalScaling,Nothing}
critical_scaling(::Type{<:AbstractQuantity}) -> Union{CriticalScaling,Nothing}

The reduced-temperature critical correspondence of quantity: which exponent governs its |t|-singularity, and with what sign — or nothing if the quantity has no reduced-temperature critical law (e.g. the partition function, or the field-driven δ / distance-driven η laws handled by critical_isotherm / correlation_decay).

critical_scaling(Susceptibility)          # CriticalScaling(:γ, -1) ⇒ χ ∼ |t|^{-γ}
critical_scaling(SpontaneousMagnetization) # CriticalScaling(:β, +1) ⇒ M ∼ |t|^{+β}

degeneracy_factor(process) -> Int

The number of distinct arrangements of the process's frequency arguments — the multinomial n! / ∏ mᵢ! over the multiplicities.

This is the bookkeeping between the response kernel and what a monochromatic drive produces: the frequency integral defining the order-n response sums over every arrangement of the applied frequencies that meets the emission condition, so a process whose arguments are all distinct collects more terms than a fully degenerate one. Second-harmonic generation has degeneracy 1 while sum-frequency generation has 2, which is why the two carry different prefactors in every textbook table and why the difference is worth stating once rather than per consumer.

degeneracy_factor(HarmonicGeneration(2))       # 1  — (ω, ω)
degeneracy_factor(SumFrequencyGeneration())    # 2  — (ω₁, ω₂)
degeneracy_factor(OpticalRectification())      # 2  — (ω, −ω)
degeneracy_factor(KerrEffect())                # 3  — (ω, ω, −ω)

derivable(bag::Bag; extras...) -> Set{VariableKey}

Type-keyed derivable: the quantity/field TYPES computable from the bag bag (plus extras for supplied slots), through chains of the type-keyed solve. Matched by TYPE, so no formula-symbol collision — a ThermalEntropy in the bag can never pose as a Thermopower.

derivable(; knowns...) -> Set{Symbol}

The set of quantity variables COMPUTABLE from the supplied known values — the honest reachability of the derivation graph. Each element is a variable that can be obtained, directly or through a chain of solves, from the knowns; the knowns themselves are included.

derivable(; Z = 2.0, β = 1.0)          # ⊇ Set([:Z, :β, :f])  — F = −β⁻¹ln Z reachable

Honest, not structural: a symbol appears only if some relation is actually affine-solvable for it along the way (non-affine steps are skipped, exactly as derive would skip them).

derivation_graph() -> KnowledgeGraph{Symbol}

The derivation graph as a KnowledgeGraph instance, for a network VIEW and structural inspection: one DIRECTED edge input →[relation] output per (step, input), the simple-graph projection of the derivation_steps hyperedges.

Edge kind is the relation's name.

derivation_steps() -> Vector{DerivationStep}

Every candidate directed edge of the derivation graph: for each registered relation and each of its variables, the edge that would compute that variable from the others. These are STRUCTURAL candidates — a relation appears as an edge for a variable it is not affine in too; derive is the honest evaluator that discovers, by actually calling solve, which edges fire. Built once and cached.

derivative_edge(quantity) -> Union{DerivativeEdge,Nothing}
derivative_edge(::Type{<:AbstractQuantity}) -> Union{DerivativeEdge,Nothing}

The genealogy edge of quantity: the (parent, field) it is a derivative of, or nothing for a root potential (the free energy) or a quantity outside the thermodynamic-derivative tree.

derivative_edge(Susceptibility(:z, :z))  # DerivativeEdge(Magnetization{:z}, MagneticField)  (χ_zz = ∂M_z/∂h)
derivative_edge(Magnetization(:z))       # DerivativeEdge(FreeEnergy, MagneticField)          (M_z = −∂F/∂h)
derivative_edge(FreeEnergy())            # nothing — the root

derivative_order(quantity, field::AbstractField) -> Int

How many times quantity is differentiated with respect to field on the way up to the root — the order of quantity as a field-derivative of its root potential.

derivative_order(Susceptibility(:z,:z), MagneticField())  # 2  (χ = ∂²F/∂h²)
derivative_order(Magnetization(:z),   MagneticField())  # 1  (M = ∂F/∂h)
derivative_order(SpecificHeat(),     MagneticField())  # 0  (no field derivatives)

derive(target::Symbol; debug=false, knowns...) -> value | DerivationTrace

Lazily derive target from the supplied known values by finding ONE route through the derivation graph and running it. Returns the computed value; with debug=true returns a DerivationTrace instead — the value plus the exact route (which relation produced each intermediate, from which inputs) and whether it was indirect.

derive(:f; Z = 2.0, β = 1.0)                 # -0.6931…   (F = −β⁻¹ ln Z)
derive(:f; Z = 2.0, β = 1.0, debug = true)   # DerivationTrace: 1. FreeEnergyFromZ: {Z, β} → :f

The route is discovered by forward chaining with the REAL solve, so a step whose relation is non-affine in its output is skipped, not faked. Throws if target is not reachable from the knowns.

derive(Q::Type, bag::Bag; extras...) -> value

Type-keyed derive: the value of quantity/field TYPE Q computed from bag (+ extras), or an error if unreachable. Collision-proof — a relation fires only when the ACTUAL quantity types it needs are present:

derive(PeltierCoefficient, bag(Thermopower => s, Temperature => t))     # t·s (Kelvin)
derive(PeltierCoefficient, bag(ThermalEntropy => s, Temperature => t))  # ERROR: unreachable
#   — KelvinRelation needs a Thermopower, not the entropy; the silent
#   entropy-as-Seebeck derivation the symbol-keyed graph allowed is impossible here.

differentiation_chain(quantity) -> Vector{Any}

The genealogy path from quantity up to its root potential, as the list of quantity types [typeof(quantity), parent, …, FreeEnergy]. A root (or non-genealogy) quantity returns the singleton [typeof(quantity)].

differentiation_chain(Susceptibility(:z, :z))
# [Susceptibility{:z,:z}, Magnetization{:z}, FreeEnergy]  — χ ⟵ M ⟵ F

The chain terminates because the genealogy is a finite tree rooted at a thermodynamic potential (the free energy, or the grand potential for the grand-canonical branch); a cycle in the declared edges would loop forever and is guarded against with an explicit depth cap.

dimension(A::VectorPotential) -> Int

How many spatial components A has — the number of SpatialDirection slots, the same count tensor_rank reports.

disjoint(a::Region, b::Region) -> Bool

Whether two regions share no site (a ∩ b == ∅) — the precondition of the bipartite entropy inequalities (subadditivity, Araki–Lieb).

domain(rel::AbstractRelation) -> Symbol

The relation's family tag (:scaling, :thermodynamic, :fundamental, :topology, …) — for filtering in the registry API, and for disambiguating same-named variables across families (the exponent β vs the inverse temperature β).

ehrenfest_order(::AbstractTransition) -> Union{Int,Float64}

The order of the transition in the (generalized) Ehrenfest sense: the index of the lowest free-energy derivative that is discontinuous or singular. 1 for FirstOrder, 2 for ContinuousTransition, Inf for the essential singularity of KosterlitzThouless.

emitted_frequency(process, ω...) -> Number

The frequency at which the induced response appears: the SUM of process_frequencies, because the order-n response at total frequency ω collects the arguments obeying ω₁ + ⋯ + ωₙ = ω.

This is the frequency a measurement indexes by, and it is NOT the driving frequency: optical rectification emits at 0 while being driven at ω, and cross-phase modulation emits at the probe frequency while being driven by a pump as well.

emitted_frequency(HarmonicGeneration(2), 0.5)      # 1.0
emitted_frequency(OpticalRectification(), 0.5)     # 0.0
emitted_frequency(FourWaveMixing(), 1, 3)          # -1    ( = 2·1 − 3 )

ensemble_weight(dist, E; N=0) -> Real

The unnormalized statistical weight the distribution assigns to a state of energy E (and particle number N, grand-canonical only):

• MicroCanonical: indicator of the energy window (0 or 1),
• Canonical: e^{−βE},
• GrandCanonical: e^{−β(E − μN)}.

Normalization is the caller's partition function — summing canonical weights over a spectrum IS Z(β) (cf. FreeEnergyFromZ).

entanglement_entropy(region::Region) -> VariableKey
entanglement_entropy(sites...) -> VariableKey

The bag key for the von Neumann entanglement entropy S(region) — VariableKey(VonNeumannEntropy, RegionSupport(region)). Build a region-entropy bag and auto-discover its inequalities:

b = bag(entanglement_entropy(1) => 0.7, entanglement_entropy(2) => 0.7,
        entanglement_entropy(1, 2) => 1.0)          # S(A), S(B), S(A∪B)
region_report(b)                                    # subadditivity, Araki–Lieb

(Spelled out rather than entropy to avoid the very common StatsBase/Distributions entropy export collision.)

fermionic_entanglement_entropy(region::Region) -> VariableKey
fermionic_entanglement_entropy(sites...) -> VariableKey

The bag key for the FermionicEntanglementEntropy S_f(region). The fermionic twin of entanglement_entropy, and a different key — the two entropies agree only on a single contiguous interval, so a bag may hold both and region_report will discover the inequalities within each family without ever mixing them.

fetch(model, quantity, bc; kwargs...)

Return the stored / computed value of quantity for model under boundary condition bc. The canonical signature takes a concrete model struct + concrete quantity struct + BC.

AbstractQAtlas owns the generic function only; each implementing package registers one method per supported (model, quantity, bc) triple. This top-level fallback throws an informative error for un-implemented triples.

fetch_cached(model, quantity, bc; kwargs...)

Memoizing wrapper over fetch: the first call for a given (model, quantity, bc) (plus kwargs) computes the value via fetch and stores it; later identical calls return the stored value without recomputing.

Safe because a reference value is a pure function of its key (the fetch contract), and the oracle behind it is expensive. The key compares the arguments by value, which is exactly right for the immutable model / quantity / BC structs (a mutable model caches per object identity). A fetch method with side effects must not be cached. Errors are not cached — a failed fetch propagates and leaves the cache untouched. Clear with clear_fetch_cache!.

Thread-safe: the value is computed outside the lock so distinct keys compute concurrently; a race on the same key keeps the first stored value.

field_permutation(χ) -> NTuple{n,Int}

The permutation π of χ's n = response_order(χ) field slots that brings its field indices to canonical_component (sorted) order — Tuple(sortperm(collect(indices(χ)[2:end]))).

Because the intrinsic permutation symmetry pairs each field index with its frequency, π is also the permutation the symmetry applies to the frequency arguments:

χ_{α; β₁…βₙ}(ω₁, …, ωₙ) == canonical_component(χ)(ω_{π₁}, …, ω_{πₙ})

so it is exactly what a consumer needs to check one frequency-resolved component against another (or against the canonical representative). For a static Susceptibility (frequency_arguments == 0) there is nothing to permute and permutation-equivalent components are equal outright; π still reports the field-index sort.

field_permutation(DynamicalSusceptibility(:x, :z, :y))  # (2, 1) — swap the two frequencies
field_permutation(DynamicalSusceptibility(:x, :y, :z))  # (1, 2) — already canonical

fourier_conjugate(rep::AbstractRepresentation) -> AbstractRepresentation

The Fourier-conjugate representation: RealSpace ↔ MomentumSpace, TimeDomain ↔ FrequencyDomain. An involution (fourier_conjugate(fourier_conjugate(r)) == r).

fourier_conjugate_quantity(quantity) -> Type

The quantity obtained by Fourier-transforming quantity in every representation it carries — the real-space/time object of a momentum/frequency one and vice versa:

fourier_conjugate_quantity(StaticStructureFactor)   # SpinCorrelation   (spatial FT)
fourier_conjugate_quantity(DynamicalStructureFactor)# DynamicalCorrelation (space-time FT)

Its representation is the tuple of fourier_conjugates of the original's. Defined for the quantities with an unambiguous conjugate partner; others (representation-agnostic ones) have none.

fourier_pair(a, b) -> Bool

Whether quantities a and b are Fourier conjugates — the same physics in conjugate representations (their representations are elementwise fourier_conjugates, and one is the declared fourier_conjugate_quantity of the other).

fourier_pair(StaticStructureFactor(), SpinCorrelation(:z, :z))       # true (S(q) ↔ ⟨SS⟩(r))
fourier_pair(DynamicalStructureFactor(), DynamicalCorrelation(:x, :x)) # true (space-time FT)

frequency_arguments(quantity) -> Int
frequency_arguments(::Type{<:AbstractQuantity}) -> Int

The number of independent frequency variables a quantity depends on — equivalently, by Fourier transform, the number of independent time variables: its multi-time dimensionality.

0 for a static / instantaneous quantity (a thermodynamic potential, or the static susceptibility χ⁽ⁿ⁾ = ∂ⁿM/∂hⁿ, which is the zero-frequency limit). 1 for a one-frequency dynamical quantity (G(ω), S(q, ω), the linear dynamical susceptibility χ(ω)). For an n-th order nonlinear dynamical response the field is applied at n distinct times, so the response is intrinsically multi-time: frequency_arguments == n, e.g. χ⁽²⁾(ω₁, ω₂) in 2D coherent spectroscopy (Wan & Armitage, [18]).

The static Susceptibility{I} and the dynamical DynamicalSusceptibility{I} of the same order are the zero-frequency limit and the full multi-time object respectively — see the Kubo formula in structure/spectral.jl.

fss_peak(quantity, L; exponents::NamedTuple) -> Real

Finite-size scaling of quantity's critical peak with linear size L, Q(T_c, L) ∝ L^{fss_size_exponent} — the exponent derived from the critical_scaling correspondence, not passed by hand.

fss_peak(Susceptibility(:z, :z), 64; exponents=exps)   # ∝ 64^{γ/ν}

fss_size_exponent(quantity; exponents::NamedTuple) -> Real

The exponent of the linear size L in the finite-size scaling of quantity at criticality: Q(T_c, L) ∼ L^{fss_size_exponent}. Derived from the correspondence — a divergent quantity Q ∼ |t|^{−x} scales as L^{+x/ν}, a vanishing one Q ∼ |t|^{+x} as L^{−x/ν} — so the size exponent is always −(power·e)/ν:

fss_size_exponent(Susceptibility(:z, :z); exponents=exps)          # +γ/ν  (= 7/4)
fss_size_exponent(SpontaneousMagnetization(); exponents=exps)  # −β/ν  (= −1/8)
fss_size_exponent(CorrelationLength(); exponents=exps)         # +1    (ξ ∼ L)

graph_edges(g) -> Vector{TypedEdge}

The edges of g (the backing vector).

graph_jsonl([io=stdout], g; nodelabel=string) -> nothing

Stream g as JSONL for a network/graph view. The first line is a summary {"nodes":N,"edges":M}; each following line is one edge object {"kind":…,"from":…,"to":…,"detail":…,"directed":…}, with node ids rendered by nodelabel (default string; quantity graphs pass nameof). No JSON dependency — matching QAtlas's graph export so one consumer renders models ⊕ quantities ⊕ derivations.

graph_neighbors(g, node) -> Vector{TypedEdge}

Every edge of g incident on node (as from or to) — its neighborhood, direction ignored.

graph_nodes(g) -> Set

Every node that appears as an endpoint of some edge of g.

graph_reachable(g, start) -> Set

The set of nodes reachable from start following edge direction (directed edges from → to, symmetric edges both ways); includes start.

graph_shortest_path(g, a, b) -> Union{Vector{TypedEdge},Nothing}

A shortest path from node a to node b as the sequence of edges connecting them (respecting per-edge direction); nothing if b is unreachable from a, and the empty vector if a === b.

has_critical_exponents(::AbstractTransition) -> Bool

Whether power-law critical exponents in the CriticalExponents sense apply — true only for ContinuousTransition, where the correlation length diverges as a power law.

has_latent_heat(::AbstractTransition) -> Bool

Whether the transition releases a latent heat L = T ΔS — i.e. whether the entropy S = −∂F/∂T is discontinuous. Only FirstOrder.

has_order_parameter(::AbstractTransition) -> Bool

Whether the transition is characterized by a local order parameter that is nonzero on one side. false for KosterlitzThouless (a topological transition with only quasi-long-range order).

index_spaces(quantity) -> Tuple{Vararg{AbstractIndex}}
index_spaces(::Type{<:AbstractQuantity}) -> Tuple

The internal index spaces of a quantity, one AbstractIndex per tensor slot (so length(index_spaces(q)) == tensor_rank(q)). Empty for a scalar; (SpinAxis(), SpinAxis()) for a susceptibility; (OrbitalIndex(), OrbitalIndex()) for a Green's function; etc.

indices(quantity) -> Tuple{Vararg{Symbol}}
indices(::Type{<:AbstractQuantity}) -> Tuple

The selected index values of a (component of a) tensor quantity, one symbol per slot — indices(Susceptibility(:x, :y)) == (:x, :y), indices(Magnetization(:z)) == (:z,), indices(Energy()) == (). This replaces the earlier fused component label (:xx): the honest form is one entry per index, so a quantity's component pairing is by the whole tuple. Length equals tensor_rank for a fully-specified component.

intrinsic_permutation_symmetric(quantity) -> Bool
intrinsic_permutation_symmetric(::Type{<:AbstractQuantity}) -> Bool

Whether the response tensor is invariant under permutation of its field indices (paired with their frequencies) — the intrinsic permutation symmetry of nonlinear response. true for the susceptibilities and the conductivity, false otherwise (the default).

is_response(quantity) -> Bool

Whether quantity is a response function — i.e. a derivative of another quantity in the genealogy (derivative_edge is non-nothing).

keldysh_distribution(stat::ParticleStatistics, ω; β=nothing, T=nothing) -> Real

The equilibrium Keldysh distribution function h(ω) for exchange statistics stat:

• Fermionic(): h(ω) = tanh(βω/2) — bounded in [-1, 1],
• Bosonic(): h(ω) = coth(βω/2) — diverges as ω → 0 (the classical 2T/ω limit).

This is the function multiplying the spectral weight in the fluctuation–dissipation theorem G^K = h(ω)(G^R − G^A) (KeldyshFDT). It equals 1 ∓ 2n(ω) with n the Fermi–Dirac/Bose–Einstein occupation at μ = 0, and it is odd in ω and satisfies h(ω) → sign(ω) (fermions) / h(ω) → coth as T → 0.

keldysh_distribution(Fermionic(), 1.0; β=2.0)   # tanh(1.0) ≈ 0.7616
keldysh_distribution(Bosonic(), 1.0; T=0.5)     # coth(1.0) ≈ 1.3130

maxwell_relation(p::ThermodynamicPotential) -> MaxwellRelation

Derive the Maxwell relation from a potential's differential. Because ∂Φ/∂x = sₓ·cₓ and ∂Φ/∂y = s_y·c_y, the commuting mixed partials ∂²Φ/∂x∂y = ∂²Φ/∂y∂x give sₓ·∂cₓ/∂y = s_y·∂c_y/∂x, i.e. ∂cₓ/∂y = (sₓ·s_y)·∂c_y/∂x — the four Maxwell relations are the four instances of this ONE identity.

maxwell_relation(thermodynamic_potentials()[2])   # F: ∂S/∂V = ∂p/∂T

maxwell_residual(m::MaxwellRelation; derivs) -> Number
maxwell_residual(p::ThermodynamicPotential; derivs) -> Number

The residual of the structure-derived Maxwell relation, ∂cₓ/∂y − coeff·∂c_y/∂x, with the two first-derivative values read from derivs (an AbstractDict keyed by the (conjugate, variable) tuples — the same keys m.lhs / m.rhs carry). Zero ⇔ the mixed partials of Φ commute. Preserves the input number type (Rational in ⇒ Rational out).

m = maxwell_relation(thermodynamic_potentials()[2])              # F: ∂S/∂V = ∂p/∂T
maxwell_residual(m; derivs = Dict((:S, :V) => 2 // 1, (:p, :T) => 2 // 1))   # 0//1

mutual_information(b::Bag, A::Region, B::Region; quantity=VonNeumannEntropy) -> Number

The mutual information I(A:B) = S(A) + S(B) − S(A∪B), computed from the region entropies in the bag b (the Subadditivity slack; ≥ 0). Errors if any of the three entropies is absent.

quantity selects the entropy family — pass FermionicEntanglementEntropy to read the fermionic mutual information out of a bag built with fermionic_entanglement_entropy. The two are different numbers whenever a region is disconnected, and the difference does not cancel here, so the family is named rather than inferred.

mutual_information(bag(entanglement_entropy(1) => 0.7, entanglement_entropy(2) => 0.7,
                       entanglement_entropy(1, 2) => 1.0), Region(1), Region(2))   # 0.4

n_drives(process) -> Int

How many independent drive frequencies the process consumes — the number of arguments process_frequencies and emitted_frequency expect.

native_energy_granularity(model, bc) -> :total | :per_site

Trait declaring which granularity the given model returns natively for Energy at boundary condition bc. Every model that supports Energy must add a method per supported BC. A missing method is caught at the call site as a MethodError, which is intentional: it forces new models to declare the convention rather than silently inheriting an unrelated default.

obeys_entropy_inequalities(::Type) -> Bool

Whether a region-keyed quantity satisfies subadditivity, Araki–Lieb, strong subadditivity and weak monotonicity, and may therefore be swept by region_report.

Opt-in, defaulting to false, because "is an entanglement measure" is not the criterion: RenyiEntropy and TsallisEntropy live on the same regions and are not strongly subadditive away from the von Neumann limit, so a <: AbstractEntanglementMeasure test would auto-discover inequalities they are not required to satisfy and report correct data as broken. Declared true only for VonNeumannEntropy and FermionicEntanglementEntropy, each of which is the von Neumann entropy of an honest reduced state.

operation_scope(via::Symbol) -> Symbol

Which layer owns the dynamical-graph operation via — the scope line of issue #14:

• :definitional — a pointwise identity relating quantity values at a single (q, ω) (or a supplied scalar: an integral, a derivative). It lives HERE, in this stdlib-only definitional package, as an @relation (:dyson, :neg_im_over_pi; and every supplied-integral / supplied-derivative relation such as the sum rules and Kramers–Kronig).
• :functional — a transform / sum / limit that must represent a quantity as a FUNCTION and act on it globally (a BZ average, a space-time Fourier transform, an ω → 0 limit, the Kubo response). Its evaluation belongs to the future ParaLA-based functional sibling; only its structural edge lives here (spectral_origin).

The line is exactly origin_relation's split: an operation is :definitional iff it has a pointwise @relation. Grey zone (issue #14, cf. #6): a sum rule is :definitional — the RELATION checks a supplied number here, while COMPUTING that number from the function is :functional (the sibling's job).

origin_relation(via::Symbol) -> Union{AbstractRelation,Nothing}

The exact single-(q, ω)-point @relation that realizes the operation via, or nothing when the operation is a transform / sum / limit with no pointwise form (its evaluation belongs to the functional sibling, issue #14):

• :dyson → Dyson,
• :neg_im_over_pi → SpectralFromGreens,
• :bz_average, :spacetime_fourier, :low_frequency_limit, :kubo → nothing (transform / sum / limit / commutator-response — no single-point form; evaluation is the functional sibling's job).

The Kubo edge (:kubo) is a transform of a multi-time correlation (Kubo, [16]), so it has no single-(q,ω)- point relation here.

parity_forbidden(order, observable_parity) -> Bool
parity_forbidden(process_or_quantity, observable_parity) -> Bool

Whether a symmetry forces the order-n response to vanish identically.

If the system has a symmetry under which the driving field is odd (f → −f) and the observable transforms with parity s = ±1 (Q → sQ), then χ⁽ⁿ⁾ = s(−1)ⁿ χ⁽ⁿ⁾, so the response vanishes unless s(−1)ⁿ = +1:

• an even observable (s = +1) in such a system has no odd-order response;
• an odd observable (s = −1) has no even-order response.

Inversion in a centrosymmetric crystal is the standard instance: the current is inversion-odd, so χ⁽²⁾ ≡ 0 and second-harmonic generation is forbidden.

This is a selection rule, not a numeric identity, so it is structure and not an AbstractRelation: it tells a consumer when to EXPECT zero, which is what makes a measured zero informative rather than vacuous.

parity_forbidden(2, -1)                          # true  — no χ⁽²⁾ for an odd observable
parity_forbidden(HarmonicGeneration(2), -1)      # true
parity_forbidden(HarmonicGeneration(3), -1)      # false — χ⁽³⁾ survives

peierls_current(H_of_A, A::VectorPotential) -> value

J = -∂H/∂A at A, by automatic differentiation of H_of_A.

The same shape as thermal_derivative and the same sign convention as the rest of the response genealogy (M = -∂F/∂h): a quantity IS a signed derivative of a potential, and the seam differentiates so no consumer hand-codes one. H_of_A takes a VectorPotential and returns the energy.

Currently implemented for VectorPotential{1} only, by forward mode; a higher dimension needs a gradient and is refused rather than silently reduced to one component. The length unit A is measured in stays the model's business — this seam supplies the derivative and the sign, nothing else.

Requires an automatic-differentiation backend; the method is provided by the ForwardDiff package extension. Without it, this throws an informative error.

peierls_phase(A::VectorPotential{N}, displacement::NTuple{N,<:Real}) -> Real

A · d, the phase a hopping picks up across a bond whose endpoints differ by displacement.

The hopping becomes exp(-i·peierls_phase(A, d)) in the forward direction and its conjugate in the reverse. Applying the same sign to both is not a gauge transformation, and shows up as an open chain whose energy moves with A.

displacement is measured in whatever length unit the model uses, and that unit is a choice the model must state: it is invisible to every static check and to the linear and second-order responses, and separates only at third order in the drive. This layer does not name it, because how far a bond spans is a fact about a lattice, not about a definition.

permutation_equivalent(a, b) -> Bool

Whether response tensors a and b are forced equal by intrinsic permutation symmetry — i.e. differ only by a permutation of their field indices. χ⁽²⁾_{x;yz} = χ⁽²⁾_{x;zy}, so they are equivalent; χ_{x;yz} and χ_{y;xz} are not (different response index).

potential_root(quantity) -> Type

The root potential of quantity's genealogy — the last entry of its differentiation_chain. For the canonical response tree this is FreeEnergy (M = −∂F/∂h, S = −∂F/∂T, …); for the grand-canonical branch it is GrandPotential (N = −∂Ω/∂μ). Each root is itself the Legendre-generating potential of its ensemble — F = −β⁻¹ ln Z, Ω = −β⁻¹ ln Ξ.

principal_value_hilbert(response::AbstractResponse, ω) -> Number

The principal-value Hilbert transform P ∫ f(ω′)/(ω′ − ω) dω′ of response at ω — the pv_real / pv_imag a KramersKronigReal / KramersKronigImag check consumes (feed the imaginary part to obtain pv_imag, the real part for pv_real).

AbstractQAtlas owns the generic function only; the numerical transform is the functional sibling's job (#14 / #19), which adds a method for its own AbstractResponse representation. This fallback errors informatively.

process_frequencies(process, ω...) -> NTuple

The frequency arguments (ω₁, …, ωₙ) at which χ⁽ⁿ⁾ is to be evaluated for process, given the n_drives(process) driving frequencies actually applied. The result always has response_order(process) entries.

process_frequencies(HarmonicGeneration(3), 0.5)          # (0.5, 0.5, 0.5)
process_frequencies(OpticalRectification(), 0.5)         # (0.5, -0.5)
process_frequencies(SumFrequencyGeneration(), 0.5, 1.2)  # (0.5, 1.2)
process_frequencies(FourWaveMixing(), 0.5, 1.2)          # (0.5, 0.5, -1.2)

quantities(rel::AbstractRelation) -> Tuple{Vararg{Type}}

The physical-quantity TYPES a relation directly constrains — the machine link from a relation to the vocabulary it speaks about (beyond the bare variable symbols of variables). For a type-keyed relation this is auto-derived: the AbstractQuantity subset of its variable_types (family-erased) unioned with also_constrains — e.g. quantities(SusceptibilityFDT()) == (Susceptibility, Magnetization), the typed χ plus the Var(M) association. Defaults to () for relations that constrain parameters/exponents rather than named quantities (scaling laws, Maxwell relations). The reverse index is relations_constraining.

quantity_graph() -> KnowledgeGraph{Type}

The entire quantity-relationship graph as a KnowledgeGraph — every :derivative, :spectral, :fourier and :law edge among the constructible quantity families, deduplicated. Built once from the type hierarchy and cached; query it with the generic kernel (graph_neighbors, graph_shortest_path, …) or the quantity-specific wrappers below.

quantity_graph_jsonl([io=stdout]) -> nothing

Stream the whole quantity_graph as JSONL for a network/graph view (node ids are the family type names). A thin wrapper over graph_jsonl.

quantity_neighbors(fam) -> Vector{QuantityEdge}

Every edge of quantity_graph incident on quantity family fam (as from OR to) — its neighborhood. Unlike related_quantities this also surfaces edges naming fam as their to endpoint (e.g. the quantities whose derivative is fam). A thin wrapper over graph_neighbors.

quantity_path(a, b) -> Union{Vector{QuantityEdge},Nothing}

A shortest path in the quantity-relationship graph from quantity a to b (instances, families, or types) — the machine answer to "how are a and b related?". nothing if they are in different components, the empty vector if a and b are the same family. A thin wrapper over graph_shortest_path (structural edges are symmetric, so the search is undirected).

quantity_path(SpecificHeat(), Magnetization(:z))
# SpecificHeat — Energy — FreeEnergy — Magnetization   (through the common root)

reachable_quantities(q) -> Vector{Type}

The physical-quantity TYPES structurally reachable from q through the type-keyed derivation graph — the quantity-first navigation over typed_derivation_graph. Accepts a quantity instance or its (concrete) type; the result is family-erased (Susceptibility{I} → Susceptibility), de-duplicated, name-sorted, and includes q's own family (trivially reachable).

reachable_quantities(PartitionFunction())   # ⊇ [FreeEnergy, PartitionFunction] — F = −β⁻¹ ln Z

The dual of relations_constraining (a quantity → the laws it obeys); this is a quantity → the other quantities its laws connect it to.

region_check_all(b::Bag; atol=0) -> Bool

true iff every entropy inequality (bipartite + strong subadditivity) auto-discovered by region_report holds on the bag b — and at least one instance was found (an empty match is false, never a silent green).

region_report(b::Bag; atol=0) -> Vector{RegionReportRow}

Auto-discover the entanglement-entropy inequalities over the REGIONS in a bag of region-keyed entropies (bag(entanglement_entropy(A) => s_A, …)), with no A/B/AB hand-labeling — the region twin of relation_report:

• Subadditivity and Araki–Lieb, for every disjoint pair (A, B) whose S(A), S(B), S(A∪B) are all present: I(A:B) = S(A)+S(B)−S(A∪B) ≥ 0 and S(A∪B) ≥ |S(A)−S(B)|.
• Strong subadditivity, for every pairwise-disjoint triple (A, B, C) whose S(B), S(A∪B), S(B∪C), S(A∪B∪C) are present: S(A∪B) + S(B∪C) ≥ S(A∪B∪C) + S(B) (the conditional mutual information I(A:C|B) ≥ 0).
• Weak monotonicity, for every pairwise-disjoint triple (A, B, C) whose S(A), S(C), S(A∪B), S(B∪C) are present — no full-system S(A∪B∪C), so it is found strictly more often than strong subadditivity: S(A∪B) + S(B∪C) ≥ S(A) + S(C).

A negative (conditional) mutual information — a broken MPS/ED entanglement calculation — is caught for whichever regions expose it.

Every entropy family in the bag that declares obeys_entropy_inequalities is swept separately: a bag holding both entanglement_entropy(A) and fermionic_entanglement_entropy(A) on the same regions yields both sets of rows, and no inequality is ever built from one family's S(A) and another's S(A∪B).

b = bag(entanglement_entropy(1) => 0.7, entanglement_entropy(2) => 0.7,
        entanglement_entropy(1, 2) => 1.0)      # S(A), S(B), S(A∪B)
all(row -> row.pass, region_report(b))          # true — S is subadditive here

region_tee_report(b::Bag) -> Vector{RegionTEERow}

Auto-discover the tripartite information I₃ and the Kitaev–Preskill topological entanglement entropy γ = −I₃ over the REGIONS in a bag of region-keyed entropies — the multipartite twin of region_report (which handles the entropy inequalities). One row is emitted per pairwise-disjoint triple {A, B, C} whose seven sub-entropies S(A), S(B), S(C), S(A∪B), S(A∪C), S(B∪C), S(A∪B∪C) are all present; I₃ is symmetric in A, B, C, so each unordered triple gives exactly one row.

γ is the KitaevPreskillTEE constant ln 𝒟 — provided the regions form a KP tripartition (three sectors meeting so the boundary-law terms cancel). The set layer carries no geometry, so this reports the alternating sum for any admissible triple; whether it isolates the topological constant is the caller's (geometry-dependent) responsibility.

γ = log(2)
b = bag(entanglement_entropy(1) => 1.0, entanglement_entropy(2) => 1.0,
        entanglement_entropy(3) => 1.0, entanglement_entropy(1, 2) => 1.5,
        entanglement_entropy(1, 3) => 1.5, entanglement_entropy(2, 3) => 1.5,
        entanglement_entropy(1, 2, 3) => 1.5 - γ)   # area terms cancel, leaving −γ
only(region_tee_report(b)).topological_entanglement_entropy ≈ γ   # ln 2 (toric code)

related_quantities(q) -> Vector{QuantityEdge}

The graph neighborhood of quantity q (a quantity instance or type): every QuantityEdge it participates in across ALL edge kinds — its response-genealogy parent (:derivative), its dynamical origin (:spectral), its Fourier conjugate (:fourier), and every quantity it is co-constrained with by a universal law (:law). Endpoints are quantity families (the index-erased UnionAll).

related_quantities(Susceptibility(:z, :z))
# TypedEdge(:derivative, Susceptibility — Magnetization, "∂/∂MagneticField")
# TypedEdge(:law, Susceptibility — Magnetization, "SusceptibilityFDT")
# …

relation_report(b::Bag; atol=0, domain=nothing, extras...)

Type-keyed relation_report: evaluate every applicable type-keyed relation against the bag b (plus extras for supplied slots) and report per-relation residuals. The collision-proof verify-engine front door.

relation_report(data::NamedTuple; atol=0, domain=nothing)
    -> Vector{@NamedTuple{relation, subject, residual, pass}}

Evaluate every applicable relation against data and report per-relation residuals. Each row also carries subject (nothing here — the type-keyed relation_report(::Bag) fills it with the auto-discovered component of a family-generic relation, §8a). The one-call integration point for downstream packages:

# gate an exponent table (an atlas registry, MC-extracted exponents, …):
relation_report((; α=0//1, β=1//8, γ=7//4, δ=15//1, ν=1//1, η=1//4, d=2))

# cross-check measured thermodynamics against every applicable identity:
relation_report((; C=c, var_E=v, β=β, N=N); atol=tol)

relations_constraining(q) -> Vector{AbstractRelation}

Every registered relation that directly constrains the quantity q (its type appears in the relation's quantities) — the reverse of quantities, so a consumer can ask a quantity "which universal laws must you obey?". Accepts a quantity instance or its type.

relations_constraining(Susceptibility(:z, :z))   # [SusceptibilityFDT(), SusceptibilityResponse()]

report(model, quantity, bc;
       value, route, provenance,
       err=nothing, mechanism="", independent=(), atol=0, refs=()) -> Card

Package a computed value for the (model, quantity, bc) triple into a schema-valid Card — the reporter-facing sibling of fetch (fetch RETRIEVES a value; report PACKAGES one). The card's hub is "TypeName(model)/TypeName(quantity)/TypeName(bc)" (instances or types are both accepted). route must be one of REPORT_ROUTES; provenance names what produced the value (the reporter package + method). A non-finite value yields status = :divergent with subject = nothing, never a raw NaN.

value (and each independent entry) is a scalar Real/Complex; a complex value with a negligible imaginary part is taken as real.

report(TFIM(1.0, 0.5), VonNeumannEntropy(), PBC(64);
       value = 0.87, err = 0.01, route = :monte_carlo,
       provenance = "ClassicalMonteCarlo.jl@metropolis", refs = ["Calabrese2004"])

representation(quantity) -> Tuple{Vararg{AbstractRepresentation}}
representation(::Type{<:AbstractQuantity}) -> Tuple

The spatial and/or temporal representation(s) a quantity is expressed in — e.g. (MomentumSpace(), FrequencyDomain()) for S(q, ω), (RealSpace(),) for a real-space correlation, () for a global thermodynamic quantity with no space/time resolution.

residual(rel::AbstractRelation, b::Bag; extras...) -> Number

Type-keyed residual: read each identity-bearing variable from the bag b by its quantity / field TYPE, each supplied (untyped) slot from extras, and evaluate. Same value and exact-arithmetic contract as the symbol-keyed method — the collision-proof front door.

residual(SpectralFromGreens(), bag(SpectralFunction => A, RetardedGreensFunction => G))

residual(rel::AbstractRelation; vars...) -> Number

Signed violation of the relation at the given variable values; zero if and only if the relation is satisfied. Preserves the input number types (see the exact-arithmetic contract on AbstractRelation).

response_order(quantity) -> Int
response_order(::Type{<:AbstractQuantity}) -> Int

For a response function χ⁽ⁿ⁾ = ∂ⁿ(output)/∂(field)ⁿ, the order n — the number of conjugate-field derivatives. Linear response is 1; the second-order nonlinear response is 2; etc. A response tensor carries one output index and n field indices, so n = tensor_rank − 1 for the response families (Susceptibility, Conductivity). Returns 0 for quantities that are not response functions (the default).

scaling_dimensions(; ν, η, d) -> ScalingDimensions

Invert the exponent map: recover the RG eigenvalues from the two independent exponents that fix them, y_t = 1/ν and y_h = (d + 2 − η)/2, at dimension d. Composing with critical_exponents closes the loop — every other exponent (α, β, γ, δ) is then reconstructed from just (ν, η, d), a direct expression of the two-eigenvalue structure:

s = scaling_dimensions(ν = 1//1, η = 1//4, d = 2)   # 2D Ising eigenvalues
critical_exponents(s).δ                              # 15//1  (δ from ν, η, d alone)

singular_form(quantity, t; exponents::NamedTuple) -> Real

The leading singular form of quantity at reduced temperature t, Q ∼ |t|^{power·e}, with the exponent looked up from the critical_scaling correspondence and its value taken from exponents. The correspondence — not the caller — decides which exponent and which sign:

exps = (α=0//1, β=1//8, γ=7//4, δ=15//1, ν=1//1, η=1//4)
singular_form(SpontaneousMagnetization(), -0.01; exponents=exps)  # |t|^{+1/8}
singular_form(Susceptibility(:z, :z), 0.01; exponents=exps)           # |t|^{-7/4}

Throws for a quantity with no reduced-temperature critical law.

slack(ineq::AbstractInequality; vars...) -> Number

The non-negativity margin of an inequality — its residual: how far from saturation, negative iff the inequality is violated.

solve(rel::AbstractRelation, Q::Type, b::Bag; extras...) -> Number

Type-keyed solve: the value of the variable whose identity type is Q, implied by the relation and the others (read from b / extras). Translates Q to its private slot and defers to the affine symbol-keyed solver, so exact arithmetic is preserved.

solve(KeldyshComponent(), KeldyshGreensFunction,
      bag(GreaterGreensFunction => 2, LesserGreensFunction => 3))    # 5

solve(rel::AbstractRelation, ::Val{x}; vars...) -> Number

The value of variable x implied by the relation and the remaining variables, e.g. solve(Widom(), Val(:γ); β=1//8, δ=15//1) == 7//4.

No per-variable rearrangements are hand-written: for any variable the relation is affine in (true of almost every identity here), the answer follows exactly from three kernel evaluations — see the generic _solve. A relation that is non-affine in some variable provides a specialized _solve for it (e.g. FreeEnergyFromZ for Z); attempting a generic solve for a non-affine variable throws instead of silently returning a wrong value. Preserves input number types.

spectral_chain(quantity) -> Vector{Any}

The dynamical-graph path from quantity back to its source, as the list of quantity types [typeof(quantity), from, …, source]. A source (or off-graph) quantity returns the singleton [typeof(quantity)].

spectral_chain(DensityOfStates())
# [DensityOfStates, SpectralFunction, RetardedGreensFunction, SelfEnergy]
# i.e. ρ ⟵ A ⟵ G^R ⟵ Σ : the density of states is built from the
# self-energy through Dyson, the spectral representation, and the BZ sum.

spectral_moment(response::AbstractResponse, n::Integer) -> Number

The n-th frequency moment ∫ ωⁿ f(ω) dω of response: n = 0 is the sum-rule / normalization integral a SpectralSumRule / StaticFromDynamicalStructureFactor check consumes (∫A, ∫S), and n = 1 the first moment a FSumRule check consumes (∫ω S).

AbstractQAtlas owns the generic function only; the quadrature is the functional sibling's job (#14 / #19). This fallback errors informatively.

spectral_origin(quantity) -> Union{SpectralOrigin,Nothing}
spectral_origin(::Type{<:AbstractQuantity}) -> Union{SpectralOrigin,Nothing}

The dynamical-graph edge of quantity: the (from, via) it is obtained from, or nothing for a source quantity (SelfEnergy, DynamicalCorrelation) or a quantity outside the graph.

spectral_origin(DensityOfStates())      # SpectralOrigin(SpectralFunction, :bz_average)
spectral_origin(SpectralFunction())     # SpectralOrigin(RetardedGreensFunction, :neg_im_over_pi)
spectral_origin(RetardedGreensFunction()) # SpectralOrigin(SelfEnergy, :dyson)

tensor_rank(quantity) -> Int
tensor_rank(::Type{<:AbstractQuantity}) -> Int

The tensor rank of a quantity: 0 for a scalar (energy, specific heat, partition function, density of states, exponents), 1 for a vector (magnetization M_α), 2 for a rank-2 tensor (susceptibility χ_αβ, conductivity σ_μν, propagators G_ab, structure factors). Default 0; tensorial families override.

thermal_derivative(quantity, potential, x) -> value
thermal_derivative(χ::Susceptibility, F, h⃗::AbstractVector, components) -> value

The value of quantity as the appropriate derivative of the potential function evaluated at the point x, via automatic differentiation — the AD realization of the response genealogy (derivative_edge):

A single-field F(h) fixes only the diagonal susceptibility (every index equal); an off-diagonal component is a mixed partial in distinct field directions and errors (rather than silently returning the diagonal). For the full tensor component pass a multi-field potential F(h⃗) and the field-direction ordering components:

χ⁽ⁿ⁾_{α;β₁…βₙ} = −∂ⁿ⁺¹F / ∂h_α ∂h_{β₁} … ∂h_{βₙ}

(the response index α is included; the diagonal reproduces the single-field result).

Requires an automatic-differentiation backend to be loaded; the methods are provided by the ForwardDiff package extension. Without it, this throws an informative error.

using ForwardDiff
F(h) = -log(2cosh(h)) / β                       # single-spin free energy
thermal_derivative(Magnetization(:z), F, 0.3)   # M = tanh(0.3·β)·…  (= −F'(0.3))

G(h⃗) = h⃗[1] * h⃗[2] * h⃗[3]                       # a cross-field free energy
thermal_derivative(Susceptibility(:x, :y, :z), G, [0.0, 0.0, 0.0], (:x, :y, :z))  # −1

thermal_gradient(F, x) -> −∇F(x)

The full first-order response conjugate to a field VECTOR x, in a single REVERSE-mode pass: M_α = −∂F/∂h_α for every direction at once from a free energy F(h⃗) (magnetization for a magnetic-field vector, particle numbers for a chemical-potential vector, …). The reverse-mode companion of thermal_derivative, which takes one component at a time by forward mode — for a high-dimensional field vector, reverse mode gets every component in one pass instead of one pass per component.

Returns −∇F (the − is the extensive-response convention M = −∂F/∂h); a scalar x gives the scalar −F'(x), agreeing with the order-1 thermal_derivative.

Requires a reverse-mode AD backend; the method is provided by the Zygote package extension. Without it, this throws an informative error.

using Zygote
F(h⃗) = -sum(log(2cosh(β*hᵢ)) for hᵢ in h⃗) / β   # independent spins
thermal_gradient(F, [0.1, 0.4, -0.2])            # [tanh(β·0.1), tanh(β·0.4), tanh(-β·0.2)]

thermodynamic_potentials() -> NTuple{4,ThermodynamicPotential}

The four standard thermodynamic potentials with their differentials — the single structural source the Maxwell relations are derived from:

topological_entanglement_entropy(b::Bag, A::Region, B::Region, C::Region) -> Number

The Kitaev–Preskill topological entanglement entropy γ = ln 𝒟 from a tripartition (Kitaev & Preskill, [36]), γ = −[S(A)+S(B)+S(C) − S(A∪B)−S(B∪C)−S(C∪A) + S(A∪B∪C)] — the area-law-independent constant isolated by the alternating tripartite sum (KitaevPreskillTEE; γ > 0 ⇒ topological order). Equals −tripartite_information.

tripartite_information(b::Bag, A::Region, B::Region, C::Region) -> Number

The tripartite (interaction) information I₃ = S(A)+S(B)+S(C) − S(A∪B)−S(A∪C)−S(B∪C) + S(A∪B∪C) = I(A:B) + I(A:C) − I(A:B∪C), from the region entropies in b for pairwise-disjoint A, B, C — equal to −topological_entanglement_entropy (the Kitaev–Preskill combination). Errors if the regions are not a tripartition or if any of the seven entropies is absent.

typed_derivation_graph() -> KnowledgeGraph{VariableKey}

The type-keyed derivation graph: one directed edge input →[relation] output per (typed step, input), nodes are VariableKeys — the collision-proof counterpart of derivation_graph. Structural (over-approximates, like its symbol sibling; use derive(Q, bag) for honest reachability).

typed_derivation_steps() -> Vector{TypedStep}

Every candidate directed edge of the type-keyed derivation graph: for each type-keyed relation and each of its identity slots, the edge computing that slot's TYPE from the other identity slots. Inequalities and symbol-only relations are skipped (an inequality gives a saturation bound, not a derivation; a symbol-only relation has no typed slots). Built once and cached.

variable_slots(rel::AbstractRelation) -> Tuple{Vararg{Tuple{Symbol,Any}}}

For each required variable, its (private-symbol, key) pair, in declaration order. key is the variable's identity TYPE for an identity-bearing variable (a quantity / field / coordinate / exponent, written name::Type in the @relation) or nothing for a supplied slot (an untyped value — an evaluation coordinate, a supplied integral; design note R3). The private symbol is the formula letter used in the residual body; the key is what the type-keyed front door matches on. Filled in by @relation; ()-ish for legacy symbol-only relations (every slot nothing).

variable_support(v) -> Support

The support a variable INSTANCE keys under. Global() for everything whose type is its whole identity; overridden where an instance carries data that distinguishes it from another instance of the same type.

Add an override here whenever a quantity gains such a field — that is the one place that decides whether two instances share a bag slot, and the failure mode of getting it wrong is silent (see OrderSupport).

variable_types(rel::AbstractRelation) -> Tuple{Vararg{Type}}

The identity TYPES of a relation's identity-bearing variables, in declaration order (the non-nothing keys of variable_slots). Empty for a legacy symbol-only relation. quantities(rel) is the AbstractQuantity subset of this (family-erased), auto-derived and unioned with also_constrains — so a type-keyed relation needs a hand-written link only for a quantity that enters through a supplied variance/derivative slot.

variables(rel::AbstractRelation) -> Tuple{Vararg{Symbol}}

The required variables of the relation (optional variables with defaults, e.g. a site count N = 1, are not listed). Filled in by @relation; used for applicability matching in applicable_relations and by the β-or-T normalizer.

@bound :domain Name(bounded OP bounding)              # comparison form
@bound :domain Name(x, y, z, opt=default) = x OP expr # statement form
@bound :domain Name(x, y, z, opt=default) = slack     # bare-slack form

Declare a BOUND — a relation asserting an inequality rather than an equality. The generated struct subtypes AbstractInequality: residual returns the slack in ≥ 0 form, check tests slack ≥ −atol, and solve returns the saturation value. Everything @relation generates (kernel, variables, variable_slots, domain, auto-quantities, registry insertion, export) is generated here too.

OP is <=/≤ or >=/≥, and the bounded quantity is written first — the statement reads as a sentence about its subject. Strict </> are rejected: the criterion is slack ≥ −atol, so a strict declaration would be checked non-strictly.

The first two forms additionally record the roles — bounded_slot, bounding_slot, bounding_constant, bound_direction — so "what bounds this, and from which side?" is answerable from the declaration instead of being re-derived from the sign of a slack expression, or maintained a second time in a consumer's own direction field.

@bound :thermodynamic SpecificHeatPositivity(C::SpecificHeat >= 0)
@bound :quantum LiebRobinsonBound(v <= v_LR::LiebRobinsonVelocity)
@bound :entanglement Subadditivity(S_A, S_B, S_AB) = S_AB <= S_A + S_B
@bound :entanglement Monogamy(τ_ABC, τ_AB, τ_AC) = τ_ABC - τ_AB - τ_AC

In the comparison form the bounded side may be an untyped slot while the bounding side carries the quantity type (@bound :quantum Tsirelson(S <= S_max::CHSHBound)). That is what lets a bound be stated — and its bounding value fetched — before any quantity type names the bounded observable.

@relation :domain Name(x, y, z, opt=default) = expr

Declare a relation ONCE. Expands to the complete implementation:

• struct Name <: AbstractRelation end (docstring-attachable),
• the residual kernel _residual(::Name; x, y, z, opt=default) = expr (kernels tolerate extra keywords, so a whole data set can be splatted through relation_report),
• variables(::Name) = (:x, :y, :z) — required variables only,
• domain(::Name) = :domain,
• registry insertion and export Name.

residual/check work immediately; solve works for every variable the expression is affine in. Note for downstream packages declaring their own relations: the struct and methods precompile fine, but the registry insertion is a load-time side effect — re-register from your module __init__ if you need registry visibility across sessions.

@relation :scaling Rushbrooke(α, β, γ) = α + 2β + γ - 2

Equilibrium statistical mechanics: occupation statistics → ensembles → thermodynamic potentials → response, FDT & stability.

CanonicalTPQ <: AbstractRelation

The canonical thermal-pure-quantum estimator of the partition function (Sugiura & Shimizu, [42]),

Z(β) = D · ⟨ψ₀| e^{−βĤ} |ψ₀⟩,

where |ψ₀⟩ is a Haar-random normalized state in the D-dimensional Hilbert space and the bar is the random-state average — exact because ⟨ψ₀| Ô |ψ₀⟩ = Tr Ô / D on average, with fluctuations exponentially small in system size. Thermal averages follow the same way, ⟨Â⟩_β = ⟨ψ_β| Â |ψ_β⟩ / ⟨ψ_β|ψ_β⟩ with |ψ_β⟩ = e^{−βĤ/2}|ψ₀⟩.

Supplied-weight convention: tpq_weight = ⟨ψ₀| e^{−βĤ} |ψ₀⟩. Variables: Z, tpq_weight, D.

ClausiusClapeyron <: AbstractRelation

The Clausius–Clapeyron relation for the slope of a first-order phase boundary,

dp/dT = ΔS/ΔV = L/(T ΔV),

with L = T ΔS the LatentHeat and ΔV the volume jump across the transition. Connects to the FirstOrder transition type (the only one with has_latent_heat).

Variables: dp_dT, L, T, ΔV.

CompressibilityPositivity <: AbstractInequality

Mechanical stability: the isothermal compressibility is non-negative,

κ_T ≥ 0

(slack κ_T), the convexity of the free energy in volume.

Variables: κT.

CrooksFluctuationTheorem <: AbstractRelation

The Crooks fluctuation theorem (Crooks, [43]): the forward and time-reversed work distributions of a driven process obey

P_F(W) / P_R(−W) = e^{β (W − ΔF)},

crossing at W = ΔF (ratio = 1) and integrating over W to JarzynskiEquality. Supplied-ratio convention: ratio = P_F(W) / P_R(−W).

Variables: ratio = P_F(W)/P_R(−W), W, ΔF, β (or T).

ElectricCurrentResponse <: AbstractRelation

The electric current as the field-derivative of the Hamiltonian in the velocity gauge,

j = −∂H/∂A.

The edge derivative_edge(ElectricCurrent) names, stated exactly — the same shape as MagnetizationResponse with the Hamiltonian in place of the free energy, because the vector potential couples to the hopping rather than to a thermodynamic variable. Supplied-derivative convention: dH_dA is the caller-computed ∂H/∂A at the working point.

EntropyResponse <: AbstractRelation

Entropy as a free-energy response,

S = −∂F/∂T.

Supplied-derivative convention: the caller provides dF_dT however obtained (closed form, AD, finite difference). Reconciling this derivative route against the algebraic FreeEnergyLegendre route is the classic thermodynamic self-consistency check.

FreeEnergyFromZ <: AbstractRelation

The statistical definition of the Helmholtz free energy,

f = −ln(Z) / (β N),

bridging the microscopic partition function and the macroscopic potential. N = 1 (default) gives the total free energy; N = number of sites gives the per-site density (the QAtlas FreeEnergy tag convention, f = -β⁻¹ log Z / N). Note the log makes this relation inherently floating-point — the exact-arithmetic contract applies only to the arithmetic around it. Non-affine in Z, so Val(:Z) has a specialized solve (the exp inverse); every other variable is generic.

FreeEnergyLegendre <: AbstractRelation

The fundamental (Helmholtz–Legendre) relation among the potentials at fixed temperature,

F = U − T·S ⟺ S = β(U − F),

with all three potentials in the same granularity. Type-keyed on the per-site convention — F (FreeEnergy) and S (ThermalEntropy) are per-site tags, so U is keyed Energy{:per_site} to match (a total-energy value must be per-site-normalized before it goes in the bag). Purely algebraic: exact inputs give exact residuals.

GibbsDuhem <: AbstractRelation

The Gibbs–Duhem constraint among the intensive variations,

S dT − V dp + N dμ = 0,

expressing that the intensive parameters (T, p, μ) are not independent. Supplied-differential convention: dT, dp, dμ are the variations.

Variables: S, dT, V, dp, N, dμ.

GibbsHelmholtz <: AbstractRelation

The Gibbs–Helmholtz equation in the β form,

U = ∂(βF)/∂β.

Supplied-derivative convention: dβF_dβ is the caller-computed value of ∂(βF)/∂β (equivalently −∂ln Z/∂β, since βF = −ln Z) evaluated at the same state point as U.

GrandPotentialLegendre <: AbstractRelation

The grand potential as the Legendre transform of the free energy that trades the particle number for the chemical potential,

Ω = F − μN.

The grand-canonical companion of FreeEnergyLegendre (F = U − TS): it opens the second root of the response genealogy (GrandPotential), from which N = −∂Ω/∂μ follows (ParticleNumberResponse).

Variables: Ω, F, μ, N.

HeatCapacityDifference <: AbstractRelation

The Mayer relation between the constant-pressure and constant-volume heat capacities,

c_p − c_v = T v α² / κ_T,

with α = (1/V)(∂V/∂T)_p the ThermalExpansionCoefficient, κ_T = −(1/V)(∂V/∂p)_T the IsothermalCompressibility, and v the (per-site) volume. Purely thermodynamic — always non-negative since κ_T > 0, so c_p ≥ c_v.

Variables: Cp, Cv, T, v, α, κT.

JarzynskiEquality <: AbstractRelation

Jarzynski's nonequilibrium equality (Jarzynski, [44]): the exponential average of the work W over many realizations of ANY protocol driving the system between two equilibrium states equals the exponentiated equilibrium free-energy difference, however far from equilibrium the driving is,

⟨e^{−βW}⟩ = e^{−β ΔF}, ΔF = F_B − F_A.

Supplied-average convention: exp_work = ⟨e^{−βW}⟩.

Variables: exp_work = ⟨e^{−βW}⟩, ΔF, β (or T).

JarzynskiSecondLaw <: AbstractInequality

The second law as the Jensen-inequality corollary of JarzynskiEquality (⟨e^{−βW}⟩ ≥ e^{−β⟨W⟩} by convexity ⇒ e^{−βΔF} ≥ e^{−β⟨W⟩}): the average work done on the system cannot be less than the free-energy difference,

⟨W⟩ ≥ ΔF

(slack W_avg − ΔF = the dissipated work W_diss ≥ 0). Saturated by a quasistatic (reversible) protocol; a strictly positive slack measures irreversibility.

Variables: ΔF (the bounded one), W_avg = ⟨W⟩.

LinearResponseFDT <: AbstractRelation

The general static linear-response identity for a perturbation H(λ) = H₀ − λ·O with [O, H₀] = 0 (classical statistics or a commuting observable):

∂⟨O⟩/∂λ = β Var(O).

SusceptibilityFDT is this relation with O = M and a 1/N normalization.

MagnetizationResponse <: AbstractRelation

The order parameter as the field-derivative of the free energy,

M = −∂F/∂h.

The first edge of the field-derivative genealogy (derivative_edge(Magnetization{:z})), stated exactly. Supplied-derivative convention: dF_dh is the caller-computed ∂F/∂h at the working point.

MaxwellEnthalpy <: AbstractRelation

The Maxwell relation from the enthalpy H(S, p):

(∂T/∂p)_S = (∂V/∂S)_p.

Variables: dT_dp, dV_dS.

MaxwellGibbs <: AbstractRelation

The Maxwell relation from the Gibbs free energy G(T, p):

(∂S/∂p)_T = −(∂V/∂T)_p.

Variables: dS_dp, dV_dT.

MaxwellHelmholtz <: AbstractRelation