API Primer

BOUND_DIRECTIONS

The controlled vocabulary for the direction of a status=:bound row — which side of the bounded quantity the fetched value constrains:

• :upper — the fetched value is an upper bound; an independent witness stays ≤ it (verified with verify_bound(...; relation=:leq)).
• :lower — the fetched value is a lower bound; a witness stays ≥ it (relation=:geq).

A bound is fully pinned by what it bounds (the registry quantity), which way (direction), and whose bound it is (references, plus a scheme= selector when several bounds share one quantity — e.g. the :classical / :quantum / :no_signalling CHSH bounds). Non-bound rows carry direction === nothing; register! enforces both halves.

COST_VALUES

How a registered route's work scales in the system size — an axis ORTHOGONAL to status. A route can be perfectly :exact and still be unaffordable to ask for, and that is a different fact about it than whether it is approximate.

• :closed_form — no size dependence worth naming (an analytic expression)
• :polynomial — free-fermion / single-particle diagonalisation, quadrature
• :exponential — many-body ED on a d^N Hilbert space
• :unknown — not yet classified

:exponential REQUIRES max_size: a route that cannot say where it stops is not documenting a limit, it is hiding one.

WHAT :exponential MEANS TO A CONSUMER, since status alone will not say it. An :exact row can be perfectly correct and still not be a reference value in the sense the front page advertises: there is no publication for the local magnetisation of the eight-site open Heisenberg chain, and anyone with an ED routine reproduces it in minutes. These rows are a cross-validation INSTRUMENT — the small-N ground truth a closed form is checked against, and the target a new DMRG/MPS implementation validates itself on — not a result the atlas is uniquely able to supply. MEASURED on the loaded registry: 69 of 518 rows, but 22 of S1Heisenberg1D's 24 and the entire OBC surface of Heisenberg1D and XXZ1D (23 of 35 and 23 of 37).

They are not redundant with the closed forms, which is the other easy assumption. MEASURED: every (model, quantity) pair carrying both has the exponential row at a finite OBC chain and the cheap row at Infinite — a different physical question, not a second route to one number — and for 56 (model, quantity) pairs the ED route is the only one that exists. No (model, quantity, bc) triple carries both; test_cost_axis.jl asserts it.

A generated check that spans both kinds is weaker than it looks on the ED side: all the OBC observables of those hubs come from ONE eigen(H), so a cross-quantity identity there tests the post-processing, not the Hamiltonian. See the :local_energy_sum_rule note in identity_registry.jl.

Why this is not inferable from method: it is not. SSH's MassGap@OBC was labelled :dense_ed while diagonalising a 2N x 2N SINGLE-PARTICLE matrix in O(N^3) — a name can be wrong, max_size is a claim the implementation has to honour.

Nor is it inferable from bc. The tempting rule is "Infinite has no system size, so nothing can scale with one, so it is :closed_form". That is false for a large part of this atlas, and applying it would publish "free" on routes that run a solver on every call. Three ways an Infinite row is not a formula, each MEASURED here rather than argued:

• it evaluates an INTEGRAL. TFIM, XXZ1D, XYh1D, Kitaev1D and SSH's Infinite thermodynamics all reach QuadGK; IsingSquare's :onsager free energy and SixVertex's :analytic one do too, and IsingTriangular's Houtappel form is a NESTED quadrature.
• it SOLVES. Hubbard1D/FreeEnergy runs a beta-continuation with a numerical-Jacobian Newton step (bounded, so it does terminate) and does not return inside 600 s.
• it hides a size in a PROXY. TFIM's Infinite SusceptibilityZZ and SpinStructureFactor route to a large-N OBC Pfaffian with a default N_proxy; measured 10.6 s, 16.8 s and 18.1 s per call. Infinite did not remove the system size, it moved it out of the caller's sight.

The discriminator that does hold is behavioural: does the route, when run, reach a quadrature / eigensolve / root-find? That is what these labels record.

REGISTRY :: Vector{Implementation}

Module-level mutable vector populated at include-time by @register calls scattered across src/models/.../<Model>_registry.jl files. Public read API: implementation_status.

STATUS_VALUES

The controlled vocabulary for the status axis of a registered implementation — what kind of mathematical claim the row makes. This is orthogonal to reliability (how confident the implementation is) and to the test-corroboration level tracked by the atlas harness:

• :exact — analytic closed form; verified as an equality against the literature value (the historical default; every legacy row is :exact).
• :bound — a one-sided inequality. Either a saturating universal constant (equality at the optimal state, e.g. a Tsirelson bound) or a variational bound (an independently measured quantity stays ≤/≥ the fetched value, with no saturation guaranteed). The ≤/≥ direction lives on the verification card, not here.
• :approx — a domain-limited approximation (e.g. a high-temperature expansion): correct on a stated region of validity with a known leading error order.
• :universal — universality-class behaviour (CFT scaling, critical exponents, RMT statistics): true for the class, not a finite model's exact value. Reached via the Universality{C} namespace.

The four kinds are also signalled by the namespace of the call: a concrete Model (:exact/:bound/:approx), Universality{C} (:universal), or Bound{D} (:bound, model-independent).

register! rejects any status outside this tuple, so a typo fails at package load time rather than silently mislabelling a claim.

Implementation

A single (model, quantity, bc) row of the QAtlas implementation registry. See @register for how rows are added and implementation_status for how to query them.

_normalise_tested_in(x) -> Union{Vector{String},Nothing}

Accept a single path or a list, and store a list either way.

Normalising at the boundary rather than at every read site is what keeps the lint, about and the graph export from each having to re-handle the two shapes — and it is why passing a String stayed a valid spelling when the field went plural.

canonical_scheme(model, quantity, bc) -> Symbol

The scheme of the canonical definition for the hub — the one a bare fetch(model, quantity, bc) returns. Errors if the hub has no canonical row.

definitions(model, quantity)     -> Vector{NamedTuple}
definitions(model, quantity, bc)

Catalog of registered definitions for a (model, quantity) — every way QAtlas can compute it, one row per scheme. Each row is (bc, scheme, status, direction, valid_domain, error_order, canonical, references) (the bc field is dropped in the 3-argument form). Use it to see which exact / bound / approx definitions exist and where each holds, then select one with fetch(model, quantity, bc; scheme=…). The canonical row is what a bare fetch(model, quantity, bc) returns.

has_native_fetch(impl::Implementation) -> Bool

true iff which(fetch, (impl.model, impl.quantity, impl.bc)) resolves to a method more specific than the catch-all in core/type.jl. Conversion fallbacks (e.g. the generic Energy{:per_site} ↔ Energy{:total} router) count as "native" because they are a real dispatchable implementation — they just live above the model layer.

Used by test/core/test_registry.jl to detect registry rows that silently lost their backing fetch method.

implementation_status() -> Vector{NamedTuple}
implementation_status(model::AbstractQAtlasModel)
implementation_status(::Type{<:AbstractQAtlasModel})
implementation_status(quantity::AbstractQuantity)
implementation_status(::Type{<:AbstractQuantity})
implementation_status(queue::AbstractVector)

Return registry rows as NamedTuples (Tables.jl-compatible without a Tables dependency).

• No-arg: every registered triple.
• model / quantity (instance or type): rows whose corresponding type field matches exactly (no subtype walking — model parameters are part of the identity here).
• queue: a vector of (model, quantity, bc) triples (each component may be either an instance or a type). Returns one row per queue entry that is registered, dropping entries that are not.

Use this to plan downstream work — e.g. before writing tests for a new ThermalMPS workload, query the queue you intend to validate against.

implementation_status_markdown([io::IO=stdout], entries=implementation_status())

Render entries (any iterable of NamedTuple rows from implementation_status) as a GitHub-flavoured Markdown table to io.

references_for(model, quantity, bc) -> Vector{String}
references_for(model, quantity)     -> Vector{String}
references_for(model)               -> Vector{String}

Return the literature references — references.bib bibkeys — that the registered implementation(s) for the given arguments rest on. Use it as a companion to fetch: pass the same model (and optionally quantity and boundary condition bc) you are calling to see which papers that closed-form value derives from and is checked against.

These are exactly the keys rendered on the model's documentation page and in the global Reference List; resolve a key to its full entry there (or in docs/references.bib).

Arguments may be instances or types, mirroring implementation_status. With fewer arguments the references are aggregated over the unspecified axes (all boundary conditions for a (model, quantity) pair; every registered quantity for a bare model). The result is de-duplicated and sorted, and is empty when no matching registry row carries references (including when the triple is not registered at all).

Examples

julia> references_for(TFIM(), Energy{:per_site}(), Infinite())
1-element Vector{String}:
 "Pfeuty1970"

julia> references_for(TFIM())            # every paper TFIM rests on
…

register!(model_T, quantity_T, bc_T;
          scheme=:canonical, method=:unknown, status=:exact,
          direction=nothing, valid_domain=nothing, error_order=nothing,
          canonical=true, reliability=:unknown, tested_in=nothing,
          references=String[], notes="")

Push a new Implementation row into REGISTRY. Usually called via the @register macro. A (model, quantity, bc) hub may hold several rows distinguished by scheme (the definition key); canonical marks the one a bare fetch(model, quantity, bc) returns. Invariants: status=:bound requires a direction; status=:approx requires references + a valid_domain; status=:exact forbids valid_domain/error_order. See STATUS_VALUES, BOUND_DIRECTIONS.

validity(model, quantity; scheme, bc=nothing) -> NamedTuple

Region of validity of a registered definition selected by scheme: (scheme, status, direction, valid_domain, error_order, references). For an :approx this is where (valid_domain) and how well (error_order) it holds; for a :bound, the direction. Pass the scheme from definitions.

@register Model Quantity BC method=… reliability=… tested_in=… references=… notes=…

Thin macro around register!. Lets each model file register its native fetch methods declaratively, e.g.

@register TFIM Energy{:total} OBC method=:bdg reliability=:high \
    tested_in="test/models/quantum/TFIM/test_TFIM_thermal.jl" \
    references=["Pfeuty 1970"]

The three positional arguments are spliced as types; the remaining key=value pairs are forwarded as keyword arguments to register!.

REALIZES :: Vector{Realization}

The model ↔ universality-class correspondence, populated at include-time by realizes! / @realizes. Query with realizations (by model) and realized_by (by class).

Realization

One model realizes class row of the REALIZES correspondence: the concrete model flows to Universality{class} in the stated regime (e.g. a quantum critical point), resting on references.

fetch(u::Universality{C}, ::UniversalityClass, bc) -> u

Identity: a Universality{C} object is its own universality class. This allows fetch(fetch(model, UniversalityClass(), bc), UniversalityClass(), bc) to round-trip cleanly, and lets Universality{C} instances be used directly wherever a model is expected in universality-class queries.

realizations(model) -> Vector{NamedTuple}

The universality classes model realizes: (class, regime, references) rows.

realized_by(class::Symbol) -> Vector{NamedTuple}

The concrete models realizing Universality{class}: (model, regime, references) rows — the membership list behind the by/universality view.

realized_class(model) -> Union{Symbol,Nothing}

The universality class a model instance realizes at its current parameters: the class of the unique @realizes row whose at predicate holds for model, or nothing if the instance sits on no registered critical locus. Errors if more than one row matches (non-exclusive at predicates — a coherence violation; a critical point belongs to exactly one class).

realizes!(model_T, class; regime, at=nothing, example=nothing, references=String[])

Record that model_T realizes Universality{class} in regime. class is a Symbol naming a universality class (:Ising, :XY, :Heisenberg, …).

at is an optional predicate model_instance -> Bool marking the critical locus (a point, line, or surface in parameter space) where the model realizes the class — multiple rows for one model must have mutually-exclusive at predicates (a critical point belongs to exactly one class). example is a representative critical instance on that locus (used to verify mutual exclusion and to probe universal behaviour). Both are needed for the universal-quantity delegation / verification to engage.

@realizes Model :class regime="…" references=[…]

Macro sugar around realizes!: the positional Model is spliced as a type and :class as the class symbol; the remaining key=value pairs are forwarded as keyword arguments.

REDUCES :: Vector{Reduction}

The model ↔ model reduction correspondence, populated at include-time by reduces! / @reduces. Query with reductions (by source) and reduced_from (by target).

Reduction

One source reduces to target row of the REDUCES correspondence: the concrete source model becomes the concrete target model in the stated regime (a limit / special point), resting on references. This is what makes a model→model delegation coherent — see @reduces.

reduced_from(model) -> Vector{NamedTuple}

The concrete models that reduce to model: (source, regime, references) rows — the inverse of reductions.

reduces!(source_T, target_T; regime, references=String[])

Record that source_T reduces to target_T in regime. Both arguments are concrete model types.

reductions(model) -> Vector{NamedTuple}

The models model reduces to: (target, regime, references) rows.

@reduces Source Target regime="…" references=[…]

Macro sugar around reduces!: the positional Source and Target are spliced as model types; the remaining key=value pairs are forwarded as keyword arguments.

@reduces MixedFieldIsing1D TFIM regime="longitudinal field h_z = 0"

ABOUT :: Vector{ModelCard}

Module-level store of model description cards, populated at include-time by about! / @about from src/about_registry.jl. Query with about.

ModelCard

One @about row: the human-facing description of a model — a one-sentence summary, the hamiltonian as a LaTeX string (rendered as display math; may be empty), and optional references (bibkeys). See @about / about.

about!(model_T; summary, hamiltonian="", references=String[])

Record a ModelCard for model_T. summary is a one-sentence description (required, may contain inline $…$ math); hamiltonian is a LaTeX string rendered as display math on the model page (optional). Usually called via the @about macro.

about(model) -> NamedTuple | nothing

The description card for model (instance or type): (summary, hamiltonian, references), or nothing if no @about card was authored.

@about Model summary="…" hamiltonian=raw"…" references=[…]

Macro sugar around about!: the positional Model is spliced as a type; the remaining key=value pairs are forwarded as keyword arguments. Use raw"…" for the hamiltonian so LaTeX backslashes survive.

@about TFIM summary="The 1D transverse-field Ising model, the canonical solvable quantum phase transition." \
    hamiltonian=raw"H = -J\sum_i \sigma^z_i \sigma^z_{i+1} - h\sum_i \sigma^x_i"

CHECK_GENERATORS :: Vector{Pair{Symbol,Function}}

kind => generator registration, one per constraint edge type. Each generator is a zero-argument function returning Vector{GeneratedCheck}, enumerated lazily (at call time, NOT load time) so it sees the fully-populated REGISTRY and edge stores.

EDGE_STORES :: Vector{EdgeStoreSpec}

Self-registration of every declarative store in the knowledge graph — the legacy describe/route stores (REGISTRY, REALIZES, REDUCES, ABOUT) and the constraint stores (SYMMETRY_PROFILES, IDENTITIES, DUALITIES, LIMIT_EDGES). Graph-wide structural passes (reference integrity C1, drift guards) iterate THIS list, so a new edge store is covered the moment it registers itself.

CheckOutcome

The result of running one GeneratedCheck. status is one of:

• :pass — the check ran and the two values agree;
• :fail — the check ran and the values DISAGREE (a genuine numerical contradiction); lhs/rhs/abs_err/rel_err are meaningful;
• :skip — the check is declared inapplicable (an exclusion); numerics are NaN, detail is the reason;
• :error — the runner THREW (a config/dispatch bug, NOT a numerical disagreement); numerics are NaN, detail carries the exception. Kept distinct from :fail so a broken edge is not mis-read as a physics contradiction.

:fail and :error are both test failures, but only :fail means "the physics disagrees".

EdgeStoreSpec(name, store, references_of, location_of)

Registration record for one declarative edge store: store is the module-level const vector, references_of(row) returns the bibkeys a row cites, and location_of(row) renders a human-readable row locator for findings. See register_edge_store!.

GeneratedCheck

One executable cross-check derived from (a constraint edge × the implementations present in REGISTRY). kind names the generating edge type (:identity / :dual / :limit / :symmetry), id is a deterministic identifier (stable across runs — the sharding/reporting key), and run is a zero-argument callable returning a CheckOutcome.

_bc_instance(bc_T::Type{<:BoundaryCondition}; finite_N::Int) -> BoundaryCondition

Materialize a boundary condition from its registry type: Infinite() as-is, OBC/PBC at the declared finite_N (constraint edges carry the size their generated finite-N checks run at).

_both_endpoints_independent(source_T, target_T, quantity_T, bc_T) -> Bool

Both model endpoints have a canonical, independent (non-delegating) registry row for (quantity_T, bc_T) — the precondition shared by the duality (#699) and limit (#701) generators for emitting a genuine two-implementation cross-check.

_canonical_row(model_T, quantity_T, bc_T) -> Union{Implementation,Nothing}

The canonical REGISTRY row of an exact (model, quantity, bc) hub, or nothing — the shared lookup behind the duality/limit coherence checks and generators (one definition instead of four copies of the scan loop).

_check_endpoint_rows!(out, source_T, target_T, quantity_T, bc_T, tag, label)

Shared C12/C13 endpoint-row coherence: append a :gap finding (tagged tag, prefixed label) for each of the two model endpoints whose (quantity, bc) row is missing or delegation-backed — the cross-check the edge promises cannot be generated, or would be circular.

_equivalent_rows(rowq::Type, Q::Type) -> Bool

Extension point of _row_covers: declare that a registered quantity type covers a different requested type because fetch routes between them automatically. New equivalence axes add a method right below this fallback (co-located with the quantity that owns the routing would be cleaner but the kernel is the single import point all generators see), NOT an edit to the hub-enumeration loop.

_implemented_hubs(quantities; require_independent=false) -> Vector{NamedTuple}

The (model, bc) pairs whose canonical registry rows cover ALL of quantities (exact quantity types, modulo the Energy-granularity equivalence of _row_covers) — the hubs a constraint generator can materialize checks on. With require_independent=true, hubs where ANY of the participating rows is delegation-backed are dropped (the #699/#701 circularity rule). Universality / Bound namespaces are excluded: constraint checks compare concrete-model implementations.

Deterministic: sorted by (model name, bc name), one entry per hub.

_outcome(lhs, rhs; rtol, atol, detail="") -> CheckOutcome

Compare two scalars with the harness's pass criterion (abs_err ≤ atol || rel_err ≤ rtol).

_quantity_instance(Q::Type{<:AbstractQuantity}) -> AbstractQuantity

The canonical instance of a quantity type for generated fetches. Works for every field-less leaf (including parametric ones like Energy{:per_site}); quantity types that REQUIRE constructor arguments (RenyiEntropy(α), …) are not instantiable from a bare type and raise an informative error — a constraint edge over such a quantity must carry the instance itself.

_row_covers(rowq::Type, Q::Type) -> Bool

Whether a registry row carrying quantity rowq covers a request for Q: exact match, or any declared _equivalent_rows routing equivalence.

_with_param(model, field::Symbol, val) -> model′

Reconstruct model with the named field replaced by val via the positional constructor (the same mechanism as the identity harness's _perturb_field). Errors if the field is absent — a constraint edge naming a non-existent parameter is a declaration bug, not a skip.

generated_checks(; kinds=nothing) -> Vector{GeneratedCheck}

Every executable cross-check the constraint layer derives from the current registry state — the union over all registered generators, deterministically sorted by id. Pass kinds (e.g. (:identity,)) to select a subset; the per-kind test files in test/generated/ are exactly such selections, so the union of the generated test suite equals this list (the universe.jl philosophy applied to generated tests).

register_check_generator!(kind::Symbol, gen::Function)

Register the test generator of a constraint edge type for generated_checks.

register_edge_store!(name, store; references_of, location_of)

Register a declarative store for generic graph-wide passes. references_of defaults to a references-field reader that yields String[] for a row type without that field (so a future bibkey-less store contributes nothing to C1 instead of throwing inside it); location_of should pin the row precisely enough that a dangling-bibkey finding is actionable.

run_generated_check(c::GeneratedCheck) -> CheckOutcome

Run c, converting a thrown exception into an :error outcome (NOT :fail) whose detail carries the exception — a runner only ever throws on a config/dispatch bug, so it must not be conflated with a numerical :fail. Generated suites report every check rather than aborting at the first throwing hub.

SYMMETRY_PROFILES :: Vector{SymmetryProfile}

The model-symmetry attribute store, populated at include-time by symmetry! / @symmetry (one profile per model family). Query with symmetry_profile / models_with_symmetry.

SymmetryProfile

The declared symmetry attributes of one model family — see @symmetry. internal is the on-site/internal symmetry group tag (:SU2, :U1, :Z2, :Z2xZ2, :none, …); site_spin the on-site spin (1//2, 1, …, or nothing for non-spin models); gapped / gs_degeneracy the declared bulk spectral facts at generic parameters (nothing = parameter-dependent or not declared).

check_lsm_consistency() -> Vector{CoherenceFinding}

C10: Lieb–Schultz–Mattis coherence over the @symmetry store — no test execution, declarations only. For every profile where the LSM theorem applies (internal ⊇ U(1) spin rotation, translation invariance, half-odd- integer site_spin):

• declared gapped=true with gs_degeneracy == 1 is a :error — the declaration contradicts the theorem (registry mistake, or a claim that needs extraordinary evidence);
• declared gapped=true with no gs_degeneracy is a :gap — the profile owes the degeneracy that reconciles it with LSM.

check_symmetry_corroboration() -> Vector{CoherenceFinding}

A profile that declares a gapped fact but has no canonical, independent MassGap row at Infinite generates no symmetry_checks — the spectral claim is a graph fact with nothing to corroborate it. Reported as a :gap, mirroring the C12/C13 pattern (a promised cross-check that cannot be generated is a self-reported hole, not an :error).

models_with_symmetry(internal::Symbol) -> Vector{Type}

The model families whose profile declares the given internal symmetry group — the registry query behind symmetry-gated identity generation.

symmetry!(model_T; internal, translation=false, time_reversal=false,
          site_spin=nothing, gapped=nothing, gs_degeneracy=nothing,
          notes="", references=String[])

Record model_T's symmetry profile. Invariants: one profile per model; gs_degeneracy is only meaningful for a declared gapped=true family and must be ≥ 1.

symmetry_checks() -> Vector{GeneratedCheck}

Cross-store corroboration of the @symmetry spectral declarations: for every profile that declares gapped (true or false) AND whose model has a canonical, independent MassGap row at Infinite, emit a check comparing the declaration against the fetched gap. This closes the two-sources-of-truth seam between the profile store and REGISTRY: a MassGap implementation change that contradicts the declared profile (or a wrong profile) fails loudly instead of drifting silently. Profiles with gapped=nothing (parameter-dependent families) and models without an independent MassGap row emit nothing — the declaration carries no claim to corroborate, or no second implementation exists to corroborate it against.

symmetry_profile(model) -> Union{SymmetryProfile,Nothing}

The declared symmetry profile of model (instance or type), or nothing if the model has no @symmetry declaration yet.

@symmetry Model internal=:SU2 translation=true site_spin=1//2 …

Macro sugar around symmetry!: the positional Model is spliced as a type; the remaining key=value pairs are forwarded as keyword arguments.

@symmetry Heisenberg1D internal=:SU2 translation=true time_reversal=true site_spin=1//2 gapped=false

IDENTITIES :: Vector{AbstractIdentityEdge}

The quantity↔quantity identity store, populated at include-time by identity! / @identity_edge. Query with identities_for / participants; the generated checks are the :identity kind of generated_checks.

AbstractIdentityEdge

A quantity↔quantity identity — one of the two concrete modes below. Splitting the two modes into distinct types (rather than one struct with a mode tag and half its fields left nothing) makes the inactive-half states unrepresentable and lets the queries/generators dispatch instead of branch. Shared fields, present on both: name, sweep (fetch-kwargs grid), finite_N (OBC/PBC hub size), rtol/atol, exclusions (Model/(Model,BC) => reason pairs emitted as visible :skip checks), notes, references.

IsotropyIdentityEdge <: AbstractIdentityEdge

A component-isotropy relation over a quantity family (an abstract taxonomy supertype): the family's components must coincide, optionally gated on a requires_internal symmetry. See @identity_edge.

TupleIdentityEdge <: AbstractIdentityEdge

An explicit relation over named quantities: check(vals, point) -> (lhs, rhs) must agree for every hub implementing all of quantities (a NamedTuple name => quantity Type). See @identity_edge.

check_identity_coverage() -> Vector{CoherenceFinding}

C11: every identity edge should be exercised — an edge that generates zero checks constrains nothing, a self-reported :gap. Dispatches per edge type: a tuple identity no hub implements; a gated isotropy identity whose requires_internal matches no @symmetry profile (gate closed); or ANY isotropy identity — gated or not — with no hub implementing ≥ 2 distinct family components (the ungated case the modal version silently skipped).

identities_for(quantity) -> Vector{AbstractIdentityEdge}

The identity edges quantity (instance or type) participates in — tuple identities naming it, and family identities whose family it belongs to.

identity!(name; quantities=nothing, check=nothing, family=nothing,
          requires_internal=nothing, sweep=(;), finite_N=8,
          rtol=1e-8, atol=1e-10, exclusions=[], notes="", references=String[])

Record an identity edge (a TupleIdentityEdge or IsotropyIdentityEdge). Exactly one of the two mode signatures must be given: (quantities + check) for a tuple identity, or family (an abstract quantity supertype, optionally requires_internal symmetry-gated) for component isotropy. Tuple participants must be field-less quantity types (instantiable from the bare type).

finite_N is the OBC/PBC hub size the generated checks run at; the default 8 suits spin-1/2 hubs but is a 3ᴺ dense-ED trap for spin-1 models — prefer 6 for families that reach S=1 chains (see src/identity_registry.jl). rtol must be in [0, 1) (a value ≥ 1 would pass every check) and atol ≥ 0.

participants(edge::AbstractIdentityEdge) -> Vector{Type}

The quantity types edge relates: the declared tuple, or the family's component-carrying concrete members.

@identity_edge :name key=value …

Macro sugar around identity!: the positional :name is the edge's identifier; the remaining key=value pairs are forwarded as keyword arguments. See src/identity_registry.jl for the declared catalog.

DUALITIES :: Vector{Duality}

The duality-edge store, populated at include-time by dual! / @dual. Query with dualities; the generated cross-implementation checks are the :dual kind of generated_checks.

Duality

One parameter-mapped model↔model equivalence — see @dual. param_map sends a source instance to the equivalent target instance; examples are the source instances the generated cross-checks run at (chosen off any self-dual locus so the map is exercised nontrivially); involution asserts param_map ∘ param_map ≈ id (checked statically on the examples).

DualityQuantitySpec

One quantity both sides of a Duality must agree on: compared at boundary condition bc, on the fetch-kwargs grid sweep, after mapping the target-side value through value_map(value, source_instance) (identity by default; carries operator renormalisations and additive constants, e.g. the Jordan–Wigner −h energy-density offset between TFIM and the Kitaev wire).

check_duality_maps() -> Vector{CoherenceFinding}

C12: static sanity of every duality edge, evaluated on its registered examples only (the C8 pattern — predicates run, fetch does not):

• each example is a source instance and param_map(example) is a target instance (:error otherwise — the map is malformed);
• an involution=true edge satisfies param_map(param_map(x)) ≈ x on every example (:error);
• each quantity spec has canonical, independent (non-delegating) registry rows on BOTH endpoints at its bc — a missing or delegation-backed row is a :gap: the cross-check the edge promises cannot be generated yet.

dual!(name, source_T, target_T; param_map, kind, quantities,
      examples, involution=false, finite_N=8, rtol=1e-8, atol=1e-10,
      regime="", notes="", references=String[])

Record a duality edge. quantities is an iterable of NamedTuples (quantity=Q, bc=BC[, sweep=(…)][, value_map=f]) — the explicit allowlist of observables the duality maps; examples must be non-empty source instances. involution=true (parammap² ≈ id, checked on the examples) requires `sourceT === target_T— a self-duality; cross-family edges cannot be involutions.rtol ∈ [0, 1),atol ≥ 0`.

dualities(model) -> Vector{NamedTuple}

The duality edges touching model (as source or target): (name, source, target, kind, regime, references) rows.

@dual :name Source Target param_map=… kind=… quantities=[…] examples=[…] …

Macro sugar around dual!: :name and the Source/Target model types are positional; the remaining key=value pairs are forwarded as keyword arguments. See src/duality_registry.jl for the declared catalog.

LIMIT_EDGES :: Vector{LimitEdge}

The asymptotic-limit store, populated at include-time by limits_to! / @limits_to. Query with limits_from / limits_into; the generated convergence-sequence checks are the :limit kind of generated_checks.

LimitEdge

One asymptotic model→model limit — see @limits_to. param is the driven source field, approach the strictly-monotone parameter sequence (ordered toward the limit), rate optional human-readable convergence-rate metadata, quantities the per-quantity convergence specs, and mono_slack the relative slack of the error-shrinkage requirement (declare a looser value for slowly/non-uniformly converging limits, e.g. logarithmic rates).

LimitQuantitySpec

One quantity a LimitEdge's generated convergence check runs on: compared at boundary condition bc on the fetch-kwargs grid sweep, with the sequence's terminal error required below final_atol (set from the measured convergence at declaration time; the looser early-sequence behaviour is covered by the monotonicity requirement).

check_limit_edges() -> Vector{CoherenceFinding}

C13: static sanity of every limit edge:

• the driven param is a field of the source model (:error — checked by reconstructing the default instance at the first approach point);
• each quantity spec has canonical, independent (non-delegating) registry rows on BOTH endpoints at its bc — missing or delegation-backed rows are a :gap (the convergence check would be absent or circular, #701's rule).

limits_from(model) -> Vector{NamedTuple}

The asymptotic limits of model (as the driven source): (name, target, param, regime, rate, references) rows.

limits_into(model) -> Vector{NamedTuple}

The models that asymptotically approach model — the inverse of limits_from: (name, source, param, regime, rate, references) rows.

limits_to!(name, source_T, target_T; param, approach, regime,
           quantities, rate=nothing, finite_N=8, mono_slack=0.1,
           notes="", references=String[])

Record an asymptotic limit edge. approach must be strictly monotone (its direction encodes the side the limit is taken from); quantities is an iterable of NamedTuples (quantity=Q, bc=BC, final_atol=ε[, sweep=(…)]); mono_slack is the relative tolerance of the error-shrinkage requirement (each error may exceed its predecessor by at most this fraction).

@limits_to :name Source Target param=:Δ approach=[…] regime="…" quantities=[…] …

Macro sugar around limits_to!: :name and the Source/Target model types are positional; the remaining key=value pairs are forwarded as keyword arguments. See src/limits_registry.jl for the declared catalog.

EXPONENT_SWEEPS :: Vector{AbstractExponentSweep}

The declared scaling-plane hubs, populated at include-time by exponent_sweep! / refuse_exponents!. Every hub with a CriticalExponents method must appear here, or check_derivation_coverage reports it: an exponent table nothing declares is a table the network never sees.

AbstractExponentSweep

A declared hub of the scaling plane: a (model, bc) whose CriticalExponents row either IS handed to the network (SweptExponents) or is deliberately kept out of it (RefusedExponents).

Two types rather than one with a refused field, for the reason AbstractIdentityEdge gives: a refused hub has no sweep, no dimension and no derived-from list, so one struct would carry a mode tag and a nothing-filled half, and _scaling_checks would branch where it can dispatch.

DerivationReach

One (model, bc) hub and the relation names whose type-keyed derivation step is CLOSED on it: the hub fetches the step's output and every quantity the step needs. quantities is how many distinct quantity families the hub implements.

RefusedExponents

A hub whose CriticalExponents are kept OUT of the network, carrying reason.

It exists because the name-keyed consistency_report cannot tell two quantities wearing one letter apart, so a table whose α is not the specific-heat exponent has to be excluded rather than fed in and reported as a contradiction. The refusal is emitted as a visible skip, because an absence and an exclusion read the same in a pass count.

ScalingRefusal(status, reason)

Why a hub produced no routes at a sweep point. status is :skip where the table is DECLARED not to close (too few exponents, no quoted error, no relation reaches it) and :error where a call THREW.

The split is the point. A renamed fetch keyword and a BKT table carrying η alone both end a sweep point, and reported the same way the first disappears into the second: a suite that treats every non-route as a declared skip goes green while a whole hub's cross-checks stop existing. :error fails the suite, matching CheckOutcome's own split of a config bug from a contradiction.

SweptExponents

A hub whose exponent table is cross-checked: the (model, bc), the sweep of fetch kwargs to run it at, the spatial dimension the hyperscaling relations need, and the routes that may not judge it.

dimension is nothing where hyperscaling does not apply, :sweep where the sweep's own d is the dimension, or a number where the hub sits at a fixed d its fetch does not take as a kwarg.

derived_from maps a target exponent to the relation NAMES the shipped value was obtained from; those routes cannot check it and are skipped with a reason. k is the sigma multiplier of the pass criterion.

_emits_only_skips(s::AbstractExponentSweep) -> Bool

Whether a SWEPT declaration produces no check that can return a verdict.

Emptiness is the test that reads naturally here and it cannot fire: a point _scaling_checks cannot prepare still emits a refusal check, so the vector is never empty and a guard on isempty would be a guard unable to fail. What can happen, and is what this asks, is a declaration every one of whose points was skipped. An :error counts as content: it fails the suite, so a hub that is merely broken is loud already and does not also need a coverage finding. A refused hub is exempt by construction; its skip IS its content.

_sigma_outcome(held, value, sigma_held, sigma_route; k, detail="") -> CheckOutcome

The scaling plane's pass criterion: |value − held| ≤ k·√(σ_held² + σ_route²), floored at round-off. Reported as lhs = held, rhs = value, with rel_err carrying the DEVIATION IN SIGMA rather than a relative difference; what a reader of a failing row needs is how far outside the stated errors it is.

A non-finite input is :error, never :pass. The tolerance is built FROM the sigmas, so an infinite one accepts every disagreement; refusing is the only answer that does not turn a numerical breakdown into agreement.

check_derivation_coverage() -> Vector{CoherenceFinding}

Every hub that can fetch CriticalExponents is declared (swept or refused), and every declaration generates at least one check.

Both directions are needed and they fail differently: an undeclared hub is a table nothing cross-checks and nothing says so, and a declaration that judges nothing reads as coverage while constraining nothing. Delegation rows of REGISTRY are exempt: a delegated table is the same numbers as the hub it routes to, so sweeping it would run one check several times under different names.

derivation_reach() -> Vector{DerivationReach}

Which hubs the AbstractQAtlas relation network could cross-check today: for each (model, bc) in REGISTRY, the relations whose type-keyed derivation step has its output and all of its quantity inputs implemented there.

A genuine cross-check needs the hub to fetch at least TWO of the step's quantities, so a step whose only other typed slot is a supplied temperature does not count.

Structural, and an upper bound on what fires, in two ways worth keeping apart. A step's UNTYPED slots are not consulted here at all, so a relation can close on a hub's quantities and still have no route because a supplied value it needs does not exist. Four of the reachable relations sit in test_abq_conformance.jl's MATERIALIZABLE_BUT_UNWIRED for exactly that. And whether the solve computes at all is generated_checks's business, not this one's.

Name-sorted and deterministic. Pinned by test/lint/test_derivation_reach.jl, so the reachable set cannot shrink unnoticed.

exponent_hubs() -> Vector{Type}

Every model type with a fetch(model, ::CriticalExponents, …) method, found by scanning methods(fetch).

Reflection rather than REGISTRY, because most universality classes carry no registry row: of the fifteen types with such a method, five are registered (Universality{:MeanField} plus the four delegating models). A coverage guard keyed on the registry alone would be structurally unable to see the ten classes that carry the exponent tables.

exponent_sweep!(model, bc; sweep=(;), dimension=:sweep, derived_from=[],
                k=3.0, notes="", references=String[])

Declare a SweptExponents hub. See src/derivation_registry.jl for the catalog.

Refuses a duplicate (model, bc, sweep), a non-positive k, a dimension that is neither nothing, :sweep nor a real, a :sweep dimension whose sweep carries no real d, and a derived_from naming an exponent or a relation that does not exist. dimension=nothing needs notes: it suppresses the hyperscaling routes, and an unexplained suppression reads as coverage.

refuse_exponents!(model, bc; reason, references=String[])

Declare a RefusedExponents hub: its CriticalExponents are kept out of the network and reason says why.

A refusal is keyed on (model, bc) ALONE, because its generated check carries no sweep point in its id; two refusals for one hub would pass a sweep-aware duplicate test and then collide on that id, which surfaces three layers away as generated_checks calling the generator non-deterministic.

@exponent_sweep Model BC key=value …

Macro sugar around exponent_sweep!, matching @identity_edge's shape: the two positional arguments are the hub, the rest are forwarded as keywords.

@refuse_exponents Model BC reason=…

Macro sugar around refuse_exponents!.

const AbstractModel = AbstractQAtlasModel

Backward-compatible alias. Existing downstream code dispatches on ::AbstractModel; new code should use ::AbstractQAtlasModel directly or — preferably — a concrete model struct.

Model{M} <: AbstractQAtlasModel  (deprecated)

Phantom-typed Dict wrapper kept for backward compatibility. The Model(:TFIM; J=1.0, h=1.0) constructor below still works but is routed through the Symbol-dispatch deprecation shim in src/deprecate/legacy_fetch.jl. Prefer concrete model structs for new code.

Quantity{Q} <: AbstractQuantity  (deprecated)

Phantom-typed wrapper kept for the legacy symbol API. New code should use concrete quantity structs such as Energy(), MagnetizationX(), ZZCorrelation(; mode=:static).

AperiodicSequence(ω) <: DisorderCorrelation

A deterministic modulation whose fluctuations grow as Δ(L) ∼ L^ω. Luck's criterion governs. ω = 1/2 reproduces a random sequence, and Luck then reduces to Harris in one dimension.

BinaryDisorder(κ) <: DisorderFamily

Two couplings, λ ∈ {1, κ} with equal probability, 0 < κ ≤ 1. Bounded away from zero, so E[λ^s] exists for EVERY s: the lower bound on z that PowerLawDisorder imposes is a property of that family and not of the physics that reads it.

DisorderCorrelation

How the randomised couplings are correlated in space. This is the axis the relevance criteria classify, so it decides WHICH criterion applies to a disordered model, not merely how strong the disorder is.

DisorderFamily

A distribution of dimensionless couplings λ > 0. A concrete family answers log_moment, mean_log, var_log and moment_floor; nothing else is assumed about it.

Disordered(clean::AbstractQAtlasModel; couplings...)

clean with the named couplings drawn at random: field c of clean becomes clean.c * λ, with λ from the family given for c. The clean value is the SCALE, not the coupling.

Disordered(TFIM(; J=1.0, h=1.0); J=PowerLawDisorder(1.0), h=PowerLawDisorder(1.0))

Every name must be a field of clean, which is checked: a misspelling is the one way to ask for disorder and silently not get it.

A Disordered model does not inherit the clean model's answers: it is not a subtype of M, so a clean fetch cannot dispatch on it and asking for one is a MethodError rather than a clean value. That is the type system doing it; no blanket refusal is registered here, because one would be ambiguous with the generic per-quantity dispatchers that already exist.

PowerLawCorrelated(ρ) <: DisorderCorrelation

Correlator falling as G(r) ∼ r^{−ρ}. Weinrib-Halperin governs, and on the UNCORRELATED DISORDERED ν, not the clean one: it asks whether correlations move a fixed point that disorder has already changed.

PowerLawDisorder(D) <: DisorderFamily

P(λ) = D⁻¹ λ^{−1+1/D} on (0, 1], the strong-disorder RG's generic family ([2] §A.1): D² = var(ln λ), and D = 1 is uniform on [0, 1]. E[λ^s] = 1/(1 + D s), so moments below s = −1/D do not exist.

Uncorrelated() <: DisorderCorrelation

Independent couplings. Harris's criterion governs, on the CLEAN correlation length exponent.

_clean_nu(m::Disordered; d_euclidean::Int) -> Real

The clean model's correlation-length exponent, via its universality class.

d_euclidean, not the criterion's spatial d: CriticalExponents is keyed by the EUCLIDEAN dimension, so a quantum chain asks it at d = 2 while Harris asks about that same chain at d = 1. Mixing them is silent, because both are small positive integers.

Throws naming the missing link rather than a MethodError: the two ways it can be absent are different gaps in the atlas and worth telling apart.

clean_model(m::Disordered) -> AbstractQAtlasModel

The model m randomises. Its field values are the SCALES of the random couplings, not couplings themselves.

correlation(m::Disordered) -> DisorderCorrelation

How the randomised couplings are correlated, which is what selects the relevance criterion in disorder_relevance.

disorder(m::Disordered, coupling::Symbol) -> DisorderFamily

The family randomising coupling. Throws if that coupling is not random, rather than returning a "no disorder" family, because a deterministic coupling and an absent one are different statements.

disorder_relevance(m::Disordered; d, ν₀=nothing, ν_dis=nothing, atol=0) -> Symbol

Does this disorder change the fixed point? :relevant, :marginal or :irrelevant.

The correlation selects the criterion, which is the whole point of carrying one:

d_euclidean has no default and is required wherever it is actually read, which is the clean-ν lookup: give ν₀ yourself, or take the correlated route, and it is not asked for. d is the system's own spatial dimension, which is what the criteria take and what quenched disorder lives in. d_euclidean is the dimension of the classical theory whose exponent table CriticalExponents holds: d + z for a quantum critical point, and simply d for a classical model, which has no imaginary-time direction to add. A quantum chain is d = 1, d_euclidean = 2; a 2D classical Ising model is d = 2, d_euclidean = 2. Handing the second one d + 1 is how that model silently reports :relevant where Harris' own 1974 answer is :marginal.

ν₀ is looked up from the clean model's universality class unless given. ν_dis has no such route: it is the exponent of the uncorrelated DISORDERED fixed point, a different object from anything the clean model knows, so it must be supplied. Each is read by one criterion only, and passing the other one is refused rather than ignored.

julia> disorder_relevance(RandomTFIM(); d=1, d_euclidean=2)   # ν₀ = 1 < 2 = 2/d
:relevant

log_moment(f::DisorderFamily, s::Real) -> Float64

ln E[λ^s], in logs so a residual built from it stays free of cancellation where the terms are all O(s).

mean_log(f::DisorderFamily) -> Float64. `E[ln λ]`.

moment_floor(f::DisorderFamily) -> Float64

inf{s : E[λ^s] < ∞}, or -Inf where every moment exists.

var_log(f::DisorderFamily) -> Float64. `var[ln λ]`.

AnyonMutualStatistics() <: AbstractQuantity

The mutual braiding data of a PAIR of anyons, selected by the anyons fetch kwarg:

(anyons, mutual_phase)

mutual_phase is the phase the wave function acquires when one anyon is carried in a full braid around the other — π for the toric code's e/m pair (a Z₂ "mutual semion"), which is what makes the bound state ε = e × m a fermion even though e and m are both bosons.

A different quantity from AnyonSelfStatistics, not a different argument to it: the two answer questions about a single anyon and about a pair, and return different fields.

AnyonSelfStatistics() <: AbstractQuantity

The self-statistics data of ONE anyon in a topologically ordered phase, selected by the label fetch kwarg:

(label, statistics, self_phase, quantum_dim, fusion)

statistics is :boson / :fermion / :anyon, self_phase the phase acquired under a 2π self-rotation, quantum_dim the quantum dimension (1 for every Abelian anyon), and fusion the anyon's fusion with itself.

The label is an INSTANCE selector, like a momentum or a site index — every label returns the same fields. That is the difference from the AnyonStatistics this replaces (#819), whose returned schema changed with its type kwarg, so no caller could use it without branching on the argument it had just passed.

See AnyonMutualStatistics for the braiding of a PAIR, which is the other schema that used to hide behind the same name.

BoundaryEntropy() <: AbstractQuantity

Affleck-Ludwig universal (non-integer) boundary entropy log g of a conformal boundary state in a 1+1D rational CFT, given by

g_a = S_{0a} / sqrt(S_{00})

for the Cardy boundary state |a⟩ corresponding to primary a, where S_{ab} is the modular S-matrix. The quantity log g is non-negative under unitary RG and decreases monotonically (g-theorem). The universal "ground-state degeneracy" interpretation goes back to Affleck-Ludwig 1991. Tracking: #580.

CFTThermalEntropyDensity <: AbstractQuantity

Leading low-temperature thermal entropy density (entropy per unit length) of a (1+1)D conformal field theory,

s(T) = pi c T / 3 = pi c / (3 beta),

with the central charge. This is the temperature derivative of the universal CFT free energy density (Bloete-Cardy- Nightingale 1986), and the operational complement of ThermalEnergyDensity.

CardyEntropy() <: AbstractQuantity

Asymptotic high-energy entropy (log of the density of states) of a 1+1D CFT, given by the Cardy 1986 formula

S_Cardy(E) = 2 π sqrt(c E / 6),

where c is the central charge of the CFT and E is the excitation energy (in units where the cylinder circumference is 1). This counts the number of CFT states at fixed energy E and underlies, e.g., the Cardy-Verlinde / black-hole-entropy correspondences. Tracking: #580.

CasimirEnergyCorrection() <: AbstractQuantity

Universal 1/L finite-size correction to the ground-state energy of a 1+1D conformal field theory.

For a critical 1+1D system with central charge c and CFT velocity v on a system of size L:

• Periodic boundary (PBC): $E_0(L) = L\,\varepsilon_\infty - \dfrac{\pi c v}{6 L} + O(L^{-2})$
• Open boundary (OBC): $E_0(L) = L\,\varepsilon_\infty + \varepsilon_{\mathrm{surf}} - \dfrac{\pi c v}{24 L} + O(L^{-2})$

This quantity returns only the universal $1/L$ correction term ($-\pi c v/(6 L)$ at PBC, $-\pi c v/(24 L)$ at OBC), not the extensive $L \varepsilon_\infty$ piece nor the OBC surface term $\varepsilon_{\mathrm{surf}}$. The PBC-to-OBC ratio is exactly 4, independent of the universality class.

The CFT velocity v is model-dependent (e.g. $v = 2J$ for the TFIM at the critical point, $v = (\pi/2) J$ for the AFM Heisenberg chain, $v = v_F$ for the XXZ Luttinger liquid) and is supplied by the caller as a kwarg. The central charge c is read from the universality class via the same data the Universality{C} entry exposes for CriticalExponents.

References

• J. Cardy, Nucl. Phys. B 270, 186 (1986).
• H. W. J. Blöte, J. L. Cardy, M. P. Nightingale, Phys. Rev. Lett. 56, 742 (1986).
• I. Affleck, Phys. Rev. Lett. 56, 746 (1986).

ConformalCasimirEnergy() <: AbstractQuantity

Universal Casimir (ground-state) energy of a 1+1D CFT on a cylinder of circumference L (PBC). Cardy 1986 / Blote-Cardy-Nightingale 1986 / Affleck 1986 showed it is determined entirely by the central charge:

E_0(L) = -π c / (6 L).

This is the strict thermodynamic-limit subtraction lim_{L->∞} (E_GS(L) - L * e_∞) * L that extracts the universal finite-size correction. Sign convention follows the original PRL: E_0 < 0 for unitary CFTs with c > 0. Tracking: #580.

ConformalTower() <: AbstractQuantity

The conformal tower of states excitation spectrum in 1+1D conformal field theories. At boundary condition bc::Union{PBC, OBC}, returns a sorted vector of NamedTuples representing the lowest-lying excitation energies E_n - E_0 relative to the ground state, their scaling dimensions Δ_n (or h_n), and their degeneracies:

(energy = E_n - E_0, dimension = Δ_n, degeneracy = g_n)

For periodic boundary conditions (PBC), the excitation energies scale as: En - E0 = (2π v / L) Δn where `Δn = hn + \bar{h}n` is the scaling dimension.

For open boundary conditions (OBC), the excitation energies scale as: En - E0 = (π v / L) hn where `hn` is the boundary scaling dimension.

Keyword arguments:

• L::Real: system size.
• v::Real: CFT sound velocity.

ConformalWeights() <: AbstractQuantity

Primary scaling dimension h of a 2D rational CFT. For Virasoro MinimalModel this is the Kac-table entry h_{r,s}; for WZWSU2 it is the SU(2)-spin label h_j = j(j+1)/(k+2).

Concrete model fetch methods take additional keyword arguments identifying the primary (r, s for MinimalModel; j for WZWSU2) and return an exact Rational{Int}.

CornerEntanglementCoefficient() <: AbstractQuantity

Universal corner coefficient in the bipartite entanglement entropy of a 2+1D CFT with a boundary corner of angle $\theta$:

S(ρ_A) = a |∂A| - c(\theta) \ln(L/\epsilon) + o(\ln(L/\epsilon)).

For a nearly smooth boundary $\theta \to \pi$, $c(\theta) \approx \sigma (\pi - \theta)^2$ where $\sigma = \frac{\pi^2}{24} C_T$. If no angle theta is provided, the fetch method returns the smooth-limit prefactor $\sigma$.

DynamicLocalization() <: AbstractQuantity

Cycle-averaged effective-hopping renormalization of a tight-binding band driven by a spatially-uniform monochromatic ac electric field (Peierls coupling). In units e = ℏ = a = 1, a field E(τ) = E₀ cos(ωτ) gives the dimensionless drive K = E₀/ω, and the hopping is renormalized by the exact, nonperturbative Bessel factor

t_eff / t = J₀(K).

The band collapses — "dynamic localization" — at the zeros of J₀ (first at K = 2.404826…), where a static tilt drives no current despite E₀ ≠ 0. This is the hallmark exact nonlinear (all-orders-in-field) response of the ac-driven free-fermion chain (Dunlap–Kenkre 1986; Holthaus–Hone 1996); the full harmonic content of the current is the Bessel spectrum Jₙ(K) (see driven_band_harmonic_weights).

E8Spectrum() <: AbstractQuantity

Zamolodchikov E8 mass spectrum (8 stable particles). Concrete implementation lives in src/universalities/E8.jl; the type is defined here so src/core/alias.jl can reference it without circular loads.

EdwardsAndersonParameter() <: AbstractQuantity

The Edwards–Anderson spin-glass order parameter q_EA = [⟨s_i⟩²] ([6]) — the disorder-averaged squared local magnetization. Nonzero with zero net magnetization is the signature of the spin-glass phase, where spins freeze in random directions.

EnergyLocal() <: AbstractQuantity

Bond-resolved energy density vector, length N_bulk − 1 for a bond Hamiltonian Σ_b h_b.

EntanglementGrowthSlope() <: AbstractQuantity

Linear-growth slope of the half-system entanglement entropy after a global quench from a thermal-like initial state. Calabrese-Cardy 2005 predicts that, for t < L / (2 v),

dS_A / dt = (π c v) / (3 β_eff),

where c is the central charge of the critical post-quench Hamiltonian, v is the Lieb-Robinson velocity of correlation spreading, and β_eff is the effective inverse temperature of the generalised-Gibbs steady state set by the initial state. This struct is the type tag; concrete dispatches live at the universality layer and on model files. Reference: Calabrese-Cardy 2005, J. Stat. Mech. P04010. Tracking: #580 quench-dynamics phase.

EntanglementSaturationDensity() <: AbstractQuantity

Per-unit-length saturation value of post-quench entanglement entropy in the Calabrese-Cardy 2005 picture: in the long-time regime t > L / (2 v), the half-system entropy saturates at

S_A(infty) / L = π c / (6 beta_eff),

where c is the central charge of the post-quench critical Hamiltonian and beta_eff is the effective inverse temperature of the generalised-Gibbs steady state. Universal in (c, beta_eff). Partner to EntanglementGrowthSlope (which gives the dS/dt of the linear regime). Reference: Calabrese-Cardy J. Stat. Mech. P04010 (2005). Tracking: #580.

ExactSpectrum

Dispatch tag for the full sorted eigenvalue spectrum of a finite model.

GGEValue{Q<:AbstractQuantity}(inner) <: AbstractQuantity

Wrapper quantity carrying an underlying observable inner::Q whose generalised Gibbs ensemble (GGE) stationary value is to be computed — i.e. the t → ∞ long-time average that an integrable (free-fermion) quench reaches.

For an integrable system the ordinary (canonical) Gibbs ensemble does not describe the long-time relaxed state: every mode-occupation n_k = ⟨c_k† c_k⟩ is a separate conserved quantity, so the diagonal ensemble is a generalised Gibbs ensemble fixed by the full distribution {n_k}. See Rigol et al. [7] for the foundational argument and Calabrese, Essler, Fagotti J. Stat. Mech. (2012) P07016 / P07022 for the TFIM-specific closed-form expressions.

fetch(model_f, ::GGEValue{Q}, bc; initial::ModelType, kwargs...) returns the GGE expectation of the Q observable in the post-quench Hamiltonian model_f, with the conserved mode occupations frozen by the initial-state (initial) Bogoliubov rotation.

Construction

GGEValue(Energy())                  # ⟨H_f⟩ stationary value
GGEValue(MagnetizationX())          # ⟨σˣ⟩ stationary value

Fetch signature (TFIM)

fetch(TFIM(h = h_f), GGEValue(Energy()), Infinite();
      initial = TFIM(h = h_0)) -> Float64

A no-quench limit h_0 = h_f reduces to the static ground-state value of the inner observable.

HighHarmonicAmplitude() <: AbstractQuantity

Peak amplitude of the harmonic-th harmonic (frequency n ω) of the intraband current of a tight-binding band driven by a monochromatic ac field — the exact, all-orders-in-field higher-order response (high-harmonic generation).

For drive K = E₀/ω the n-th harmonic amplitude of the current, maximized over crystal momentum, is the Bessel envelope

A₀(K) = 2t |J₀(K)|,      Aₙ(K) = 4t |Jₙ(K)|   (n ≥ 1),

so harmonic = 1 is the linear response, harmonic ≥ 2 the genuinely nonlinear higher harmonics. For small K, Aₙ ∝ Kⁿ — the n-th harmonic is the order-n (χ⁽ⁿ⁾) response, whose leading coefficient is nonlinear_susceptibility. The n = 0 value is the dynamic-localization envelope (2·|DynamicLocalization|). (Dunlap–Kenkre 1986; Holthaus–Hone 1996.)

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

Light-cone spreading of the real-time spin correlator ⟨S^A_i(t) S^B_j(0)⟩ as a matrix over (site, time) — a QAtlas-specific numerical diagnostic (returns an array, not a scalar), kept here rather than in AbstractQAtlas's scalar-quantity vocabulary. LightconeSpinCorrelation(:z, :z) is the σᶻ cone.

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

Site-resolved equilibrium magnetization [⟨σ^A_i⟩_β for i = 1:N] along axis A ∈ (:x, :y, :z) — a Vector{Float64} of length N_bulk.

LocalMagnetization(:y) is identically zero for any real Hermitian Hamiltonian (parity / time-reversal); a model that returns it explicitly does so as an exact baseline against random-sample estimators that fluctuate around zero.

The post-quench counterpart is QuenchLocalMagnetization.

const MagnetizationX = Magnetization{:x}   # deprecated alias

Bulk-averaged ⟨σˣ⟩ in Pauli convention (= 2 ⟨Sˣ⟩ in spin-1/2 units). For a spin-1/2 chain H = -J ΣSᶻSᶻ - h ΣSˣ this is the transverse magnetization. Deprecated — use Magnetization(:x).

const MagnetizationY = Magnetization{:y}   # deprecated alias

Bulk-averaged ⟨σʸ⟩. Deprecated — use Magnetization(:y).

const MagnetizationYLocal = LocalMagnetization{:y}   # deprecated alias

Site-resolved ⟨σʸ_i⟩. Deprecated — use LocalMagnetization(:y).

const MagnetizationZ = Magnetization{:z}   # deprecated alias

Bulk-averaged ⟨σᶻ⟩. For Z₂-symmetric phases on an infinite system this is the order parameter at low temperature. Deprecated — use Magnetization(:z).

const MagnetizationZLocal = LocalMagnetization{:z}   # deprecated alias

Site-resolved ⟨σᶻ_i⟩. Deprecated — use LocalMagnetization(:z).

MeanRatio() <: AbstractQuantity

Mean of the consecutive level-spacing ratio r_n = min(s_n, s_{n+1}) / max(s_n, s_{n+1}), introduced by Oganesyan-Huse (2007) and tabulated for the Wigner-Dyson and Poisson ensembles by Atas-Bogomolny-Giraud-Roux, Phys. Rev. Lett. 110, 084101 (2013):

PrimaryFields() <: AbstractQuantity

Full list of primary fields of a 2D rational CFT. For MinimalModel the result is a Vector{NamedTuple{(:r, :s, :h)}} of length (p - 1)(p_prime - 1) / 2, with one entry per Kac-symmetry orbit.

Future CFT classes may return different NamedTuple schemas (e.g. (j, h) for WZW). The return type is therefore a Vector{<:NamedTuple} whose schema depends on the model.

QuenchEntanglementEntropy() <: AbstractEntanglementMeasure

Time-evolved entanglement entropy S_vN(ℓ, t) = −Tr ρ_A(t) log ρ_A(t) after a sudden quench from the ground state of an initial::AbstractQAtlasModel (H_0, passed as the initial keyword to fetch) to the post-quench Hamiltonian (the model argument).

Calabrese–Cardy quasi-particle picture (J. Stat. Mech. P04010 (2005)): linear growth S(ℓ, t) ≈ (c/3) v_E t for t ≪ ℓ/(2 v_E), saturating at (c/3) log ℓ + const for t ≫ ℓ/(2 v_E).

The equilibrium counterpart is AbstractQAtlas's VonNeumannEntropy. See docs/src/calc/tfim-quench-entanglement.md for the free-fermion derivation in the TFIM.

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

Time-evolved site-resolved magnetization after a sudden quench,

⟨σ^A_i⟩(t) = ⟨ψ_0| e^{iH_f t} σ^A_i e^{-iH_f t} |ψ_0⟩,

from the ground state of an initial::AbstractQAtlasModel (H_0, passed as the initial keyword to fetch) to the post-quench Hamiltonian (the model argument). Returns a single Float64 for one (i, t) pair — unlike the equilibrium LocalMagnetization, which returns the whole site vector.

See docs/src/calc/tfim-sigma-x-quench.md for the closed-form derivation in the TFIM (Calabrese–Essler–Fagotti, J. Stat. Mech. P07016 (2012); Barouch–McCoy–Dresden, PRA 2 (1970)).

SpectralFormFactor() <: AbstractQuantity

Disorder-averaged spectral form factor K(t) = ⟨|Σ_n e^{−iE_n t}|²⟩ / Z² — the canonical late-time quantum-chaology diagnostic (Mehta 2004 §16; Cotler et al. 2017).

For GUE random-matrix-theory eigenvalues in the large-N thermodynamic limit, with rescaled time τ = t / N, the disorder-averaged SFF has the universal closed form

• K(τ) = (τ/(2π)) − (τ/(4π)) log|1 − τ/(2π)| for τ ≤ 2π
• K(τ) = 1 for τ ≥ 2π

so that K exhibits a linear ramp K(τ) ≈ τ/π for small τ and saturates to the universal plateau K(τ→∞) = 1 for τ beyond the Heisenberg time τ_H = 2π.

QAtlas Phase 1 (issue #243) exposes only the late-time plateau τ ≥ τ_H for the GUE ensemble; the ramp regime and the GOE/GSE sigma-model closed forms (Mehta 2004 §16) are deferred to Phase 2.

References

• M. L. Mehta, Random Matrices, 3rd ed., Elsevier (2004), §16.
• E. Brézin, S. Hikami, Phys. Rev. E 55, 4067 (1997).
• J. S. Cotler, G. Gur-Ari, M. Hanada, J. Polchinski, P. Saad, S. H. Shenker, D. Stanford, A. Streicher, M. Tezuka, JHEP 05, 118 (2017), arXiv:1611.04650 — ramp-plateau picture.

SphereFreeEnergy() <: AbstractQuantity

Universal sphere free energy $F = -\ln |Z(S^3)|$ of a 2+1D conformal field theory. Acts as a measure of the degrees of freedom in 2+1D (the $F$-theorem).

SpinGlassSusceptibility() <: AbstractQuantity

The spin-glass susceptibility χ_SG = (1/N) Σ_ij [⟨s_i s_j⟩_c²] — the ordering susceptibility of the EdwardsAndersonParameter, diverging at the spin-glass transition. Distinct from the ordinary Susceptibility, which stays finite there.

SteadyStateCurrent() <: AbstractQuantity

Steady-state mass / particle current j in a 1D non-equilibrium lattice gas (e.g. ASEP / TASEP, Derrida-Lebowitz 1998). For TASEP at hopping rate p and density ρ,

j(ρ) = p ρ (1 − ρ)              (TASEP mean-field steady state)

— the canonical KPZ-class non-equilibrium observable.

const SusceptibilityXX = Susceptibility{(:x, :x)}   # deprecated alias

Static transverse susceptibility, χ_xx(β) = β · (⟨M_x²⟩ − ⟨M_x⟩²) / N. Deprecated — use Susceptibility(:x, :x).

const SusceptibilityYY = Susceptibility{(:y, :y)}   # deprecated alias

Analogue for the y-axis. Deprecated — use Susceptibility(:y, :y).

const SusceptibilityZZ = Susceptibility{(:z, :z)}   # deprecated alias

Uniform longitudinal susceptibility, χ_zz(β) = β · (⟨M_z²⟩ − ⟨M_z⟩²) / N. Deprecated — use Susceptibility(:z, :z).

ThermalEnergyDensity <: AbstractQuantity

Leading low-temperature thermal energy density of a (1+1)D conformal field theory above its ground state,

e(T) - e_0 = pi c T^2 / 6 = pi c / (6 beta^2),

where is the central charge and (Affleck 1986; Bloete-Cardy-Nightingale 1986). This is the universal counterpart of ConformalCasimirEnergy: the same c prefactor that controls the Casimir term in finite size also fixes the leading thermal-excitation density in finite temperature, via modular invariance.

TracyWidom() <: AbstractQuantity

Tracy-Widom largest-eigenvalue cumulative distribution F_β(x) for the three Wigner-Dyson ensembles (β ∈ {1, 2, 4}). Returns the value F_β(x) = P[ξ_β ≤ x] at the requested x.

QAtlas Phase 1 evaluates F_β from a precomputed table compiled from Bornemann, On the numerical evaluation of Fredholm determinants, Math. Comp. 79, 871 (2010), Table 1, with monotone linear interpolation on the table support and Tracy-Widom 1994/1996 tail asymptotics outside it. A direct Painlevé-II integrator is deferred to Phase 2.

WignerSemicircleMoment <: AbstractQuantity

Moments of the Wigner semicircle distribution

rho(x) = (1 / (2 pi)) sqrt(4 - x^2),   x in [-2, 2],

the universal large-N eigenvalue density of Gaussian random matrix ensembles (GOE / GUE / GSE) under Wigner-Mehta normalisation.

The even moments are Catalan numbers,

m_{2k} = C_k = (2k)! / (k! (k+1)!),

and the odd moments vanish by symmetry. These are the universal large-N free-probability moments underlying RMT spectral statistics; they also count rooted plane trees / non-crossing pair partitions.

Reference: E. P. Wigner, Ann. Math. 62, 548 (1955); M. L. Mehta Random Matrices (1991).

WignerSurmise() <: AbstractQuantity

Wigner surmise nearest-neighbour level-spacing distribution P_β(s) for the three Wigner-Dyson ensembles (β ∈ {1, 2, 4}: GOE, GUE, GSE). The surmise is the exact N = 2 Gaussian-ensemble spacing distribution; it is also a celebrated, accurate approximation to the bulk N → ∞ spacing distribution. Returns the value P_β(s) at the requested s (the universality fetch carries β).

const XXStructureFactor = SpinStructureFactor{:x,:x}   # deprecated alias

Static transverse structure factor S^{xx}(q). Deprecated — use SpinStructureFactor(:x, :x).

const YYStructureFactor = SpinStructureFactor{:y,:y}   # deprecated alias

Static S^{yy}(q). Deprecated — use SpinStructureFactor(:y, :y).

const ZZStructureFactor = SpinStructureFactor{:z,:z}   # deprecated alias

Static longitudinal structure factor S^{zz}(q). Deprecated — use SpinStructureFactor(:z, :z) for the static factor, or DynamicalSpinStructureFactor(:z, :z) for the dynamic S^{zz}(q, ω).

LoschmidtEcho(; mode = :rate)   (deprecated)

Deprecated — returns LoschmidtRateFunction for mode = :rate and LoschmidtAmplitude for mode = :amplitude. The type was parametric on the mode, so no const alias is possible and dispatch on LoschmidtEcho{:m} is removed; use the target types directly in new code.

MagnetizationXLocal(; mode = :equilibrium)   (deprecated)

Deprecated — returns the axis-parametric site-resolved quantity for ⟨σˣ_i⟩ in mode (:equilibrium→LocalMagnetization, :quench→QuenchLocalMagnetization). The type was parametric on the mode, so no const alias is possible and dispatch on MagnetizationXLocal{:m} is removed; use the target types directly in new code.

XXCorrelation(; mode = :static)   (deprecated)

⟨σˣ σˣ⟩; see ZZCorrelation for the mode mapping.

YYCorrelation(; mode = :static)   (deprecated)

⟨σʸ σʸ⟩; see ZZCorrelation for the mode mapping.

ZZCorrelation(; mode = :static)   (deprecated)

Deprecated — returns the axis-parametric quantity for ⟨σᶻ σᶻ⟩ in mode (:static→SpinCorrelation, :connected→ConnectedSpinCorrelation, :dynamic→DynamicalCorrelation, :lightcone→LightconeSpinCorrelation). Use those types directly in new code.

component(q) -> Union{Symbol,Nothing}
component(::Type{<:AbstractQuantity}) -> Union{Symbol,Nothing}

The component / index that a family leaf's type name encodes: the spin axis of a magnetization (:x/:y/:z), the diagonal axis pair of a susceptibility / correlator / structure factor (:xx/:yy/:zz), or the excitation channel of a gap (:mass/:charge/:spin). nothing for quantities that carry no component (the default), including the site-resolved …Local magnetizations (whose extra site argument makes them a different fetch shape).

Identities that hold per-component (e.g. the static FDT χ_αα = β·Var(M_α)/N, or the SU(2) isotropy χ_xx = χ_yy = χ_zz) pair family members by matching component — see core/identity.jl.

Bound{D}

Dispatch tag for a domain of model-independent universal bounds — the bounds-namespace analogue of Universality. D is a Symbol naming the domain (:QuantumInformation, :Dynamics, :Holographic, …).

A universal bound has no home model, so it is fetched against a Bound domain rather than a Hamiltonian:

QAtlas.fetch(Bound(:QuantumInformation), CHSHBound(), Infinite())                     # 2√2 (Tsirelson)
QAtlas.fetch(Bound(:QuantumInformation), CHSHBound(), Infinite(); scheme=:classical)  # 2   (local-hidden-variable)

Every bound is registered with status=:bound and a direction (:upper/:lower); see BOUND_DIRECTIONS. Model-specific bounds (e.g. a TFIM Lieb–Robinson velocity) carry the same convention but live on their model, not here.

MinimalModel(p::Int, p_prime::Int) <: AbstractQAtlasModel

Virasoro minimal model M(p, pprime). p and `pprimemust be coprime integers withp > p_prime ≥ 2. Construction validates those conditions and throwsDomainError` otherwise.

Special cases (cross-check):

The Ising special case MinimalModel(4, 3) reproduces the central charge stored in Universality(:Ising)'s CriticalExponents table (c = 1//2).

Use fetch with CentralCharge or ConformalWeights:

fetch(MinimalModel(4, 3), CentralCharge())                  # 1//2
fetch(MinimalModel(4, 3), ConformalWeights(); r=1, s=2)     # 1//16

See also: WZWSU2, Universality, CentralCharge, ConformalWeights, PrimaryFields.

fetch(::MinimalModel, ::CentralCharge) -> Rational{Int}

Central charge of the Virasoro minimal model M(p, p_prime):

c = 1 - 6 (p - p_prime)^2 / (p p_prime).

Returned as an exact Rational{Int}.

fetch(::MinimalModel, ::ConformalWeights; r::Int, s::Int) -> Rational{Int}

Kac-table conformal weight of the primary (r, s):

h_{r,s} = ((p r - p_prime s)^2 - (p - p_prime)^2) / (4 p p_prime),
    1 ≤ r ≤ p_prime - 1,  1 ≤ s ≤ p - 1.

Out-of-range (r, s) throws DomainError. Use the Kac symmetry h_{r,s} = h_{p_prime - r, p - s} to map a label outside the fundamental rectangle into it explicitly.

fetch(::MinimalModel, ::PrimaryFields) -> Vector{NamedTuple}

All distinct primary fields of M(p, pprime), modulo Kac symmetry `(r, s) ~ (pprime - r, p - s). Each entry is a NamedTuple(r=Int, s=Int, h=Rational{Int})`.

The list is enumerated over 1 ≤ r ≤ p_prime - 1, 1 ≤ s ≤ p - 1 and de-duplicated by selecting the lex-smallest (r, s) from each Kac-symmetry orbit, so its length is

(p - 1)(p_prime - 1) / 2.

WZWSU2(k::Int) <: AbstractQAtlasModel

Wess–Zumino–Witten model with affine Lie algebra SU(2) at level k ≥ 1. Construction throws DomainError for k ≤ 0.

Special cases:

• k = 1: c = 1 (free boson at the SU(2)-symmetric radius; low-energy theory of the spin-1/2 Heisenberg antiferromagnet, Affleck 1989).
• k = 2: c = 3/2 — equivalent to 3 free Majorana fermions (each contributing c = 1/2), or equivalently the smallest N=1 super-Virasoro minimal model. Note that "Ising × free Majorana" with one Majorana would only give c = 1/2 + 1/2 = 1 ≠ 3/2; the correct decomposition needs three Majorana fermions.
• k = 3: c = 9/5.

fetch(WZWSU2(1), CentralCharge())                    # 1//1
fetch(WZWSU2(1), ConformalWeights(); j=1//2)         # 1//4

See also: MinimalModel, Universality, CentralCharge, ConformalWeights.

fetch(::WZWSU2, ::CentralCharge) -> Rational{Int}

Sugawara central charge c = 3k / (k + 2) of WZW SU(2) at level k. Returned as an exact Rational{Int}.

fetch(::WZWSU2, ::ConformalWeights; j) -> Rational{Int}

Conformal weight h_j = j (j+1) / (k+2) of the spin-j primary at level k. j must be a non-negative half-integer (i.e. Rational such that 2j ∈ ℤ_{≥0}) with 0 ≤ j ≤ k/2.

Out-of-range or non-half-integer j throws DomainError.

fetch(WZWSU2(1), ConformalWeights(); j=0)            # 0//1
fetch(WZWSU2(1), ConformalWeights(); j=1//2)         # 1//4
fetch(WZWSU2(2), ConformalWeights(); j=1)            # 1//2