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.

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.

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/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. 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.

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.

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 :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.

const AbstractModel = AbstractQAtlasModel

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

AbstractQAtlasModel

Abstract parent type for every QAtlas model. Concrete subtypes carry their physics parameters as typed fields (e.g. struct TFIM <: AbstractQAtlasModel; J::Float64; h::Float64; end).

The older Model{S}(params::Dict) phantom-typed wrapper is still an AbstractQAtlasModel (via the deprecated alias below) but new models must use concrete structs.

AbstractQuantity

Abstract parent type for quantities. New code defines concrete structs (e.g. struct MagnetizationX <: AbstractQuantity end) so dispatch is static and naming is explicit (axis, entropy variant, …). The older Quantity{S} phantom-type wrapper is retained for legacy symbol-based dispatch; see the Quantity(::Symbol) shim below.

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.

Infinite()

Thermodynamic-limit boundary condition — no finite size.

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.

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].

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

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

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).

_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.

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; a legacy fetch(::Symbol, ::Symbol, bc; kwargs...) shim is also provided in src/deprecate/legacy_fetch.jl for backward compatibility.

Each (model, quantity, bc) triple must be implemented as a separate method; this top-level definition throws an informative error for un-implemented triples.

AbstractEntanglementMeasure <: AbstractQuantity

Entanglement-measure family (VonNeumannEntropy, RenyiEntropy, LogarithmicNegativity, MutualInformation, TopologicalEntanglementEntropy, PageEntropy).

AbstractGap <: AbstractQuantity

Spectral-gap family (MassGap, ChargeGap, SpinGap); the excitation channel is the component.

AbstractMagnetization <: AbstractQuantity

Magnetization family (MagnetizationX/Y/Z and their …Local site-resolved variants); the spin axis is the component.

AbstractStructureFactor <: AbstractQuantity

Fourier-space structure-factor family (XXStructureFactor, YYStructureFactor, ZZStructureFactor); the spin-axis pair is the component.

AbstractSusceptibility <: AbstractQuantity

Static susceptibility family (SusceptibilityXX/YY/ZZ); the diagonal spin axis is the component.

AbstractThermalPotential <: AbstractQuantity

Thermodynamic-potential family: Energy, FreeEnergy, ThermalEntropy, SpecificHeat, ResidualEntropy — the quantities related by the Gibbs / Maxwell identities (f = ε − T·s, c_v = -β² ∂ε/∂β, …).

AbstractTwoPointCorrelation <: AbstractQuantity

Real-space two-point correlator family (XXCorrelation, YYCorrelation, ZZCorrelation); the spin-axis pair is the component.

AbstractVelocity <: AbstractQuantity

Characteristic-velocity family (FermiVelocity, LuttingerVelocity, LiebRobinsonVelocity).

AnyonStatistics() <: AbstractQuantity

Topological data of the anyon content of a 2D topologically ordered phase. The dispatched fetch method takes a type::Symbol kwarg selecting an anyon (or a mutual-braiding row) and returns a NamedTuple whose shape depends on the requested row — typically (label, statistics, self_phase, quantum_dim, fusion) for individual anyons, and (label, mutual_phase, anyons) for two-anyon braids.

For Abelian theories like the toric code's Z₂ order all quantum dimensions are 1; for non-Abelian theories the schema is unchanged but quantum_dim becomes irrational and additional fields (e.g. F, R matrices) may be added by the implementing method.

Has no boundary-condition argument: anyon statistics are purely topological invariants.

BB84KeyRate() <: AbstractQuantity

The BB84 asymptotic secret-key rate R(e) = 1 − 2 H₂(e) (Shor–Preskill 2000), with H₂ the binary entropy and e the qubit error rate (QBER). A provably achievable rate — a lower bound on the extractable secret-key fraction; positive for e < 11%. A status=:bound, direction=:lower quantity; fetched against a Bound domain (Bound(:QuantumInformation)).

BekensteinBound() <: AbstractQuantity

The Bekenstein universal entropy bound — an upper bound on the entropy of a bounded system (S ≤ 2π R E). A status=:bound quantity; fetched against a Bound domain (Bound(:Holographic)).

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.

CHSHBound() <: AbstractQuantity

The CHSH (Bell-inequality) correlator bound — the maximum of S = E(a,b) + E(a,b′) + E(a′,b) − E(a′,b′) admissible in a given physical theory. A status=:bound quantity with the historical name (like LiebRobinsonBound); fetched against a Bound domain (not a model), with a scheme= selector choosing the theory regime (:classical → 2, :quantum → 2√2, :no_signalling → 4).

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).

CentralCharge() <: AbstractQuantity

Central charge c of the emergent CFT. For 1D critical systems extracted from the Calabrese–Cardy entanglement formula; universality pages return literature values.

ChaosBound() <: AbstractQuantity

The Maldacena–Shenker–Stanford bound on quantum chaos — an upper bound on the Lyapunov exponent λ_L of out-of-time-order correlators (λ_L ≤ 2π/β). A status=:bound quantity; fetched against a Bound domain (Bound(:Dynamics)).

ChargeGap() <: AbstractQuantity

Charge (Mott) gap of an electron system,

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

i.e. the energy cost of adding a particle plus the cost of removing one, equivalent to the gap between the half-filled ground state and the lowest charged excitation. Strictly positive in a Mott insulator and exactly zero in a metal / superconductor.

Implemented analytically for Hubbard1D at half filling via the Lieb–Wu (1968) closed-form integral.

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.)

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$.

CorrelationLength() <: AbstractQuantity

Two-point correlation length ξ controlling the exponential decay of connected equal-time correlators in a gapped phase,

⟨σ_α(0) σ_α(r)⟩_c ~ e^{-r/ξ}    (r → ∞).

For a critical system ξ = ∞; implementations return Inf in that case. At T = 0 and 1D free-fermion models like TFIM, ξ is set by the inverse mass gap (ξ = 1/(2|h - J|)).

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.

EdgeModeEnergy() <: AbstractQuantity

Energy of the lowest-lying boundary mode on an open chain. In a topological 1D superconductor (Kitaev 2001) the OBC chain hosts two Majorana zero modes at the chain ends; their hybridization energy decays exponentially with chain length,

\[E_\text{edge}(N) \sim e^{-N/\xi},\]

where ξ is the bulk correlation length. In the trivial phase the OBC lowest single-particle excitation is set by the bulk gap.

EdgeModeEnergy is the smallest positive BdG eigenvalue of the OBC chain — the same quantity as MassGap at OBC, exposed under a name that makes the boundary-mode interpretation explicit at the call site.

Currently used by Kitaev1D.

Energy{G}() <: AbstractQuantity
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 — keeping every existing fetch(model, Energy(), bc; ...) call site working unchanged. Use the explicit constructors when the caller needs a specific granularity (e.g. the thermodynamic-identity harness comparing f + T·s against per-site ε).

The non-native granularity is provided automatically by a generic conversion fallback for 1D BCs (OBC / PBC) that uses the internal _bc_size helper. Models on lattices whose size is not captured by bc.N (e.g. 2D Kitaev with Lx, Ly kwargs) currently support only their declared native granularity.

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.

FermiVelocity() <: AbstractQuantity

Fermi velocity v_F = ∂ε/∂k |_{k_F}. Meaningful for non-interacting / mean-field fermionic band structures (tight-binding lattices, Bogoliubov-de Gennes diagonalisations). In QAtlas this is the type returned by models like Honeycomb (at the Dirac cones), the other tight-binding lattices, and the TFIM Majorana mode at the critical field.

FidelitySusceptibility() <: AbstractQuantity

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

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() <: AbstractQuantity

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

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. PRL 98, 050405 (2007) 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.

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.

LiebRobinsonBound() <: AbstractQuantity

Lieb-Robinson velocity v_LR — the slope of the causal cone bounding the spread of operator commutators,

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

fetch returns v_LR itself (the bounding cone slope). This is a one-sided :bound: any genuinely measured information velocity stays ≤ v_LR, and for free-fermion models the bound is saturated by the maximum group velocity max_k |dΛ/dk|. Registered with status=:bound.

(Lieb & Robinson 1972; Hastings & Koma 2006.)

LiebRobinsonVelocity() <: AbstractQuantity

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

|| [A_x(t), B_y(0)] || <= C * exp(-mu * (|x - y| - v_LR * t)).

For free-fermion-mappable spin chains (TFIM, XY/XYh1D, the XX limit of XXZ) the bound is saturated and v_LR equals twice the maximum single-particle group velocity. Reference: Lieb-Robinson, Commun. Math. Phys. 28, 251 (1972); Hastings-Koma, Commun. Math. Phys. 265, 781 (2006). Tracking: issue #579 inequality framework.

LogarithmicNegativity() <: AbstractQuantity

Logarithmic negativity E = log Tr |ρ^{T_B}| measuring mixed-state entanglement between two subsystems. For two adjacent intervals on an infinite 1+1D-CFT chain at T = 0, the universal closed form (Calabrese-Cardy-Tonni 2012) is

E(ℓ_A, ℓ_B) = (c/4) log[ℓ_A · ℓ_B / (ℓ_A + ℓ_B)],

i.e., the same geometric-mean log of the mutual-information universal formula with the prefactor c/3 replaced by c/4. Tracking: #580.

LoschmidtEcho{M}() <: AbstractQuantity
LoschmidtEcho(:amplitude)
LoschmidtEcho(:rate)
LoschmidtRateFunction()        # alias for LoschmidtEcho{:rate}

Loschmidt-echo family for sudden-quench dynamics. After preparing |ψ_0⟩ as the ground state of an "initial" model H_0 and quenching to the "final" model H_f (passed as the first positional argument to fetch), the Loschmidt amplitude is

G(t) = ⟨ψ_0 | e^{-i H_f t} | ψ_0⟩,

with the Loschmidt echo L(t) = |G(t)|² ∈ [0, 1] and the rate function

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

Non-analytic cusps in λ(t) are dynamical quantum phase transitions (DQPT). See Heyl, Polkovnikov, Kehrein, PRL 110, 135704 (2013) and the review Heyl, Rep. Prog. Phys. 81, 054001 (2018).

The mode M::Symbol ∈ (:amplitude, :rate) is a phantom type parameter so that :amplitude (returns L(t)) and :rate (returns λ(t)) dispatch separately. The convenience alias LoschmidtRateFunction is the only flavour defined for Infinite, since the :amplitude itself is identically zero in the thermodynamic limit (extensive cumulants).

The pre-quench Hamiltonian is passed via the initial keyword on fetch, e.g.

fetch(TFIM(J=1.0, h=0.5), LoschmidtRateFunction(), Infinite();
      initial=TFIM(J=1.0, h=2.0), t=1.0)

const LoschmidtRateFunction = LoschmidtEcho{:rate}

Convenience alias for the rate-function flavour λ(t) = -log L(t)/N. See LoschmidtEcho.

LuttingerParameter() <: AbstractQuantity

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

LuttingerVelocity() <: AbstractQuantity

Luttinger-liquid / bosonisation velocity u (a.k.a. v_{LL}) of the low-energy linear-dispersion mode in a 1D critical interacting system. Used by models like XXZ1D in the Luttinger regime |Δ| < 1, the Heisenberg chain at the SU(2) point, and any other bosonised 1D critical theory.

For a free-fermion model this coincides with FermiVelocity; for interacting systems u includes the Luttinger renormalisation.

MagnetizationX() <: AbstractQuantity

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; the axis-explicit name avoids the "transverse" / "longitudinal" ambiguity that depends on the model's Hamiltonian choice.

MagnetizationXLocal{M}() <: AbstractQuantity
MagnetizationXLocal()                       # M = :equilibrium (default)
MagnetizationXLocal(:equilibrium)           # explicit equilibrium ⟨σˣ_i⟩_β
MagnetizationXLocal(:quench)                # post-quench ⟨σˣ_i⟩(t)

Site-resolved ⟨σˣ_i⟩ quantity. The mode parameter M::Symbol is a phantom type that splits the dispatch into:

• :equilibrium — site-resolved thermal expectation [⟨σˣ_i⟩_β for i = 1:N] (Vector{Float64}). This is the original meaning; the no-argument constructor MagnetizationXLocal() keeps back-compatibility by routing here.

• :quench — time-evolved local transverse magnetisation ⟨σˣ_i⟩(t) = ⟨ψ_0|e^{iH_f t} σˣ_i e^{-iH_f t}|ψ_0⟩ after a sudden quench from the ground state of an initial::AbstractQAtlasModel (H_0) to the post-quench Hamiltonian (the model argument to fetch). Returns a single Float64 for one (i, t) pair.

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)).

MagnetizationY() <: AbstractQuantity

Bulk-averaged ⟨σʸ⟩.

MagnetizationYLocal() <: AbstractQuantity

Site-resolved ⟨σʸ_i⟩ vector of length N_bulk. 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.

MagnetizationZ() <: AbstractQuantity

Bulk-averaged ⟨σᶻ⟩. For Z₂-symmetric phases on an infinite system this is the order parameter at low temperature; finite-system fetch methods may return the absolute value / the ordered-phase limit as documented.

MagnetizationZLocal() <: AbstractQuantity

Site-resolved ⟨σᶻ_i⟩ vector of length N_bulk.

MassGap() <: AbstractQuantity

Energy gap between the ground state and the first excited state.

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):

MerminGHZBound() <: AbstractQuantity

The Mermin 3-party Bell-type bound — the maximum of the Mermin operator |⟨M₃⟩| admissible in a given theory. A status=:bound quantity (Mermin 1990); fetched against a Bound domain with scheme= choosing the theory regime (:classical → 2 local-realistic, :quantum → 4 quantum, saturated by the GHZ state).

MutualInformation() <: AbstractQuantity

Mutual information between two subsystems, I(A:B) = S(A) + S(B) - S(A ∪ B).

This struct is the type tag; concrete fetch dispatches live at the universality layer (see src/universalities/behaviour/CardyEntanglement.jl for the Calabrese-Cardy closed forms) and on model files for non-universal cases. Tracking: #580 entanglement universality catalog.

NMRRelaxationExponent() <: AbstractQuantity

Low-temperature scaling exponent θ_NMR of the NMR spin-lattice relaxation rate, 1/T_1 ∝ T^{θ_NMR} as T → 0.

For a quantum critical point the leading exponent follows the general fluctuation-dissipation rule θ_NMR = 2Δ_op − 1, where Δ_op is the scaling dimension of the operator the nuclei couple to:

• 1D transverse-field Ising QCP: Δ_σ = 1/8 ⟹ θ_NMR = −3/4.
• XXZ critical Luttinger liquid (−1 < Δ ≤ 1), contact-hyperfine coupling to the dominant transverse staggered susceptibility (Δ_op = 1/(4K)): θ_NMR = 1/(2K) − 1, where K is the Luttinger parameter. (The subdominant longitudinal channel contributes T^{2K−1}; see Chitra & Giamarchi 1997, Eq. 27.)

NMRSpinRelaxationRate() <: AbstractQuantity

NMR spin-lattice relaxation rate per site, 1/T_1(β, η). For non-interacting 1D fermion systems, computed using the regularized double momentum-space integral:

1/T_1(β, η) = 1/π³ ∫_0^π dk₁ ∫_0^π dk₂ f(ε(k₁)) (1 - f(ε(k₂))) η / ((ε(k₁) - ε(k₂))² + η²)

where η > 0 is a small regularization width (e.g. 0.1 by default).

OptimalCloningFidelity() <: AbstractQuantity

The optimal universal quantum cloning fidelity — an upper bound on the single-copy fidelity of a 1 → 2 qubit cloner (Bužek–Hillery F ≤ 5/6). A status=:bound, direction=:upper quantity; fetched against a Bound domain (Bound(:QuantumInformation)).

PageEntropy() <: AbstractQuantity

Page average entropy of a subsystem for a Haar-random pure state in H_A ⊗ H_B. For dim(H_A) = m, dim(H_B) = n with m ≤ n (else swap by purity symmetry), Page 1993 found

<S_A> = sum_{k=n+1}^{m·n} 1/k - (m-1)/(2n).

For m = n this gives <S_A> ≈ log m - 1/2 (close to maximal but reduced by 1/2); for m << n it gives <S_A> ≈ log m - m/(2n). This is the famous Page curve in dimension space underlying e.g. the information-paradox / Page-time analysis of evaporating black holes.

Reference: D. N. Page, Phys. Rev. Lett. 71, 1291 (1993), DOI 10.1103/PhysRevLett.71.1291. Tracking: #580.

Polarization() <: AbstractQuantity

The bulk polarization density (or order parameter) per site. For the classical 2D six-vertex model, it corresponds to the spontaneous polarization (in the ferroelectric phase Δ > 1) or the spontaneous staggered polarization (in the antiferroelectric phase Δ < -1).

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.

QuantumSpeedLimit() <: AbstractQuantity

The quantum speed limit — a lower bound on the time to evolve a state to an orthogonal one (Margolus–Levitin τ ≥ π/(2E)). A status=:bound, direction=:lower quantity; fetched against a Bound domain (Bound(:Dynamics)).

RenyiEntropy(α) <: AbstractQuantity

Rényi entropy of order α, S_α = (1 − α)⁻¹ log Tr ρ_A^α.

• α = 1 recovers VonNeumannEntropy (implementations may dispatch accordingly).
• α = 2 is the second Rényi entropy, frequently measured experimentally.
• α > 0, α ≠ 1 are the supported generic cases.

The inner constructor rejects α ≤ 0 and α = 1 (use VonNeumannEntropy() explicitly) — this is intentional, to force the call site to be explicit about which entropy it wants.

ResidualEntropy() <: AbstractQuantity

Zero-temperature configurational (residual) entropy density. Real- valued, non-negative; non-zero in the presence of macroscopic ground-state degeneracy (e.g. ice rule, frustrated Ising AFM, Pauling-1935-style models). Distinct from ThermalEntropy: ThermalEntropy is a finite-temperature thermodynamic quantity, while ResidualEntropy is the lim_{T -> 0} S(T) / N residual term. Zero-temperature ground-state entropy per site,

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

i.e. the entropy density of the (possibly degenerate) ground-state manifold. Non-zero for frustrated classical models with extensive ground-state degeneracy — e.g. the antiferromagnetic Ising model on the triangular lattice (Wannier 1950, ≈ 0.3230659669) and on the kagome lattice (Houtappel 1950). Defined as a separate quantity from ThermalEntropy to keep the zero-temperature limit explicit at the dispatch level (avoiding β → ∞ extrapolations of a finite-T fetch).

ScramblingTime() <: AbstractQuantity

The fast-scrambling time t_* = (β/2π) log N (Sekino–Susskind 2008) — the conjectured lower bound on the time for a thermal system of N degrees of freedom to scramble local information into global entanglement; saturated by black holes (the fastest scramblers). A status=:bound, direction=:lower quantity; fetched against a Bound domain (Bound(:Dynamics)).

SpecificHeat() <: AbstractQuantity

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

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).

SpinGap() <: AbstractQuantity

Spin gap of an electron system,

Δ_s = E₀(S^z = 1) - E₀(S^z = 0),

i.e. the lowest excitation energy at fixed total particle number that flips one spin. Zero whenever the spinon branch is gapless (e.g. the half-filled 1D Hubbard chain — rigorous Lieb–Wu result), positive in a spin-gapped phase (Haldane chain, BCS superconductor, …).

const SpinWaveVelocity = LuttingerVelocity

Spin-chain community alias for LuttingerVelocity. The "spin wave velocity" (e.g. in the Haldane / Affleck literature on the AFM Heisenberg chain) is the same quantity as the Luttinger velocity once bosonised; both dispatch through the same fetch method via the type identity.

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.

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.

SusceptibilityXX() <: AbstractQuantity

Static transverse susceptibility, χ_xx(β) = β · (⟨M_x²⟩ − ⟨M_x⟩²) / N.

SusceptibilityYY() <: AbstractQuantity

Analogue for the y-axis.

SusceptibilityZZ() <: AbstractQuantity

Uniform longitudinal susceptibility, χ_zz(β) = β · (⟨M_z²⟩ − ⟨M_z⟩²) / N.

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.

ThermalEntropy() <: AbstractQuantity

Thermal / thermodynamic entropy per site, s(β) = −∂f/∂T where f is the free energy per site. Real-valued, non-negative, monotone in T.

TopologicalEntanglementEntropy() <: AbstractQuantity

Constant subleading correction γ in the area-law bipartite entanglement entropy of a 2D topologically ordered ground state on a simply-connected disk region:

S(ρ_A) = α |∂A| − γ + O(|∂A|⁻¹).

Kitaev–Preskill (2006) and Levin–Wen (2006) showed γ = log 𝒟, where 𝒟 = √(Σ_a d_a²) is the total quantum dimension of the topological order. Returns a Float64. For the toric code (Z₂ topological order, four Abelian anyons) γ = log 2.

TopologicalInvariant() <: AbstractQuantity

Topological Z_2 invariant of a 1D BdG superconductor (Kitaev 2001). Defined as the Pfaffian sign at the time-reversal-invariant momenta k = 0 and k = π,

\[\nu = \operatorname{sgn}\bigl[\operatorname{Pf}(H_{\mathrm{BdG}}(k=0)) \cdot \operatorname{Pf}(H_{\mathrm{BdG}}(k=\pi))\bigr] \in \{+1, -1\},\]

with ν = -1 in the topological phase and ν = +1 in the trivial phase. For a gapless bulk (Pfaffian zero at k = 0 or k = π) the invariant is ill-defined and implementations should signal an error.

Currently used by Kitaev1D.

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.

UniversalityClass() <: AbstractQuantity

The emergent universality class of a model at its critical point / scaling regime.

VonNeumannEntropy{M}() <: AbstractQuantity
VonNeumannEntropy()                   # M = :equilibrium (default)
VonNeumannEntropy(:equilibrium)       # explicit equilibrium S(ℓ)
VonNeumannEntropy(:quench)            # post-quench S(ℓ, t)

Von Neumann entanglement entropy of a reduced density matrix, S_vN = −Tr ρ_A log ρ_A. The mode parameter M::Symbol is a phantom type that splits the dispatch into:

• :equilibrium — equilibrium / thermal value S_vN = -Tr ρ_A log ρ_A of the GS or thermal reduced density matrix on the first ℓ sites (kwarg ℓ). This is the original meaning; the no-argument constructor VonNeumannEntropy() keeps back-compatibility by routing here.

• :quench — 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) to the post-quench Hamiltonian (the model argument to fetch). 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).

See docs/src/calc/tfim-quench-entanglement.md for the free-fermion derivation in the TFIM.

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 β).

XXCorrelation{M}() <: AbstractQuantity
XXCorrelation(; mode::Symbol = :static)

Real-space 2-point ⟨σˣ_i σˣ_j⟩ correlator. See ZZCorrelation for the mode semantics.

XXStructureFactor() <: AbstractQuantity

Fourier-space equivalent of XXCorrelation.

YYCorrelation{M}() <: AbstractQuantity
YYCorrelation(; mode::Symbol = :static)

Real-space 2-point ⟨σʸ_i σʸ_j⟩ correlator.

YYStructureFactor() <: AbstractQuantity

Fourier-space equivalent of YYCorrelation.

ZZCorrelation{M}() <: AbstractQuantity
ZZCorrelation(; mode::Symbol = :static)

Real-space 2-point correlator ⟨σᶻ_i σᶻ_j⟩. The mode M::Symbol is a phantom type parameter so dispatch can specialise on it.

Supported mode values (by convention; individual models need only implement the ones they support):

• :static — equal-time, thermal or zero-temperature value
• :connected — ⟨σᶻ_i σᶻ_j⟩ − ⟨σᶻ_i⟩⟨σᶻ_j⟩
• :dynamic — retarded real-time correlator ⟨σᶻ_i(t) σᶻ_j(0)⟩
• :lightcone — space-time spreading ⟨σᶻ_i(t) σᶻ_j(0)⟩ as a matrix over (site, time)

The companion type for Fourier-space structure factors is ZZStructureFactor, kept separate because it carries (q, ω) arguments instead of (i, j, t).

ZZStructureFactor() <: AbstractQuantity

Fourier-space structure factor S_zz(q, ω) = ∫ dt e^{iωt} (1/N) Σ_{ij} e^{iq·(i-j)} ⟨σᶻ_i(t)σᶻ_j(0)⟩ (or its static limit, depending on the model's fetch signature).

Kept as a separate type from ZZCorrelation because the argument domain is (q, ω) instead of (i, j, t) and because existing users already expect a dedicated StructureFactor quantity.

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.

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

Trait declaring which granularity the given model returns natively for Energy at boundary condition bc. Used by the Energy() (:natural) router and by the generic conversion fallbacks.

Every model that supports Energy must add a method per supported BC, e.g.

QAtlas.native_energy_granularity(::TFIM, ::OBC) = :total
QAtlas.native_energy_granularity(::TFIM, ::Infinite) = :per_site

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.

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.

GrowthExponents() <: AbstractQuantity

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

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:

QAtlas.fetch(Universality(:Ising), CriticalExponents(); d=2)   # exact Rational
QAtlas.fetch(Universality(:Ising), CriticalExponents(); d=3)   # numerical + _err
QAtlas.fetch(Universality(:Ising), CriticalExponents(); d=4)   # mean-field

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