Repository navigation
12 Glossary
Alex Flom edited this page May 23, 2026
·
39 revisions
This chapter defines terms used throughout the wiki. Entries are
alphabetical. Identifiers (in monospace) refer to specific code
artifacts in uor-foundation, prism, or prism-verify; coined terms
(in italics on first reference) are normative concepts this wiki
defines.
| Term | Definition |
|---|---|
| Application author | A person or team that authors a Rust crate which imports prism, builds it through the Rust toolchain, and distributes the resulting executable. One of the three external actors at Prism’s Level 1 system boundary (section 3). |
| Application user | A person who runs the application author’s executable on local hardware and, optionally, verifies its produced outputs locally by invoking prism-verify. May be the same person as the application author. One of the three external actors at Prism’s Level 1 system boundary (section 3). |
| Anamorphism | The unique morphism into a final coalgebra of an endofunctor — categorically dual to the catamorphism. In Prism, the replay surface — Grounded::derivation().replay() produces the trace, and prism-verify::certify_from_trace consumes it — is the anamorphism dual to pipeline::run's catamorphism: it walks the trace’s typed derivation steps to reconstruct a Certified<GroundingCertificate> without re-evaluating the application author’s deciders (section 8, Foundation as a Signature Category; ADR-019; constraint TC-05). The anamorphism’s domain is Grounded<Output>; its codomain is Certified<GroundingCertificate> rather than Input — certifying provenance, not inverting the catamorphism. |
axis! |
An SDK macro (ADR-030) for declaring a substrate-extension axis in a Layer-3 crate. Takes a closure-bodied form analogous to verb!: the body is a Rust trait declaration with kernel methods, bounded on AxisExtension. The macro emits the trait, the __sdk_seal::Sealed impl, the AxisExtension blanket impl, the AXIS_ADDRESS content-address const, the per-method KERNEL_<NAME> consts, and the AxisDispatch blanket impl that the catamorphism calls. Per ADR-055’s universal substrate-Term verb body discipline, the macro additionally requires a normative body clause carrying the kernel’s substrate-Term composition (a verb!-style Term composition over PrimitiveOp s and prism operators) and emits the corresponding SubstrateTermBody impl alongside AxisExtension. The closure check at the axis! invocation verifies the trait’s bounds satisfy AxisExtension's contract (sealed, deterministic, #![no_std]-clean, output-bounded, and substrate-Term-decomposable via SubstrateTermBody per ADR-055); axis declarations lacking a body clause fail to satisfy the supertrait bound and fail to compile. Parallel to verb! for verbs and to output_shape! for custom Output shapes; the universal substrate-extension declaration mechanism for the framework’s Layer-3 implementation closure. |
AxisExtension |
A foundation-defined sealed marker trait (ADR-030, amended by ADR-055) that every axis trait declared via the axis! macro extends. The AxisExtension trait’s bounds (sealed via __sdk_seal::Sealed, deterministic per fixed impl, #![no_std]-clean, output-bounded — pre-0.5.0 by AXIS_OUTPUT_BYTES_MAX, post-ADR-060 the axis kernel emits a TermValue (Inline of foundation-derived width, Borrowed, or Stream) with no separate byte-width ceiling — and substrate-Term-decomposable via the SubstrateTermBody sealed supertrait bound per ADR-055) are the foundation-vetted contract every axis impl must satisfy. The SubstrateTermBody supertrait is the architectural mechanism that makes fold-fusion’s structural reach universal across every axis surface — the catamorphism’s Term::AxisInvocation fold-rule per ADR-029 recursively folds the axis impl’s body_arena() static Term slice rather than calling an opaque kernel function. Applications never impl AxisExtension directly; the axis! macro emits the impl as a blanket impl on the application-declared axis trait, with the SubstrateTermBody impl emitted alongside. The trait’s role parallels FoundationClosed for routes and GroundedShape for Output shapes — a foundation-vetted, sealed marker that gates which types qualify for the architectural role. |
AxisTuple |
A foundation-defined trait (ADR-030) impl’d for tuple types up to a foundation-vetted impl-table arity cap (MAX_AXIS_TUPLE_ARITY per ADR-037 clause (2); Rust-language carve-out from ADR-018), carrying the dispatch surface for the catamorphism’s evaluation of Term::AxisInvocation. The trait’s dispatch(axis_index, kernel_id, inputs) method routes to the right axis impl’s kernel based on the axis_index (position in the tuple) and the kernel_id (method on the axis trait). PrismModel’s third substrate parameter is A: AxisTuple + Hasher per ADR-030 + ADR-036 (the + Hasher bound makes the canonical hash axis reachable type-associatedly via <A as Hasher>::initial()). Static dispatch through monomorphization at the model’s compile time. |
AXIS_ADDRESS |
A pub const ContentAddress emitted by the axis! macro per axis trait declaration (ADR-030), content-derived from the trait’s name + method signatures + bounds via the foundation’s content-addressing per ADR-017. The content-address is the structural identity of the axis trait — two crates declaring structurally-identical axes (same trait name in the structural sense, same method signatures, same bounds) emit the same AXIS_ADDRESS; structurally-different axes emit different addresses. Standard-library inclusion (per ADR-031) is about who maintains the canonical reference for an axis, not about who owns the address namespace. |
bridge |
A component within uor-foundation (section 5, Level 2). Hosts the author-implemented trait surface (ConstrainedTypeShape, Grounding, the observable surface) and the wire-format type definitions (certificate types, trace types, resolver façades). The wire-format type definitions are data definitions consumed by prism (which produces values of these types) and prism-verify (which re-exports them for the user). |
| Building block | The arc42 term for a unit at any level of the static-structure hierarchy: at Level 1, a system; at Level 2, a contained black box (in C4 terms, a container); at Level 3, a component within a container. Section 5 specifies Prism’s building blocks at all three levels. |
| Canonical k-invariants branch | The architectural commitment per ADR-035 that the canonical ψ-pipeline composition for the framework’s verifiability commitment is ψ_1 (Nerve) → ψ_7 (PostnikovTower) → ψ_8 (HomotopyGroups) → ψ_9 (KInvariants). The k-invariants κ_k are the universal classifying invariants of the Postnikov tower per homology:KInvariant; they classify the homotopy type up to weak equivalence — the maximum-discriminating structural invariant in the ψ-chain. Two values are computationally equivalent per ADR-001 + ADR-019 iff their k-invariants match. Narrower invariants (Betti numbers, homology groups, cohomology groups, homotopy groups alone) are strictly weaker; the canonical compiled form produces the maximum-discriminating witness with the minimum number of resolver-bound stages (four: ψ_1, ψ_7, ψ_8, ψ_9). |
| Canonical UOR-address mapping | A coined term naming the architectural property (ADR-017) that a prism standard library type’s UOR IRI is content-deterministic in its constraint declaration. Two applications using the same standard type produce values with the same UOR IRI. The standard library is the canonical addressing surface for common shapes; closure under uor-foundation (ADR-013) is what makes the canonicality hold derivatively rather than via a claimed namespace. |
CartesianProductShape |
A marker trait defined in uor-foundation whose implementations identify types as Cartesian-partition products A ⊠ B. Emitted by the cartesian_product_shape! proc-macro in uor-foundation's internal proc-macro sub-crate; emissions land in author crates. |
| Catamorphism | The unique F-algebra homomorphism from an initial algebra of an endofunctor F into any other F-algebra. In Prism, pipeline::run is the catamorphism into the runtime carrier: the unique map from Term (F’s initial algebra) to a Grounded<T>, induced by initiality and determined entirely by the term’s structure and the runtime carrier’s operations. The Trace is the anamorphism’s witness, recoverable from Grounded<T> via derivation().replay(); it is not part of the catamorphism’s codomain. F is enriched (binding, well-founded recursion, unfold, failure-promote); "F-algebra homomorphism" in the Prism instantiation means the structure-preserving map in this enriched sense (see section 8, Foundation as a Signature Category, Signature Endofunctor). (Section 8, Foundation as a Signature Category; ADR-019.) |
| Categorical X regime split | A coined term (ADR-025) referring to the n_bits=4 transition in the gauge-tower endomorphism family after_op for op ∈ Γ where Γ = {Add, Sub, Mul, Div, Mod, Pow} per ADR-053’s substrate-catalog extension — the six ring-axis primitives on Z/(2^n)Z. Below the threshold (n_bits < 4), the address space cannot host the T=3 triality cycle and the emission rule is a "bit-0 star" with popcount-2 AffineK couplings. At and above the threshold (n_bits ≥ 4), bits {0,1,2} close the triality cycle and the bit-1 anchor establishes; the emission rule routes cross-bit couplings through the anchor as popcount-3 AffineK. The constants T=3 (triality dimension) and O=8 (Hurwitz bound for normed division algebras) are theorem-grounded and inherited from the algebraic structure of the gauge tower; the derived constant pent = O − T = 5 is the first width past the triality cycle with the anchor established. The arithmetic-tower endomorphism rules at any HostBounds selection MUST exhibit the regime split. Per ADR-050, the endomorphism family evaluates at the full Witt tower (TERM_VALUE_MAX_BYTES-bounded widths) with width = max(operand widths) for binary ops; the regime split’s structural commitment holds at every Witt level the host bounds admit. |
Certificate |
A data-definition type defined in uor-foundation's bridge::cert component representing a certificate value. Wraps CertificateKind and a sequence of ContentAddress references. Sealed inside Certified<C> (which is itself sealed in prism). Re-exported by prism-verify for the application user. |
| Certificate | A coined term referring to the value carried inside a Certified<C>. The certificate is a structured statement that the principal data path was traversed and that the resulting Grounded<T> satisfies the system’s invariants. Certificates are produced once at mint time and are re-derivable from a trace plus the matching Hasher (constraint TC-05). |
CertificateKind |
A data-definition type defined in uor-foundation's bridge::cert component naming the discriminated variants of Certificate. Includes GroundingCertificate and variants for certificate-of-certificate composition. |
Certified<C> |
A sealed type in prism representing a value that has been certified by traversing the principal data path. The type parameter C is the certificate variant (e.g., GroundingCertificate). One of the three Prism-mechanism sealed types (the others are Validated and Grounded); sealed by pub(crate) constructors in prism's seal regime. No code outside prism can construct a Certified<C> value (constraint TC-02). Re-exported by prism-verify for the application user. |
certify_from_trace |
A function in prism's replay component (was previously hosted in uor-foundation::enforcement::replay; relocated to prism because it produces Certified, which is sealed in prism). Re-exported by prism-verify as the user-facing entry point. Takes a Trace and a Hasher; returns Certified<GroundingCertificate> or ReplayError. Calls no Hasher invocation and no decider invocation (constraint TC-05). |
| Closure (across layers) | A coined term naming the architectural property (ADR-024) that the framework has three layers of algebraic closure — substrate, prism, implementation — each with its own operator set and closure check, with operators at each layer taking operands from the layer below. Substrate closure subsumes ADR-013’s closure commitment (the type-and-operation half) and ADR-025’s substrate operator set (the operator half). Prism closure is specified by ADR-026’s operator set. Implementation closure is the verb-pattern commitment from ADR-024 (verbs declared via the verb! SDK macro; acyclicity through non-recurse operators; cross-implementation imports through the use_verbs! macro). |
| Closure (prism) | A coined term naming the architectural property (ADR-024, ADR-026) that every route reachable at prism level decomposes under the prism operator set (compose, parallel_compose, fold_n, tree_fold, first_admit, partition_product, partition_coproduct) into substrate-closed primitives. The closure check is performed at the application’s compile time by the prism_model! macro’s FoundationClosed impl emission (ADR-020, ADR-022 D1). |
| Closure (substrate) | A coined term naming the architectural property (ADR-024, ADR-025) that every algebra reachable at substrate level decomposes under the substrate operator set (× partition_product, + partition_coproduct, after_op for op ∈ Γ) into irreducibles drawn from foundation’s primitive vocabulary. The PT_1 disambiguator distinguishes ×-decomposable algebras from Betti-additive irreducibles. The catalog and transition tables at any committed snapshot are conformance test vectors for substrate closure’s predictions. |
Closure (under uor-foundation) |
A coined term naming the architectural property (ADR-013) that every type prism exposes is derived from uor-foundation's type-declaration vocabulary, and every operation declaration prism's vocabulary admits composes uor-foundation::PrimitiveOp discriminants. prism introduces no primitive types or primitive operations of its own; the substrate’s vocabulary is the full primitive vocabulary of any conforming Prism implementation. |
compose |
A prism-layer operator (ADR-026) that performs sequential function composition. Takes two routes f: A → B and g: B → C and produces a route A → C. Lowers via sub-tree substitution at the macro’s expansion time. The closure-body grammar G12 (ADR-026’s extension of ADR-022 D3) recognizes compose as nested function-call expressions: f(g(input)) lowers to compose(f, g) applied to input. |
CompileUnitBuilder |
A type provided through prism's vocabulary that the principal data path uses to produce a Validated<CompileUnit, Phase> from input data. Called from inside the principal data path (in prism's pipeline) after Datum admission. One of the gated steps along the principal data path (constraint TC-03). |
ConstrainedTypeShape |
A trait defined in uor-foundation that the application author implements (typically through the shape proc-macros in uor-foundation's internal proc-macro sub-crate, reached through prism's vocabulary re-exports) to specify the structural constraints of the data their application accepts. Carries associated consts IRI, SITE_COUNT, CONSTRAINTS, and (per ADR-032) CYCLE_SIZE: u64 (the cardinality of the shape’s value-set, consumed by the SDK proc-macro at expansion time when emitting first_admit's measure literal per ADR-026 G16). The implementation is part of the application author’s input to Prism (section 3). The bound that any ConstrainedTypeShape impl MUST satisfy is declared by prism. |
ConstraintRef |
A discriminated-union type defined in uor-foundation whose variants name the kinds of constraint a ConstrainedTypeShape impl may declare (Residue, Hamming, Depth, Carry, Site, Affine, SatClauses, Bound, Conjunction, Recurse per ADR-057). The Recurse variant carries a (shape_iri, descent_bound) pair referencing another ConstrainedTypeShape by content-addressed IRI; ψ_1 NerveResolver resolves the reference at evaluation time through the foundation shape-IRI registry, unrolling the referenced shape’s CONSTRAINTS up to the descent budget. Trace events of variant Validated carry sequences of ConstraintRef values; verifier structural validation confirms each is in the catalog. |
| Container | The C4 model term for a Level 2 building block — an independently deployable or executable unit within a software system. Prism’s three containers are uor-foundation, prism, and prism-verify (section 5.1). |
ContentAddress |
A data-definition type defined in uor-foundation's bridge::cert component pairing a ContentFingerprint with the hasher_identifier that produced it. Used inside certificates to disambiguate addresses across hasher selections. |
ContentFingerprint |
A data-definition type defined in uor-foundation's bridge::cert component. The substitution-axis-substituted content address. Its byte width is the byte-width range carried by the application’s selected HostBounds; the substituted Hasher selects the actual width within that range (section 8, Hashing Substrate Contract). |
CYCLE_SIZE |
An associated const on ConstrainedTypeShape (ADR-032), u64-typed, declaring the cardinality of the shape’s value-set: the number of distinct byte-sequences the shape admits per its (SITE_COUNT, CONSTRAINTS) declaration. For Witt-level shapes, CYCLE_SIZE = 2^WITT_LEVEL_BITS (e.g., W32::CYCLE_SIZE = 4294967296). For product shapes, CYCLE_SIZE is the saturating-product of factors' CYCLE_SIZEs. For coproduct shapes, CYCLE_SIZE is the saturating-sum of variants' CYCLE_SIZEs plus 1 for the discriminator. For shapes whose CONSTRAINTS array contains a ConstraintRef::Recurse reference per ADR-057, CYCLE_SIZE saturates at u64::MAX per the discrete-clock saturation semantics — application authors do not compute a precise CYCLE_SIZE for recursive shapes; the saturated value is structurally derived from the presence of a Recurse constraint. The SDK proc-macro reads CYCLE_SIZE at expansion time when emitting first_admit's measure literal per ADR-026 G16, emitting Term::Literal { value: CYCLE_SIZE, level: <smallest WittLevel that fits> } per the wiki’s existing G1 commitment to literals parseable as u64. The implementation-runtime override per ADR-026 G16’s three-way split sanctions runtime strategy selection, not structural-correctness gaps. |
Datum |
A sealed type in uor-foundation representing a host-byte input that has been admitted to the principal data path. One of the four UOR-domain sealed types (the others are Triad, Derivation, FreeRank); sealed by pub(crate) constructors in uor-foundation's enforcement. No code outside uor-foundation can construct a Datum value directly; cross-crate construction goes through uor-foundation's mint_datum mint primitive, which the architectural commitment in ADR-016 reserves for prism's pipeline (constraint TC-02). |
| Decider | A coined term referring to the algorithms the principal data path invokes (in prism's pipeline and, indirectly, in the author’s ConstrainedTypeShape/Grounding impls) to determine whether a candidate input satisfies the constraints declared by a ConstrainedTypeShape impl. Constraint TC-05 requires the verifier never to invoke the deciders; the verifier instead walks the Trace produced when the deciders ran originally. |
Derivation |
A sealed type in uor-foundation. One of the four UOR-domain sealed types. Represents a complete term-rewriting witness — the full sequence of rewrite steps transforming an original term into its canonical form — associated with a Grounded<T> value. Constructed via the mint_derivation mint primitive. The trace produced by pipeline::run is obtained as grounded.derivation().replay(). |
| Distribution channel | The mechanism by which the application author’s executable reaches the application user. Prism is silent on the mechanism (ADR-004). The distribution channel is acknowledged in section 3’s prose but does not appear as an actor in the Level 1 system context. |
enforcement |
A component within uor-foundation (section 5, Level 2). Contains the crate-internal pub(crate) constructors for the four UOR-domain sealed types (Datum, Triad, Derivation, FreeRank) and sub-modules resolver, calibrations, transcendentals, and combinators (UOR-domain composition only). The cross-crate construction surface for these four types is the separate mint primitives component. (Replay machinery relocated to prism's replay component, since it produces Certified — which is sealed in prism.) |
| F-algebra | A coined term referring to an algebra over an endofunctor F: a carrier (a type, in Prism’s instantiation) together with operations whose signature matches F’s. In Prism, a PrismModel's Route associated type is an F-algebra over the signature endofunctor; the runtime carrier pipeline::run evaluates routes against is an F-algebra; sealing’s per-stage typed transitions are F-algebra structure. The category-theoretic name for the structure that ADR-013’s closure property satisfies (section 8, Foundation as a Signature Category; ADR-019). |
first_admit |
A prism-layer operator (ADR-026) that performs first-admission search over a parametric finite ring. Takes a domain (a HostBounds-derivable finite ring — typically a WittLevel-indexed ring or a partition-product / partition-coproduct of such rings) and a predicate; produces either the first admitting index in canonical successor order or a typed exhaustion failure. The macro lowers first_admit to Term::FirstAdmit { domain_size_index, predicate_index } per ADR-034 (the lowering target shifted from Term::Recurse to the dedicated variant for structural short-circuit on first admission). The closure-body grammar G16 (ADR-026’s extension of ADR-022 D3) recognizes ++first_admit(<domain_type>, |
| <idx_ident> | <predicate_body>)++. |
FIRST_ADMIT_IDX_NAME_INDEX |
A foundation-fixed u32 name index (per ADR-034) that binds to a TermValue carrying the current candidate index (idx) inside the predicate body of an enclosing Term::FirstAdmit evaluation. The catamorphism resolves Term::Variable { name_index: FIRST_ADMIT_IDX_NAME_INDEX } references in the predicate body to this binding per ADR-029’s per-variant fold-rule for Term::FirstAdmit. Parallels RECURSE_IDX_NAME_INDEX (the iteration-counter binding for Term::Recurse) and the recursive/unfold placeholder constants. The numeric value is a foundation parameter (e.g., u32::MAX - 4). |
| Fixed point | The value to which an iterated endofunctor application converges. In Prism, the four UOR-domain sealed types and the three Prism-mechanism sealed types are fixed points of the typed pipeline endofunctor — least fixed points (denoted μ) for stage outputs that admit construction, greatest fixed points (denoted ν) where co-induction over the trace structure applies. The pipeline endofunctor is distinct from the signature endofunctor F; the signature endofunctor structures the term language (with Term as its initial algebra), while the pipeline endofunctor structures the typed sequence the catamorphism produces. Sealing (TC-02, ADR-011) is the type-system enforcement that no path other than the catamorphism reaches these fixed points (section 8, Foundation as a Signature Category; ADR-019). |
fold_n |
A prism-layer operator (ADR-026) that performs bounded linear iteration. Takes a compile-time-known iteration count n (const literal, substitution-axis-derived constant, or route-parameter), an initial state, and a step closure binding the current state and the iteration index. Lowers to either an unrolled Term::Application chain (for n at or below <B as HostBounds>::FOLD_UNROLL_THRESHOLD per ADR-037) or Term::Recurse with descent measure n − idx (for n above the threshold or parametric). The closure-body grammar G14 (ADR-026’s extension of ADR-022 D3) recognizes ++fold_n(<count_expr>, <init_expr>, |
| state, idx | <step_body>)++. |
| Fold-rule | A coined term naming the per-variant evaluation rule the catamorphism (per ADR-019 + ADR-029) applies to each Term variant during the structural fold. Each of the twenty-one Term variants per ADR-022 D3 + ADR-029 + ADR-030 + ADR-033 + ADR-034 + ADR-035 has a corresponding fold-rule that determines how that variant’s evaluation contributes to the catamorphism’s structure-preserving morphism into the runtime carrier. Substrate-primitive fold-rules (the 18 PrimitiveOp discriminants per ADR-053 evaluated through Term::Application's fold-rule) operate on byte buffers directly per ADR-050’s width-parametric discipline. The fold-rules compose universally per ADR-019’s initial-algebra property — the catamorphism IS the fusion of all per-variant fold-rules into one structure-preserving map per ADR-054’s Fold-Fusion Principle. Foundation’s pipeline::run_route is the realization of the composed fold-rules at the type-parameter selection <H, B, A, M, R, C> per ADR-022 D5 + ADR-036 + ADR-048. |
| Fold-Fusion Principle | The architectural commitment per ADR-054 that every prism transformation is a folding operation and the catamorphism fuses composed folds by universal property into a single structure-preserving morphism into the runtime carrier. Three fusion layers realize the principle: (i) macro-expansion fusion — verb-call sites lower to Term subtrees at proc-macro expansion per ADR-024; the verb-call walker is absent at run time. (ii) Catamorphism fusion — the per-variant fold-rules per ADR-029 compose universally per ADR-019’s initial-algebra property; the catamorphism IS the fusion of all per-variant fold-rules into one structure-preserving map. (iii) Monomorphization fusion — the per-substitution-axis-selection Rust routine has no dynamic dispatch and no allocation per TC-01; LLVM inlining collapses per-variant dispatch with fold-rule bodies into straight-line code. The principle is closed under composition: any expression in the prism vocabulary (verb-call, prism_model body, verb-of-verbs, verb-composing-an-axis) compiles to a fused fold by structural induction over the Term language. The principle’s standard-library realization per ADR-054 + ADR-031 is the canonical axis impl body discipline — every published canonical axis impl carries a substrate-Term verb body, so the catamorphism’s structural reach has no opaque axis-kernel boundary inside the published canonical surface. The principle is the structural mechanism upholding the Conceptual Model’s C2 (zero runtime movement) commitment. |
| Folding-transformation | A coined term (ADR-053) naming the principle that distinguishes substrate PrimitiveOp primitives from compound verbs per ADR-024: a folding-transformation is an operation whose body is structurally elementary (a carry-based byte-level or bit-position fold) and whose fold is fused into a single Term variant — the catamorphism evaluates it through one Term::Application per ADR-029 with a single per-variant fold-rule. A named composition of multiple Term variants (e.g., square-and-multiply expressed as Recurse + Mul + Ge + Sub body terms) is a verb per ADR-024, not a substrate primitive. The principle is structural-fusion, not derivability: Add could be decomposed via byte-level Succ iteration but is a substrate primitive because the fold fuses into one PrimitiveOp::Add fold-rule. ADR-053 applies the principle to admit Div, Mod, Pow as substrate primitives — each is a folding-transformation (binary long division; binary long division-companion; square-and-multiply) fused into a single fold-rule. Compound operations (modexp_p, gcd, ext_euclidean, horner, newton_step) remain verbs because they ARE multiple folding-transformations sequenced. The Fold-Fusion Principle per ADR-054 generalizes this distinction to every layer of composition: substrate primitives, verbs, prism operators, axis-impl bodies all reduce to fold compositions the catamorphism fuses universally. |
FoundationClosed |
A trait defined in prism whose impls witness that a type-level Route encoding ranges entirely over foundation-vocabulary items and expose the route's term-tree slice. The trait carries one method, fn arena_slice() → &'static , returning the route's term tree as a static slice for pipeline::run_route to read (ADR-022 D6). The prism_model! proc-macro emits an impl of this trait for a route witness if and only if every node in the witnessed term tree is a foundation-vocabulary item; the trait bound on Route in PrismModel is the type-level expression of the closure-under-foundation-vocabulary commitment (ADR-013, ADR-020). Checked at the application’s compile time by UORassembly (TC-04, ADR-006). The trait is sealed via the standard ecosystem idiom #[doc(hidden)] pub mod __sdk_seal { pub trait Sealed {} } in prism — the supertrait Sealed is namespaced inside a doc-hidden public module so the SDK proc-macro can emit impl Sealed for <RouteWitness> while external crates that name the module are flagged as architecturally non-conforming (ADR-022, D1). |
FreeRank |
A sealed type in uor-foundation. One of the four UOR-domain sealed types. Tracks the deficit of unresolved sites in the principal data path’s partition algebra: the count of free sites that have not yet been closed by resolution. Decreases monotonically as resolution progresses through the pipeline stages. Constructed via the mint_freerank mint primitive. ADR-043’s iterative-resolution discipline (resolver-internal computational pattern for resolver-bound ψ-stages with bounded-search inhabitance enumeration) reads FreeRank as the count of unpinned sites in a resolver’s working state; convergence is FreeRank = 0. |
| G20 | The closure-body grammar form for field-access projection on product-of-shapes inputs (per ADR-033). Recognized as <expr>.<name> or <expr>.<index> when <expr> has a statically-inferable shape that is a partition_product (or a chain of products for nested access). Lowers to Term::ProjectField with source_index set to the receiver’s Term arena index and byte_offset / byte_length set to proc-macro-computed values from the receiver shape’s structural metadata. Named-field access requires the product shape to be declared with the named-tuple partition_product!(Name, field1: A, field2: B) form per ADR-033’s extended partition_product! macro. Positional-field access works on the existing positional partition_product!(Name, A, B) form. |
| G21 | The closure-body grammar form for ψ_1 nerve construction (per ADR-035). Recognized as nerve(<value_expr>) where <value_expr> evaluates to a per-value byte sequence (the value whose constraint nerve is being constructed). Lowers to Term::Nerve { value_index }. Receiver-shape check: byte-shaped. Resolver-bound (consults the ResolverTuple’s NerveResolver<H> per ADR-036; the NerveResolver encodes the application’s "what constraints does this value induce?" semantics — the constraint nerve is per-value, not value-independent). Reserved macro-vocabulary identifier: nerve. |
| G22 | The closure-body grammar form for ψ_2 chain-complex construction (per ADR-035). Recognized as chain_complex(<simplicial_expr>). Lowers to Term::ChainComplex. Receiver-shape check: simplicial-complex-shaped. Resolver-bound (ChainComplexResolver per ADR-036). Reserved macro-vocabulary identifier: chain_complex. |
| G23 | The closure-body grammar form for ψ_3 homology-groups extraction (per ADR-035). Recognized as homology_groups(<chain_expr>). Lowers to Term::HomologyGroups. Receiver-shape check: chain-complex-shaped. Resolver-bound (HomologyGroupResolver per ADR-036). Reserved macro-vocabulary identifier: homology_groups. |
| G24 | The closure-body grammar form for ψ_4 Betti-number extraction (per ADR-035). Recognized as betti(<homology_expr>). Lowers to Term::Betti. Receiver-shape check: homology-groups-shaped. Resolver-free (pure computation on already-resolved homology groups). Reserved macro-vocabulary identifier: betti. |
| G25 | The closure-body grammar form for ψ_5 cochain-complex dualization (per ADR-035). Recognized as cochain_complex(<chain_expr>). Lowers to Term::CochainComplex. Receiver-shape check: chain-complex-shaped. Resolver-bound (CochainComplexResolver per ADR-036). Reserved macro-vocabulary identifier: cochain_complex. |
| G26 | The closure-body grammar form for ψ_6 cohomology-groups extraction (per ADR-035). Recognized as cohomology_groups(<cochain_expr>). Lowers to Term::CohomologyGroups. Receiver-shape check: cochain-complex-shaped. Resolver-bound (CohomologyGroupResolver per ADR-036). Reserved macro-vocabulary identifier: cohomology_groups. |
| G27 | The closure-body grammar form for ψ_7 Postnikov truncation (per ADR-035). Recognized as postnikov_tower(<simplicial_expr>). Lowers to Term::PostnikovTower { simplicial_index }. Receiver-shape check: simplicial-complex-shaped (typically a Term::Nerve emission). Resolver-bound (PostnikovResolver<H> per ADR-036; the PostnikovResolver performs Kan-completion per the homology namespace’s KanComplex / HornFiller surface as part of its resolve semantics, then computes the truncation tower per ψ_7’s identity; verb authors do not construct KanComplex values explicitly). Reserved macro-vocabulary identifier: postnikov_tower. |
| G28 | The closure-body grammar form for ψ_8 homotopy-groups extraction (per ADR-035). Recognized as homotopy_groups(<postnikov_expr>). Lowers to Term::HomotopyGroups. Receiver-shape check: Postnikov-tower-shaped. Resolver-bound (HomotopyGroupResolver per ADR-036). Reserved macro-vocabulary identifier: homotopy_groups. |
| G29 | The closure-body grammar form for ψ_9 k-invariant computation (per ADR-035). Recognized as k_invariants(<homotopy_expr>). Lowers to Term::KInvariants. Receiver-shape check: homotopy-groups-shaped. Resolver-bound (KInvariantResolver per ADR-036). Reserved macro-vocabulary identifier: k_invariants. The grammar’s complete enumeration is now G1-G29. |
Gauge-tower arithmetic operator set (Γ) |
The ring-axis arithmetic operator set per ADR-025 + ADR-053: Γ = {Add, Sub, Mul, Div, Mod, Pow} — the six ring-axis primitives on Z/(2^n)Z covered by the Categorical X regime split (ADR-025) and the folding-transformation fold-rule discipline (ADR-053). The hypercube-axis operations (Xor, And, Or, Bnot) are PrimitiveOps but are not in Γ — they form the separate metric-dual family per the MetricAxis enum; the Categorical X theorem framework is grounded in normed-division-algebra structure that does not extend to hypercube operations. Substrate-level endomorphism operators after_op are defined for op ∈ Γ only; hypercube operations remain reachable as Term::Application operators at the term-language level (G3 in the closure-body grammar) but do not generate substrate-level endomorphism kinds. Per ADR-050, every primitive in Γ (and the hypercube-axis primitives) evaluates at the full Witt tower with width = max(operand widths) for binary ops; truncation to a u64 ceiling is non-conformant. |
Grounded<T> |
A sealed type in prism representing a value that is the result of pipeline::run on a Validated<CompileUnit, Phase>. The type parameter T is the application-specific shape. One of the three Prism-mechanism sealed types; sealed by pub(crate) constructors in prism's seal regime. Every Grounded<T> is accompanied by a Trace (constraint TC-05). |
Grounding |
A trait defined in uor-foundation that the application author implements to specify how host-byte input is interpreted as a candidate for the principal data path. Reached by author code through prism's vocabulary re-exports. |
GroundingCertificate |
The certificate variant produced when a Grounded<T> is materialized. The verifier’s successful output is Certified<GroundingCertificate>. The format is specified normatively in section 8. |
| Grounded::tag::<NewTag>() | A consuming method on Grounded<T, Tag> per ADR-045 that emits a Grounded<T, NewTag> with the requested NewTag binding. Zero-cost: the Tag parameter is a PhantomData<Tag> field; re-tagging is a structural rebinding with no payload duplication and no allocation. The method consumes self by value (the seal regime is preserved — the Grounded value is moved into the method and the returned value is the same sealed value with rebound Tag). The NewTag: Default bound is the only constraint. Applications use the affordance to surface domain-distinct typed witness types (pub type MyWitness = Grounded<MyOutput, MyAppTag>) in their public API without sacrificing the foundation-sealed regime. The seal-coverage chain per TC-02 + ADR-016 is preserved — re-tagging is a sealed method on Grounded, not a construction path; every Grounded reachable in application code descends from a catamorphism emission regardless of how many times its Tag parameter has been rebound. |
GroundedShape |
A trait defined in uor-foundation whose impls witness that a ConstrainedTypeShape may appear as T in Grounded<T> (i.e., as a PrismModel::Output). The trait is sealed via the standard __sdk_seal::Sealed pattern. The foundation-sanctioned identity output ConstrainedTypeInput carries a direct impl; application-declared custom Output shapes obtain their GroundedShape impl through the output_shape! SDK macro (ADR-027), which emits ConstrainedTypeShape, Sealed, GroundedShape, and IntoBindingValue impls together. The seal is generalized (the path widens to any sanctioned-construction shape), not lifted (external direct impls remain blocked). |
Hasher |
Originally (ADR-007) a trait defined in uor-foundation providing the substitution-axis-realized content-addressing function used at mint time. Per ADR-030 + ADR-031, the trait is now declared by the prism-crypto standard-library sub-crate as HashAxis — one axis among many declared via the axis! SDK macro — and the substitution-axis triple’s third position becomes a tuple A: AxisTuple of axis-trait selections. Per ADR-036, the third-position bound strengthens to A: AxisTuple + Hasher: the canonical hash axis is carried as a trait bound on the AxisTuple itself so resolver-bound substrate operations parameterized by H: Hasher (the eight ψ-chain resolver traits per ADR-035) can consume the model’s canonical hash axis type-associatedly via <A as Hasher>::initial(). The bound that any HashAxis impl MUST satisfy is declared by prism-crypto (the canonical reference for the axis); foundation’s AxisExtension trait family (sealed, deterministic, #![no_std]-clean, output-bounded) is the meta-bound. The selected hash impl is identified to the application user out-of-band, alongside the trace; the trace alone does not name its hasher (constraint TC-05). |
| Host bytes | The runtime input the application author’s executable processes. Host bytes enter the principal data path through Grounding and become a Datum (via uor-foundation's mint_datum mint primitive). |
HostBounds |
A trait defined in uor-foundation carrying every capacity bound that varies along the principal data path. Post-ADR-060, HostBounds carries 14 associated constants: the fingerprint output width range (FINGERPRINT_MIN_BYTES, FINGERPRINT_MAX_BYTES), the algebraic-level bit-width ceiling (WITT_LEVEL_MAX_BITS), the trace event-count ceiling (TRACE_MAX_EVENTS), the catamorphism/trace bounds (FOLD_UNROLL_THRESHOLD, RECURSION_TRACE_DEPTH_MAX, OP_CHAIN_DEPTH_MAX, UNFOLD_ITERATIONS_MAX), and the structural-element counts (BETTI_DIMENSION_MAX, NERVE_CONSTRAINTS_MAX, NERVE_SITES_MAX, JACOBIAN_SITES_MAX, AFFINE_COEFFS_MAX, CONJUNCTION_TERMS_MAX). One of the three substitution axes (section 2). The architecture admits no capacity bound outside HostBounds (ADR-018); per ADR-060, byte-width carrier sizes are derived from these primitives by foundation const fn (carrier_inline_bytes::<B>() and the per-ψ-stage carrier derivations such as nerve_carrier_bytes::<B>()) rather than declared, so the 12 byte-width capacity constants ADR-037 had migrated are removed. The bound that any HostBounds impl MUST satisfy is declared by prism. There is no default — DefaultHostBounds is removed per ADR-060; every application declares its own impl HostBounds, so every capacity the foundation honors traces to an explicit application declaration. |
HostTypes |
A trait defined in uor-foundation parameterizing the host environment’s data representations. One of the three substitution axes (section 2). The default implementation is DefaultHostTypes. The bound that any HostTypes impl MUST satisfy is declared by prism. |
| Hylomorphism | The composition of a catamorphism with a recoverable anamorphism through a residue object that links the two directions. In Prism, PrismModel's forward direction is the catamorphism Input → Result<Grounded<Output>, PipelineFailure> (pipeline::run_route); the recoverable backward direction is the anamorphism Grounded<Output> → Trace → Certified<GroundingCertificate> (via derivation().replay() plus prism-verify::certify_from_trace); the trace is the residue object linking the two. The structure is a hylomorphism with verifiable round-trip — not a categorical iso (the backward direction certifies provenance rather than inverting the forward map) and not a categorical Prism optic (the trait’s name derives from the implementation crate’s name, not from the optic). Section 8, Anamorphism; ADR-019, ADR-020, ADR-021. |
| Impossibility witness | A coined term naming the structured value the principal data path returns when a candidate input does not satisfy the application author’s ConstrainedTypeShape constraints. The witness is sealed (constraint TC-02); it identifies the violated constraint and the position of the violation (section 8, Error Model). |
| Iterative-resolution discipline | The architectural commitment per ADR-043 specifying the resolver-internal computational pattern for resolver-bound ψ-stages whose typed-carrier transform requires bounded-search inhabitance enumeration. The discipline: (1) FreeRank protocol — the resolver tracks the count of unpinned sites and pins sites as predicate evaluations succeed; convergence is FreeRank = 0. (2) Bounded-domain enumeration — the resolver iterates candidate values over a ConstrainedTypeShape whose CYCLE_SIZE: u64 per ADR-032 is bounded. (3) Termination — Convergence emits the admitting carrier as the resolver’s typed output bytes (Ok(byte_count)); Exhaustion returns Err(ShapeViolation) carrying the canonical https://uor.foundation/proof/InhabitanceImpossibilityWitness shape IRI per ADR-039. (4) Host-boundary retry — on Exhaustion, the catamorphism propagates Err(PipelineFailure) to the application; the host boundary may vary the input outside the iterative-resolution domain and re-invoke forward(input). (5) Scope boundary — applies to resolver bodies; verb bodies are constrained per ADR-035’s ψ-residuals discipline. The catamorphism is one structural inference per invocation; retry is host-external, not catamorphism-internal. The discipline canonicalizes existing substrate constructs (resolver traits per ADR-036, typed carriers per ADR-041, ConstrainedTypeShape::CYCLE_SIZE per ADR-032, ConstraintRef::Bound per ADR-040, InhabitanceImpossibilityWitness per ADR-039) — it is not a substrate amendment. |
| Initial algebra | The "freest" F-algebra — the carrier from which a unique F-algebra homomorphism (the catamorphism) extends into any other F-algebra. In Prism, Term is the initial algebra of the signature endofunctor uor-foundation defines: any well-typed Term tree is an element of F’s free term language, and pipeline::run is the unique catamorphism into the runtime carrier (section 8, Foundation as a Signature Category; ADR-019). |
IntoBindingValue |
A trait defined in uor-foundation that any ConstrainedTypeShape used as a PrismModel::Input MUST implement. Carries one method, fn into_binding_bytes(&self, out: &mut [u8]) → Result<usize, ShapeViolation>, plus an associated constant MAX_BYTES: usize bounding the byte sequence’s length. pipeline::run_route calls the method to serialize the input value into the CompileUnit's transient binding-table entry for Term::Variable { name_index: 0 } (the route’s input parameter, per ADR-023). Sealed via the same __sdk_seal::Sealed supertrait as FoundationClosed and PrismModel; the SDK shape-construction macros (product_shape!, coproduct_shape!, cartesian_product_shape!, prism_model!) emit impls alongside the ConstrainedTypeShape impl. The foundation-sanctioned identity ConstrainedTypeInput implements the trait returning zero bytes (MAX_BYTES = 0). |
kernel |
A component within uor-foundation (section 5, Level 2). Contains the substitution-axis machinery: the HostTypes and HostBounds trait definitions; the address, carry, convergence, and operad algebras the principal data path uses. The convergence algebra is the kernel::convergence namespace — the Hopf convergence tower (see Hopf convergence tower). |
| Hopf convergence tower | The ontology-derived kernel::convergence namespace within the foundation’s kernel component (Space::Kernel; IRI https://uor.foundation/convergence/; UOR ontology Amendment 66 — 5 classes, 13 properties, 8 individuals). Declares four ConvergenceLevel<H> instances at division-algebra dimensions {1, 2, 4, 8} corresponding to the four normed division algebras R (dim 1, characteristic identity existence, Hopf fiber S⁰), C (dim 2, feedback, S¹), H (dim 4, choice, S³), O (dim 8, self-reference, S⁷); each ConvergenceLevel<H> carries algebra_dimension, betti_signature, fiber_type (a HopfFiber<H> with fiber_dimension / total_space / base_space / fiber_sphere), characteristic_identity, and level_name accessors. ConvergenceResidual<H> carries the persistent β_{2^k−1} = 1 Betti number that survives at each level (residual_betti, residual_dimension); CommutativeSubspace<H> selects the U(1) ⊂ SU(2) subspace at pairwise-interaction convergence (referencing a bridge::observable::Commutator<H>); AssociativeSubalgebra<H> selects the H ⊂ O subalgebra at triple-interaction convergence (referencing a bridge::interaction::AssociatorTriple<H>). The namespace is @generated from the UOR ontology and ships Null* resolver-absent baselines (NullConvergenceLevel<H>, etc.) per the foundation’s orphan-closure discipline. Per ADR-059, the tower is the operator-geometry-coordinate codomain stratification of κ-derivation per ADR-058: a canonical form’s level (R / C / H / O) is the algebra dimension at which its operator-geometry coordinates carry a normed-division-algebra structure, and descent O → H → C → R under compression pressure surrenders the characteristic identities in reverse order of acquisition (non-associativity first, existence last). |
| κ-derivation | Per ADR-058, the framework’s compression-to-canonical-form operator: the eight-resolver ψ-pipeline composed with the ψ_9 σ-projection per ADR-019 + ADR-035 + ADR-047. Its byte-sequence output is the κ-label — the minimum-information representation distinguishing the input within its constraint geometry’s typed-distinction surface (the pre-σ-projection ψ-stages monotonically reduce the unresolved-site count per ADR-043; the σ-projection emits the residual structural identity), unique under the fixed pipeline order per ADR-035. Cross-substrate compression universality is a closure property per TC-05 (binary, not statistical: a conforming substrate emits the byte-identical certificate; a non-conforming substrate fails closed at certify_from_trace). The codomain in operator-geometry coordinates is the Atlas image inside E₈ per ADR-059. See compression-to-canonical-form, closure-lossless taxonomy, Hopf convergence tower. |
| compression-to-canonical-form | The structural reading of κ-derivation committed by ADR-058. An identity claim, not a new substrate feature: minimum-information emission (the κ-label carries only the bits distinguishing the input within its constraint-geometry orbit) plus uniqueness-under-fixed-pipeline-order (two inputs emit byte-identical κ-labels iff computationally equivalent under closure under the identity catalogue per ADR-019 + ADR-024, with the converse under ADR-047’s U1–U6) are the defining properties of compression-to-canonical-form. The κ-derivation is this operator as the framework realizes it; a specific substrate’s compression behavior is the operator expressed in that substrate’s natural coordinates. |
| closure-lossless taxonomy | Per ADR-058, the three-tier equivalence structure between two outputs under the same PrismModel: T1 byte-identical (bit-equal byte sequences; identical ψ-stage traces under identical σ-projection axis selection per ADR-047); T2 κ-label-identical (the framework’s natural equivalence under κ-derivation, equivalent to TC-05 trace-replay equivalence — any conforming runtime emits the same Certified<GroundingCertificate> from either output’s trace); T3 outcome-coarse-equivalent (admits through the same C: TypedCommitment per ADR-048 even if κ-labels differ). The tiers form a strict chain T1 ⇒ T2 ⇒ T3; the reverse implications hold only under additional structural conditions. Supplies a typed equivalence vocabulary for application-level interoperability protocols where κ-label-identity is the structural-equivalence target. |
| operator-geometry coordinates | Per ADR-059, the natural-coordinate reading of κ-derivation’s codomain in which the Hopf convergence tower (kernel::convergence) is visible. The codomain in operator-geometry coordinates is the Atlas of Resonance Classes image inside E₈, stratified coarsely by the convergence-tower levels (R / C / H / O at algebra dimensions {1, 2, 4, 8}) and finely by the exceptional algebraic structures (G₂ / F₄ / E₆ / E₇ / E₈). Dual to the byte-coordinate reading carried by the κ-label: byte-coordinate identity implies operator-geometry-coordinate identity up to Weyl-orbit equivalence under fixed hash-axis selection per ADR-047, and conversely under the σ-projection hardening axioms. |
| Atlas of Resonance Classes | Per ADR-059, the universal object whose image inside E₈ is the codomain of κ-derivation in operator-geometry coordinates: a 96-vertex graph arising as the stationary configuration of an action functional on a 12,288-cell complex, the initial object in the category ResGraph. Every exceptional Lie group structure factors through it via categorical operations — G₂ via product (Klein × ℤ/3 → 12 roots), F₄ via quotient (96 / ± mirror → 48 sign classes), E₆ via filtration (→ 72 roots), E₇ via augmentation (→ 126 roots), E₈ via direct embedding (φ: Atlas ↪ E₈ injective, adjacency-preserving, → 240 roots; unique up to E₈ Weyl-group symmetry). ADR-059 is a conceptual-reading commitment; the Atlas / exceptional-structures code realization is application-level (a demand-driven Layer-3 sub-crate per ADR-031 or a sibling library), not part of uor-foundation. See ResGraph, operator-geometry coordinates. |
ResGraph |
Per ADR-059, the category of resonance graphs in which the Atlas of Resonance Classes is the initial object. Universal factorization through the Atlas is the categorical statement of cross-substrate codomain universality: every conforming compressor’s canonical-form codomain (every PrismModel admitting through κ-derivation per ADR-058) factors through the Atlas, so two conforming substrates compressing the same input land at the same Atlas-image position modulo Weyl-orbit equivalence. Joint with ADR-058, this makes cross-substrate convergence under compression a categorical theorem rather than an empirical regularity. |
| κ-label composition shapes | Per ADR-061 (prism-runtime-level), five ConstrainedTypeShape s in prism’s standard type library (per ADR-031) operationalizing the categorical operations on the Atlas image inside E₈ per ADR-059, each parametric over the component-label byte width: G2ProductShape<N> (the G₂ product — binary; SITE_COUNT = 2 × N), F4QuotientShape<N> (the F₄ mirror-symmetry quotient — unary; SITE_COUNT = N), E6FiltrationShape<N> (the E₆ degree-filtration — unary; SITE_COUNT = N + 1 — the filtration is structure-preserving, the canonical form retaining the operand bytes annotated with a one-byte degree-partition tag), E7AugmentationShape<N> (the E₇ S₄-orbit augmentation — unary; SITE_COUNT = N), and E8EmbeddingShape<N> (the E₈ direct embedding, the universal target — unary; SITE_COUNT = N). A composition of N component κ-labels under an operation is a typed-input value the existing ψ-pipeline consumes through the existing σ-projection; a content-addressing realization’s canonicalize verb emits the canonical form whose κ-label is the composed κ-label — itself a κ-label landing at an Atlas-image position, hence recursively composable (the content-addressable surface is closed under composition). Arity is fixed per shape by the operation’s algebra (G₂ binary; the rest unary); wider compositions iterate the primitive shapes via a ConstraintRef::Recurse tree per ADR-057, bounded by the Categorical X regime split’s T = 3 (arity, H-level) and O = 8 (depth, O-level) per ADR-025 + ADR-059. σ-axis substitutability per ADR-047 lifts to compositions with σ-axis homogeneity required within each composition (all operand κ-labels share the composition’s σ-axis; cross-σ-axis composition is not committed); cross-substrate universality per ADR-058 + ADR-059 lifts to compositions. No foundation or SDK change; the TypedCommitment (ADR-048) and ObservablePredicate (ADR-049) closed sets are retained. |
literal_u64 |
An SDK-emitted helper per ADR-051 that constructs a Term::Literal whose value carrier holds the big-endian encoding of value: u64 truncated/padded to match the declared WittLevel. Signature: uor_foundation_sdk::literal_u64(value: u64, level: WittLevel) → Term. Preserves the narrow-form construction surface authors had before ADR-051 widened the literal carrier from u64 — call sites using u64 literals route through this helper without rewriting; the helper guarantees the literal’s byte-length equals level.witt_length() / 8. Per ADR-060 the literal carrier is the source-polymorphic TermValue (Inline for the integer literal, whose width fits carrier_inline_bytes::<B>()); wide literals (widths > 64 bits, up to WITT_LEVEL_MAX_BITS) are constructed by directly populating the Inline carrier. |
MAX_AXIS_TUPLE_ARITY |
A foundation-vetted pub const usize (ADR-030; retained per ADR-037 clause (2)) bounding the number of axis trait selections in a model’s AxisTuple. Per ADR-037’s two-branch reconciliation, this is a type-system tuple-impl-table cap with explicit Rust-language carve-out from ADR-018: Rust’s lack of variadic generics requires per-arity AxisTuple blanket-impl emission at foundation’s build time; the emission set cannot be parametric on downstream applications' HostBounds impls. Foundation emits impls for tuples of arity 1 through this cap; applications declaring an AxisTuple of larger size are rejected at the type-system level. The cap is foundation-vetted, motivated by current standard-library Layer-3 sub-crate AxisTuple usages plus headroom; foundation revision adjusts the value when standard-library or application needs evolve. The Rust-language carve-out is explicit and bounded — when variadic generics stabilize, a future ADR may migrate this cap to the HostBounds-parametric discipline. |
| Mint primitive | A coined term naming the public functions in uor-foundation's mint primitives component (mint_datum, mint_triad, mint_derivation, mint_freerank, mint_product_witness, mint_coproduct_witness, mint_cartesian_witness) that take type-level-validated inputs and internally call the pub(crate) constructors of the four UOR-domain sealed types in enforcement. The mint primitives are the cross-crate construction surface for the four UOR-domain types; the architectural commitment of ADR-016 reserves prism's pipeline as the only sanctioned caller. |
mint_cartesian_witness |
A helper function emitted by the cartesian_product_shape! proc-macro alongside the ConstrainedTypeShape impl for a Cartesian-partition product. Lives in uor-foundation's internal proc-macro sub-crate; emissions land in author crates. Constructs the witness value the principal data path consumes when the application author’s code processes input of the declared shape. |
mint_coproduct_witness |
A helper function emitted by the coproduct_shape! proc-macro alongside the ConstrainedTypeShape impl for a sum type. Lives in uor-foundation's internal proc-macro sub-crate; emissions land in author crates. Constructs the witness value the principal data path consumes when the application author’s code processes input of the declared shape. |
mint_product_witness |
A helper function emitted by the product_shape! proc-macro alongside the ConstrainedTypeShape impl for a product type. Lives in uor-foundation's internal proc-macro sub-crate; emissions land in author crates. Constructs the witness value the principal data path consumes when the application author’s code processes input of the declared shape. |
| ψ-chain | The framework’s structural-witness arm of op:InferenceOperation per spec/src/namespaces/op.rs and spec/src/namespaces/homology.rs: nine ontology-defined identity maps (ψ_1..ψ_9) composing into a structural-correctness pipeline that witnesses the partition’s homology-class identities. ADR-035 commits a Term variant per ψ-map (Term::Nerve, Term::ChainComplex, Term::HomologyGroups, Term::Betti, Term::CochainComplex, Term::CohomologyGroups, Term::PostnikovTower, Term::HomotopyGroups, Term::KInvariants) — bringing the substrate’s Term enum to twenty-one variants — and names the k-invariants branch (ψ_1 → ψ_7 → ψ_8 → ψ_9) as the canonical composition for the framework’s verifiability commitment per ADR-001 + ADR-019. The ψ-chain is the dual of the ψ-pipeline (ψ_1..ψ_6, the resolution arm); both arms compose op:InferenceOperation (ι = P ∘ Π ∘ G). Verb bodies reach the ψ-chain through the closure-body grammar forms G21-G29; the eight resolver-bound stages (all but ψ_4 Betti) consult the model declaration’s R: ResolverTuple per ADR-036 for per-value content provision. |
| ψ-residuals discipline | The architectural commitment per ADR-035 that the route body’s typed-iso surface is pure-prism — admission is structural (a property of the value’s k-invariant signature per the canonical k-invariants branch), not search-based (a runtime predicate enumerated over a value-bytes domain). The following Term forms are ψ-residuals — the vocabulary of ψ-enumeration — and are forbidden in route-body syntactic emissions: Term::FirstAdmit per ADR-034 (ψ-enumeration over a counter domain), Term::AxisInvocation per ADR-030 (the canonical hash axis is consumed by axis impl bodies and resolvers, not by route-body terms), Term::Application with PrimitiveOp::Le/Lt/Ge/Gt (byte-comparison residuals of search-based admission), Term::Application with PrimitiveOp::Concat (byte-concatenation residuals of byte-shape-aware admission). Per ADR-056’s scope refinement, the discipline applies to the route body’s syntactic surface — the prism_model!-declared route closure body — NOT to compound verb bodies declared via verb! per ADR-024, axis impl bodies per ADR-055, or resolver bodies per ADR-046. Verbs and axis impls may use the full substrate vocabulary including ψ-residual constructs in their internal Term compositions; the catamorphism’s fold-fusion mechanism per ADR-054 inlines these bodies into the route’s evaluation while the route’s typed-iso surface stays structurally shaped. Canonical compound operations — SHA padding (Concat), HMAC (Concat), Merkle tree construction (Concat), tensor saturation (Le/Ge) — are valid substrate-Term verb bodies under ADR-055 + ADR-056. The SDK’s prism_model! macro walks the route closure body at proc-macro expansion and rejects ψ-residual syntactic forms; the verb! and axis! macros emit verb / axis bodies without applying the ψ-residuals walk. |
| ψ-chain resolver traits | A cluster of eight sealed resolver traits declared by foundation per ADR-036, one per resolver category in ResolverCategory (Nerve, ChainComplex, HomologyGroup, CochainComplex, CohomologyGroup, Postnikov, HomotopyGroup, KInvariant). Each trait has a single resolve method whose signature is uniform across all eight: per ADR-060, fn resolve(&self, input: TermValue<'a, {carrier_inline_bytes::<B>()}>) → Result<TermValue<'a, {carrier_inline_bytes::<B>()}>, ShapeViolation> — the resolver returns a TermValue directly (Inline / Borrowed / Stream), superseding ADR-036’s writer-style &[u8]-input / &mut [u8]-output / byte-count-return form. Each trait implements the corresponding ψ-map identity per ADR-035 (ψ_1 per NerveResolver<H>, ψ_2 per ChainComplexResolver<H>, ψ_3 per HomologyGroupResolver<H>, ψ_5 per CochainComplexResolver<H>, ψ_6 per CohomologyGroupResolver<H>, ψ_7 per PostnikovResolver<H> with internal Kan-completion, ψ_8 per HomotopyGroupResolver<H>, ψ_9 per KInvariantResolver<H>). The resolver-bound ψ-Term variants per ADR-035 consult the model’s ResolverTuple at evaluation time via the eight Has<Category>Resolver<H> marker-trait accessors. Each trait is sealed per ADR-022 D1; each is parameterized by the model’s H: Hasher (the A: AxisTuple + Hasher substrate parameter per ADR-030 + ADR-036). Resolver shape-violations carry the https://uor.foundation/resolver/RESOLVER_ABSENT shape IRI and the foundation-internal RESOLVER_ABSENT_DISCRIMINATOR byte (Null* resolvers) plus the standard CAPACITY_EXCEEDED/SHAPE_VIOLATION set; the catamorphism’s resolver-bound fold-rules propagate them through Term::Try per ADR-022 D3 G9. |
Has<Category>Resolver<H> |
Foundation-emitted marker traits per ADR-036 — one per resolver category (HasNerveResolver<H>, HasChainComplexResolver<H>, HasHomologyGroupResolver<H>, HasCochainComplexResolver<H>, HasCohomologyGroupResolver<H>, HasPostnikovResolver<H>, HasHomotopyGroupResolver<H>, HasKInvariantResolver<H>) — each providing the typed accessor for that category (e.g., HasNerveResolver<H>::nerve_resolver() → &dyn NerveResolver<H>). The resolver! macro emits impl blocks for all eight marker traits unconditionally on the user-declared resolver tuple; declared fields delegate to the user’s resolver value, undeclared categories delegate to NullResolverTuple's Null* impls. The model declaration’s pipeline::run_route invocation requires all eight Has<Category>Resolver<A> bounds on the resolver tuple unconditionally (where A is the model’s AxisTuple + Hasher substrate parameter); the runtime check for resolver-absence fires through the RESOLVER_ABSENT shape-violation when the catamorphism’s fold-rule consults a category whose accessor returns the Null* resolver. |
| Observable | A coined term referring to a method on uor-foundation's read-only trait surface (in the bridge::observable component) through which application authors and verification authors introspect foundation state. Observables are normatively read-only (section 8, Observability); they MUST NOT mutate any foundation state. |
| Operation declaration | A coined term naming the application author’s act of declaratively expressing an operation using prism's operation-declaration vocabulary. prism ships the vocabulary; the author writes the declaration; rustc enforces the well-typedness (ADR-014). Operation declarations compose uor-foundation::PrimitiveOp discriminants (closure under uor-foundation, ADR-013); prism does not ship operations, only the vocabulary in which authors declare them. |
output_shape! |
An SDK macro (ADR-027) for declaring custom Output shapes used as PrismModel::Output. The macro emits the ConstrainedTypeShape impl, the __sdk_seal::Sealed impl, the GroundedShape impl, and the IntoBindingValue impl alongside each other for the application-named output struct. Parallel to product_shape!, coproduct_shape!, and cartesian_product_shape! for inputs and intermediates; output_shape! is the sanctioned construction path that admits any ConstrainedTypeShape impl as a GroundedShape-conformant Output through the SDK-macro lane. The foundation-sanctioned identity output ConstrainedTypeInput retains its existing direct impl; output_shape! is for application-declared shape-rich outputs. |
Grounded::output_bytes |
A public accessor on Grounded<T, Tag> (ADR-028) that returns the route’s evaluation result as a byte slice. The bytes are the catamorphism’s evaluation output (per ADR-029), carried in the Grounded’s value payload as a source-polymorphic TermValue per ADR-060 (Inline for outputs within the foundation-derived inline width, Borrowed into an upstream byte source, or Stream for unbounded outputs). There is no fixed ROUTE_OUTPUT_BUFFER_BYTES slot — that ceiling is removed per ADR-060; unbounded outputs flow as TermValue::Stream with no byte-width ceiling. The Output shape’s IRI names the bytes' semantic interpretation; foundation carries the bytes; the application interprets them. |
parallel_compose |
A prism-layer operator (ADR-026) that performs parallel composition at the morphism level. Takes two routes f: A → C and g: B → D and produces a route A × B → C × D whose term tree is the partition-product of f's and g's trees. Distinct from partition_product: partition_product operates on shapes (type constructor), parallel_compose operates on routes (morphism constructor). The closure-body grammar G13 (ADR-026’s extension of ADR-022 D3) recognizes parallel(f, g) as the syntactic form (the macro-vocabulary identifier parallel is reserved). |
partition_coproduct |
An operator at both the substrate layer (ADR-025, on algebras as +, with composition rule ST_10) and the prism layer (ADR-026, on ConstrainedTypeShape impls). Result site count is max(operands' site counts) + 1 per CoproductLayoutWidth. The substrate-level form is one of the catalog’s composer operators (entry count at any snapshot is snapshot-specific); the prism-level form is a macro form recognized by G18 (ADR-026’s extension of ADR-022 D3) as partition_coproduct!(<A>, <B>, …). |
partition_product |
An operator at both the substrate layer (ADR-025, on algebras as ×, with composition rule PT_3) and the prism layer (ADR-026, on ConstrainedTypeShape impls). Result site count is the sum of operand site counts per ProductLayoutWidth; CONSTRAINTS combine canonically. PT_1 (site-disjointness with no tag-pinner; sum of structural component sizes equals observed site count) disambiguates ×-decomposable algebras from Betti-additive irreducibles. The substrate-level form is the catalog’s primary composer operator (entry count at any snapshot is snapshot-specific); the prism-level form is a macro form recognized by G17 (ADR-026’s extension of ADR-022 D3) as partition_product!(<A>, <B>, …). |
PartitionProductFields |
A trait defined in uor-foundation per ADR-044 carrying the field metadata that the prism_model! and verb! macros consume at expansion time when lowering closure-body field-access expressions (input.<name> and input.<index>) per ADR-033’s G20. The trait declares two parallel associated constants: FIELDS of type &'static [(u32, u32)] (byte_offset, byte_length pairs for each field, in declaration order) and FIELD_NAMES of type &'static [&'static str] (field names parallel to FIELDS). The split-const form refines ADR-033’s original single-array-of-triples emission by separating offsets/lengths from names — name-lookup uses ++FIELD_NAMES.iter().position( |
| n | n == &<name>)++ and indexes FIELDS[idx] for the offset/length pair. The partition_product! macro emits the trait impl alongside the standard ConstrainedTypeShape impl; hand-written product shapes (composites whose layout follows an external wire-format spec rather than the macro’s canonical bytewise-concatenation form) implement the trait directly. Trait invariant: FIELDS.len() == FIELD_NAMES.len(). |
Phase |
A discriminant type carried by Validated<CompileUnit, Phase> indicating the validation phase the value has reached along the principal data path. Distinct phases include intermediate phases through which CompileUnitBuilder transitions and FinalPhase, the only phase from which pipeline::run can consume the value. |
pipeline |
A component within prism (section 5, Level 2). Contains the principal data path implementation. Provides pipeline::run, the singular function from Validated<CompileUnit, Phase> to Grounded<T> plus Trace. Calls uor-foundation's mint primitives at the Datum/Triad/Derivation/FreeRank admission stages. |
pipeline::run |
A function in prism's pipeline component. The singular entry point to the principal data path. Consumes a Validated<CompileUnit, FinalPhase> and returns (Grounded<T>, Trace). The author’s executable invokes pipeline::run at runtime; the call is resolved monomorphically at the author’s compile time (constraint TC-01). |
primitives |
A component within uor-foundation (section 5, Level 2). Contains the closed catalog of primitive operations (PrimitiveOp discriminants): bit-rotation, content-comparison, depth-projection, integer-handling, lookup, observable-arithmetic. |
PrimitiveOp |
An enum defined in uor-foundation whose discriminants name the primitive operations available along the principal data path. The catalog at the post-ADR-053 snapshot enumerates 18 canonical discriminants: ring-axis arithmetic Add, Sub, Mul, Div, Mod, Pow (per ADR-053; the six-element Γ per the glossary’s gauge-tower entry); hypercube-axis arithmetic Xor, And, Or (binary) and Bnot (unary); unary Neg, Succ, Pred; binary byte-level comparison Le, Lt, Ge, Gt; binary byte-sequence concatenation Concat. The catalog extends through ADR-013’s substrate-amendment-via-foundation rule (TR-08); the wiki’s normative text references the catalog as snapshot-specific rather than enumerating fixed-by-architecture. Per ADR-050, every arithmetic primitive evaluates at the full Witt tower (width = max(operand widths); comparison and concat primitives retain their byte-level semantics). Trace events of variant PipelineRun carry sequences of PrimitiveOp discriminants; verifier structural validation confirms each is in the catalog at the snapshot the trace was emitted under. Operation declarations in prism compose PrimitiveOp discriminants (closure under uor-foundation, ADR-013). |
| Principal data path | A coined term naming the singular path Prism specifies from application author input to a Grounded<T> value: through Grounding, Datum (via uor-foundation's mint_datum primitive), CompileUnitBuilder, Validated, and pipeline::run. The path crosses from uor-foundation's mint primitives into prism's pipeline. Constraint TC-03 establishes this path’s singularity; no alternative pathway exists. |
| Prism | The system specified by this wiki. Realized by uor-foundation (substrate), prism (Prism runtime), and prism-verify (replay façade) (ADR-001). |
prism |
One of the three crates that realize Prism. The Prism runtime: contains the pipeline, the three Prism-mechanism sealed types (Validated, Grounded, Certified), the replay machinery (certify_from_trace), the operation-declaration vocabulary, the standard type library, and vocabulary re-exports of uor-foundation. Closed under uor-foundation's vocabulary (ADR-013). Published from the UOR-Foundation/Prism repository. Per ADR-031, prism also serves as the standard library — a façade re-exporting the prism architecture from uor-foundation together with the built-in types and built-in axes the standard-library Layer-3 sub-crates (prism-numerics, prism-crypto, prism-tensor, prism-fhe) declare. |
| prism-crypto | A standard-library Layer-3 sub-crate (ADR-031) carrying the cryptography-domain vocabulary: HashAxis (canonical hash families: SHA-2, SHA-3, BLAKE3, Poseidon), CurveAxis (elliptic-curve operations), SignatureAxis (signing/verification), CommitmentAxis (Pedersen, KZG, Merkle). Concrete impls per primitive: Sha256Hasher, Blake3Hasher, KeccakHasher, PoseidonHasher, Secp256k1, Ed25519Curve, Bls12_381, etc. Verbs: HMAC, HKDF, ECDSA-with-RFC6979, Merkle-tree construction. The Hasher trait that ADR-007 originally named is declared by prism-crypto as HashAxis per ADR-030’s generalization of the substitution-axis triple’s third position. Published from the UOR-Foundation/Prism repository alongside the prism façade per ADR-031. |
| prism-fhe | A standard-library Layer-3 sub-crate (ADR-031) carrying the homomorphic-encryption-domain vocabulary: FheAxis (homomorphic add, mul, rotation, key switching, bootstrapping). Multiple impls per FHE scheme: TfheBoolean, TfheInteger<N>, BgvLevelled<L>, CkksApproximate. Verbs: PBS-based comparison, encrypted lookup tables, polynomial evaluation over ciphertexts. Independent of prism-crypto in the dependency graph (FHE schemes' cryptographic primitives are scheme-internal). Published from the UOR-Foundation/Prism repository alongside the prism façade per ADR-031. |
| prism-numerics | A standard-library Layer-3 sub-crate (ADR-031) carrying the numerics-domain vocabulary: NumericAxis (or per-arithmetic-domain axes: BigIntAxis, FixedPointAxis, FieldAxis, RingAxis) with kernels for arbitrary-precision integer arithmetic, fixed-point arithmetic, finite-field arithmetic, modular exponentiation, polynomial evaluation. Multiple impls per axis: BigIntNumeric, FixedPointNumeric<I, F>, Gf2NumericAxis, PrimeFieldNumeric<P>. Verbs: GCD, extended Euclidean, fused-multiply-add, Horner’s method, Newton’s iteration. Shape declarations: BigInt<MaxBits>, FixedPoint<I, F>, FieldElement<P>, Polynomial<MaxDegree, Coeff>. Published from the UOR-Foundation/Prism repository alongside the prism façade per ADR-031. |
| prism-tensor | A standard-library Layer-3 sub-crate (ADR-031) carrying the tensor-compute-domain vocabulary: TensorAxis (matmul, conv2d, transposed-conv, pooling, normalization, reduction), ActivationAxis (element-wise nonlinearities). Multiple impls per axis: CpuFp32Tensor, CpuI8Tensor, CpuFixedPointTensor. Verbs for compositional tensor patterns whose decomposition is format-neutral: matrix-vector multiplication, batched matmul, softmax-with-cross-entropy, layer-normalization. Shape declarations: Tensor<Element, Shape> parameterized over element type and dimensional shape. The sub-crate carries domain-neutral tensor compute primitives; specific model-format imports (graph-format-to-prism_model! translators for ONNX, GGUF, TensorFlow GraphDef, PyTorch JIT, etc.) and architecture-specific compositions (transformer blocks, convolutional networks, recurrent architectures, state-space models, etc.) live in separate third-party Layer-3 crates that consume prism-tensor’s vocabulary. Published from the UOR-Foundation/Prism repository alongside the prism façade per ADR-031. |
prism-verify |
One of the three crates that realize Prism. The replay surface: a thin façade re-exporting prism's certify_from_trace and Certified, and uor-foundation's wire-format type definitions. Carries no implementation; the verification machinery lives in prism's replay component. Published from the UOR-Foundation/Prism repository. |
prism_model! |
The SDK proc-macro (ADR-022 D3) that emits a PrismModel impl from the application author’s closure-bodied route function declaration. The macro parses the closure body per the closure-body grammar G1–G29 (ADR-022 D3 plus ADR-026's G12-G19 extension plus ADR-033's G20 field-access projection plus ADR-035's G21-G29 ψ-chain forms), emits the &'static arena slice the route witness's FoundationClosed::arena_slice() returns (ADR-022 D6), emits the FoundationClosed impl with the closure-violation check (no opaque imports), and emits the forward body that calls pipeline::run_route::<H, B, A, R, Self>(input, &axes, &resolvers) (ADR-022 D5 + ADR-036). Lives in the uor-foundation-sdk crate per ADR-015’s bundling. Reserves the macro-vocabulary identifiers parallel, fold_n, tree_fold, first_admit, partition_product, partition_coproduct, hash, recurse, unfold, lift, project, nerve, chain_complex, homology_groups, betti, cochain_complex, cohomology_groups, postnikov_tower, homotopy_groups, k_invariants, plus the route-function name route (ADR-026 G3-disambiguation rule). |
PrismModel |
A trait defined in prism codifying the application author’s hylomorphism contract: Input, Output, Route associated types and a forward(input: Input) → Result<Grounded<Output>, PipelineFailure> method (ADR-020, section 8, PrismModel). Parameterized by the three substitution axes plus the ResolverTuple substrate parameter — PrismModel<H: HostTypes, B: HostBounds, A: AxisTuple + Hasher, R: ResolverTuple = NullResolverTuple> per ADR-030 + ADR-036 (the third position generalizes ADR-007’s original A: Hasher to a tuple of axis trait selections per ADR-030 with the prism-crypto-declared HashAxis per ADR-031 subsuming the prior Hasher — the A: AxisTuple + Hasher bound makes the canonical hash axis reachable type-associatedly via <A as Hasher>::initial(); the fourth position is the ResolverTuple substrate parameter per ADR-036 carrying application-provided per-value content for resolver-bound ψ-Term variants per ADR-035, defaulting to NullResolverTuple so models that emit no resolver-bound ψ-Term variants can omit the parameter) — with all four parameter selections at the impl site; each impl PrismModel<…> for … is one member of the H-indexed family of carriers (ADR-022, D4). The application author implements PrismModel for their application; Route's closure bound is checked at the application’s compile time (UORassembly, TC-04, ADR-006); forward is implemented as a single call to prism::pipeline::run_route::<H, B, A, Self, R>(input, &resolvers) emitted by the prism_model! macro from a closure-bodied route function (ADR-022, D3, D5; ADR-036). The developer’s expression of the catamorphism + anamorphism pair uor-foundation's signature category formalizes as a hylomorphism with verifiable round-trip; surfaces the architecture’s "compiled prism application is a monomorphism via the catamorphism induced by initiality of Term, with the trace as residue object enabling the recoverable backward direction" property as a Rust trait the author implements. Does not realize a standard categorical-optic shape; the trait’s name derives from the implementation crate’s name, not from the categorical Prism optic (section 8, Anamorphism). |
replay |
A component within prism (section 5, Level 2). Houses certify_from_trace. Calls prism's seal regime to construct Certified. Exposed publicly so prism-verify can re-export it. |
ReplayError |
A typed error variant defined in uor-foundation, returned by prism's certify_from_trace (re-exported via prism-verify) when re-derivation does not succeed. The verifier returns either Certified<GroundingCertificate> or ReplayError; both outcomes are structured values with no ambiguity. |
RECURSE_IDX_NAME_INDEX |
A foundation-fixed u32 name index (per ADR-034) that binds to a TermValue carrying the current iteration counter (the descending measure value at the current descent) inside the step body of an enclosing Term::Recurse evaluation. The catamorphism resolves Term::Variable { name_index: RECURSE_IDX_NAME_INDEX } references in the step body to this binding per ADR-029’s per-variant fold-rule for Term::Recurse. Parallels RECURSE_PLACEHOLDER_NAME_INDEX (which binds to the recursive-call placeholder) and UNFOLD_PLACEHOLDER_NAME_INDEX (the corresponding placeholder for Term::Unfold). The numeric value is a foundation parameter (e.g., u32::MAX - 3). |
| Real-Time Inference | The framing under which a PrismModel's forward method appears at the developer’s reading surface: input features arrive at runtime, types route them to output labels, the pipeline is the route’s compiled form, runtime cost is the cost of executing the route. The framing the architecture supports underneath is the hylomorphism with verifiable round-trip (catamorphism + anamorphism witnessed by the trace; section 8, Foundation as a Signature Category); the two framings are the same statement at two levels of abstraction. Real-Time Inference names the operational behavior without requiring the developer to learn the categorical vocabulary (ADR-020, section 8, PrismModel). |
ResolverTuple |
A sealed trait per ADR-036 declared by foundation that constrains the model declaration’s R substrate parameter — a tuple-of-bounded-types pattern paralleling AxisTuple per ADR-030, with ARITY: usize and CATEGORIES: &'static associated constants. The catamorphism's resolver-bound fold-rules per ADR-035 consult the resolver tuple via the eight Has<Category>Resolver<H> marker-trait accessors at evaluation time to retrieve application-provided resolver instances for per-value content provision. |
ResolverCategory |
A foundation-declared enum per ADR-036 enumerating the resolver-bound substrate operations that may consult a ResolverTuple. The initial set per ADR-035: Nerve (ψ_1), ChainComplex (ψ_2), HomologyGroup (ψ_3), CochainComplex (ψ_5), CohomologyGroup (ψ_6), Postnikov (ψ_7), HomotopyGroup (ψ_8), KInvariant (ψ_9). ψ_4 (Betti) is resolver-free per ADR-035 and has no ResolverCategory variant. Future substrate amendments per ADR-013/TR-08 may extend the enum. |
NullResolverTuple |
A foundation-emitted resolver tuple impl per ADR-036 satisfying every Has<Category>Resolver<H> marker trait by returning the corresponding Null<Category>Resolver<H> from each accessor. The default value for the R: ResolverTuple parameter on the PrismModel<H, B, A, R = NullResolverTuple> trait — model declarations that emit no resolver-bound ψ-Term variants per ADR-035 default to NullResolverTuple for R. Each Null<Category>Resolver<H>'s resolve method returns a ShapeViolation carrying the https://uor.foundation/resolver/RESOLVER_ABSENT shape IRI and the foundation-internal RESOLVER_ABSENT_DISCRIMINATOR byte; the catamorphism’s fold-rule propagates the shape-violation through Term::Try per ADR-022 D3 G9. |
RESOLVER_ABSENT_DISCRIMINATOR |
A foundation-internal byte constant per ADR-036, emitted by every Null<Category>Resolver<H> impl’s resolve method via the ShapeViolation carrying the https://uor.foundation/resolver/RESOLVER_ABSENT shape IRI. The specific byte value is foundation-vetted at reconciliation; the architectural commitment is that a single foundation-internal discriminator byte exists. The catamorphism’s resolver-bound fold-rule receives the shape-violation and propagates it through Term::Try per ADR-022 D3 G9 (the verb body’s outer Term::Try handler recovers the resolver-absent case). |
| Resolver trait shape | The architectural commitment per ADR-036 (resolver-surface amended by ADR-060) that the eight resolver traits — NerveResolver<H>, ChainComplexResolver<H>, HomologyGroupResolver<H>, CochainComplexResolver<H>, CohomologyGroupResolver<H>, PostnikovResolver<H>, HomotopyGroupResolver<H>, KInvariantResolver<H> — share a uniform resolve method signature. Pre-0.5.0 (ADR-036): writer-style fn resolve(&self, input: &[u8], out: &mut [u8]) → Result<usize, ShapeViolation> — byte-sequence input, byte-buffer output, byte-count return. Post-ADR-060: fn resolve(&self, input: TermValue<'a, {carrier_inline_bytes::<B>()}>) → Result<TermValue<'a, {carrier_inline_bytes::<B>()}>, ShapeViolation> — the resolver returns a TermValue directly, constructing whichever carrier variant (Inline of foundation-derived width, Borrowed into resolver-owned scratch, or Stream for unbounded structural sequences) its ψ-stage output requires; no caller-supplied output buffer and no per-stage *_OUTPUT_BYTES_MAX ceiling. Inline/Borrowed outputs incur no per-stage allocation. ADR-041’s typed-coordinate carriers (SimplicialComplexBytes<'_>, ChainComplexBytes<'_>, etc.) remain the typed views over the carrier’s backing bytes; their byte widths derive from foundation const fn per ADR-060 rather than from removed HostBounds ceilings. |
| Resolver-body discipline scope | The architectural commitment per ADR-046 (scope refined by ADR-056) recording the discipline-scope boundary between the ψ-residuals discipline (per ADR-035 + ADR-056 — applies to the route body’s syntactic surface: the closure body the application author writes directly in the prism_model!-declared route function) and ADR-043’s iterative-resolution discipline (applies to resolver bodies — the impl <ψ-stage>Resolver<H> for <Impl> blocks per ADR-036 whose resolve method bodies realize the typed-carrier structural transform). The route body’s syntactic surface is restricted: emissions of Term::FirstAdmit, Term::AxisInvocation, and byte-comparison/concat PrimitiveOp s (Le, Lt, Ge, Gt, Concat) are rejected at proc-macro expansion. Three categories are outside the discipline’s scope per ADR-056: compound verbs declared via verb! per ADR-024 (their internal Term arenas fold-fuse into the route’s evaluation per ADR-054 but are syntactically distinct from the route’s direct emissions); axis impl bodies per ADR-055’s universal substrate-Term verb body discipline; and resolver bodies per ADR-046 themselves. All three may compose the full substrate vocabulary internally. Resolver bodies are unrestricted beyond the trait’s TermValue-returning signature (per ADR-060) and the typed-carrier interface per ADR-041 — bounded iteration over <DomainTy as ConstrainedTypeShape>::CYCLE_SIZE per ADR-032 + ADR-043, σ-projection through the canonical hash axis per ADR-022 D5 + ADR-036, byte-comparison against ConstraintRef::Bound per ADR-040, structural admission-relation evaluation, FreeRank decrement, impossibility-witness emission via Err(ShapeViolation) per ADR-039 are all admissible. The boundary is structural, not stylistic: the route body’s syntactic surface is the application’s typed-iso vocabulary; compound-verb and axis-impl bodies are fold-fusion-realized substrate work the catamorphism transparently inlines; resolver bodies are the substrate’s mechanism for realizing the structural transform the catamorphism’s resolver-bound fold-rules dispatch to. |
resolver! |
An SDK macro per ADR-036 paralleling axis! per ADR-030. Application authors declare a struct of per-category resolver impls using a fixed field-name-to-category mapping (foundation-defined: nerve → Nerve, chain_complex → ChainComplex, homology_groups → HomologyGroup, cochain_complex → CochainComplex, cohomology_groups → CohomologyGroup, postnikov → Postnikov, homotopy_groups → HomotopyGroup, k_invariants → KInvariant); the macro emits the ResolverTuple impl, the ARITY + CATEGORIES consts, and impl blocks for all eight Has<Category>Resolver<H> marker traits (declared fields delegate to the user’s resolver; undeclared categories delegate to NullResolverTuple). Unrecognized field names fail at proc-macro expansion citing the recognized field-name set. |
| Rust toolchain | The cargo plus rustc ecosystem. One of the three external actors at Prism’s Level 1 system boundary (section 3). Prism delegates compilation to the Rust toolchain; Prism does not perform compilation. |
seal regime |
A component within prism (section 5, Level 2). Contains the pub(crate) constructors for the three Prism-mechanism sealed types (Validated, Grounded, Certified). Reachable from outside prism only via pipeline::run return values or via the replay component’s certify_from_trace. |
| Signature endofunctor | The endofunctor F generated by uor-foundation's vocabulary: each PrimitiveOp discriminant contributes a constructor to F’s signature; each Term variant contributes a node shape. F is the self-map of the category whose objects are foundation-typed shapes and whose morphisms are typed routes. F’s signature is closed exactly when the primitive set is closed (TC-01, ADR-013); these are not two properties but one (ADR-019). The structure under which Term is the initial algebra and pipeline::run is the catamorphism (section 8, Foundation as a Signature Category). |
| σ-Projection Hardening Principle | The architectural commitment per ADR-047 specifying the six structural axioms (U1–U6) a Hasher impl must satisfy to qualify as a UOR-hardened canonical hash axis per ADR-030. U1 marginal-uniformity: every elementary UOR observable on the projection’s output is distributed as the random-oracle model predicts. U2 joint-independence: any k-tuple of distinct inputs' projections factorize as the product of marginals. U3 admission-orthogonality: every UOR observable is statistically independent of every admission relation under random-oracle input. U4 avalanche: input proximity does not transfer to output proximity. U5 autocorrelation-flatness: structured input sequences produce uncorrelated outputs. U6 bandwidth-additivity: K independent 1-bit typed predicates Conjunction’d onto admission cost 2^K × α^-1 expected variations (corollary of U1+U2). The principle is empirically witnessed by axis::cryptanalyze per ADR-049 at samples ≥ 10^7; foundation’s DefaultHasher and prism-crypto’s published impls per ADR-031 are required to pass. A Hasher impl that fails any axiom is not admissible as a UOR-hardened canonical hash axis. |
TypedCommitment |
A foundation-declared sealed trait per ADR-048 carrying the substrate’s zero-cost typed-bandwidth admission surface. Every TypedCommitment: Copy impl is monomorphized per concrete type at every call site (no Vec, no dyn, no allocation, no runtime-unknown loop bounds), preserving the zero-cost contract per TC-01 + ADR-019. Trait methods: bandwidth_bits() → f64 (the K bits the commitment encodes per κ-label); accept_prob() → f64 (the tight PRF acceptance probability under the Hardening Principle’s U1+U2 per ADR-047); evaluate(&self, kappa_label: &[u8]) → bool (the conjunction’s per-κ-label decision); predicate_count() → usize. Foundation provides three built-in implementors: EmptyCommitment (the no-commitment baseline; bandwidth 0, accept_prob 1), SingletonCommitment<P: ObservablePredicate> (a single typed predicate over a UOR observable per ADR-049), and AndCommitment<A: TypedCommitment, B: TypedCommitment> (typed conjunction at the type level — bandwidth additive per U6, accept_prob multiplicative; static dispatch through monomorphization). Foundation also publishes the TargetCommitment = SingletonCommitment<LexicographicLessEqThreshold> canonical search-cost commitment alias for admission shapes gating on a &'static [u8] threshold. The trait is the substrate’s typed-bandwidth channel constructor; declaring K predicates in a conjunction is O(K) at the typed-iso surface; the cryptographic 2^K × α^-1 cost is the PRF baseline the canonical hash axis enforces. |
EmptyCommitment |
The no-commitment baseline implementor of TypedCommitment per ADR-048. A zero-sized type with #[derive(Default, Copy)]. Constants: bandwidth_bits = 0.0, accept_prob = 1.0, predicate_count = 0, evaluate(_kl) = true unconditionally. The default value for the fifth model-declaration parameter C on PrismModel<H, B, A, R, C = EmptyCommitment> — models declaring no typed-bandwidth commitment preserve ADR-035’s bare base-admission semantics. Direct correspondence to the substrate’s type:Conjunction empty case (zero predicates conjuncted). |
SingletonCommitment<P> |
A single-predicate implementor of TypedCommitment per ADR-048 carrying one ObservablePredicate per ADR-049. bandwidth_bits = -log2(P::accept_prob()), accept_prob = P::accept_prob(), predicate_count = 1, evaluate(kl) = P::evaluate(kl). Used as the base case of a K-fold AndCommitment chain — SingletonCommitment { predicate: p_1 }.and(SingletonCommitment { predicate: p_2 }).and(…) constructs the typed-bandwidth conjunction at the type level. Zero-cost: the predicate’s evaluate body inlines into SingletonCommitment::evaluate and through AndCommitment::evaluate at every call site. |
AndCommitment<A, B> |
The typed conjunction implementor of TypedCommitment per ADR-048 composing two TypedCommitment impls at the type level. bandwidth_bits = A::bandwidth_bits() + B::bandwidth_bits() (additive per the Hardening Principle’s U6 axiom per ADR-047), accept_prob = A::accept_prob() * B::accept_prob() (multiplicative — tight when the underlying predicates' supports are disjoint per U2 joint-independence), predicate_count = A::predicate_count() + B::predicate_count(), evaluate(kl) = A::evaluate(kl) && B::evaluate(kl). A K-fold conjunction becomes a nested type AndCommitment<AndCommitment<… AndCommitment<P_1, P_2>, …>, P_K> of depth K; the runtime cost is K inlined predicate evaluations the compiler can unroll (no allocation, no dynamic dispatch). Compile-time cost grows with K — see TR-17 for the architectural trade-off and mitigation pattern at large K. |
| Typed-bandwidth admission | A coined term naming the architectural property per ADR-048 that the catamorphism’s success-envelope Grounded<Output> is the complete typed admission verdict — both the base admission relation evaluated by the resolver-bound ψ_9 stage and the additional typed predicates evaluated by C: TypedCommitment post-resolver. The fifth model-declaration parameter C defaults to EmptyCommitment (preserving the bare base-admission semantics); applications opting into typed-bandwidth surface declare a non-empty C and receive zero-cost monomorphized conjunction composition. The bandwidth scaling 2^K × α^-1 per Hardening Principle U6 (ADR-047) holds end-to-end without out-of-band machinery; the catamorphism IS the typed-bandwidth-attested admission certificate. |
| UOR observable surface | The foundation-declared typed observable primitives per ADR-049 — Stratum<P> (p-adic valuation per observable:StratumObservable, indexed by const-generic prime P), WalshHadamardParity (spectral parity at an arbitrary non-trivial frequency, under the new observable:SpectralObservable subclass), UltrametricCloseTo<P> (p-adic ultrametric distance to a reference, per observable:MetricObservable), AffineParity (single-bit value at a designated position), LexicographicLessEqThreshold (big-endian integer-threshold comparison to a &'static [u8] target, under the new observable:ValueThresholdObservable subclass realizing the type:LexicographicLessEqBound catalog primitive per ADR-040). Each observable is Copy, foundation-declared, ontology-bound to its observable:Observable IRI per ADR-038’s closed catalog, and consumable as a SingletonCommitment<P: ObservablePredicate> operand per ADR-048. The five observables span the elementary UOR readings the Hardening Principle’s U1 marginal-uniformity battery covers; together they cover the BitSet (AffineParity, Stratum<P=2>, WalshHadamardParity, UltrametricCloseTo), Modular (Stratum<P≥3>), and ValueThreshold (LexicographicLessEqThreshold) admission regimes per the Hardening Principle’s U2 joint-independence calibration. The five-impl surface stands in 1:1 correspondence to the closed BoundShape catalog of ADR-040 — every catalog primitive has a foundation-published ObservablePredicate realization. |
LexicographicLessEqThreshold |
The foundation-declared typed observable per ADR-049 realizing the type:LexicographicLessEqBound catalog primitive per ADR-040. Carries a target: &'static [u8] parameter; evaluate(digest) returns true iff digest ≤_lex target under right-aligned big-endian byte comparison (shorter operand zero-padded on the left, matching the integer-threshold reading). The closed-form acceptance probability is (value(target) + 1) / 256^len(target), where value(target) reads target as a big-endian integer and len(target) is the target’s byte width. Bound to the observable:ValueThresholdObservable taxonomy subclass per ADR-038’s closed catalog. The canonical search-cost observable for admission shapes that gate on a static integer threshold; consumed by the foundation-published TargetCommitment type alias per ADR-048. |
TargetCommitment |
The foundation-published type alias per ADR-048 — pub type TargetCommitment = SingletonCommitment<LexicographicLessEqThreshold> — realizing the canonical search-cost commitment for admission shapes that gate on a lexicographic threshold against a &'static [u8] target. A singleton in C's structural position (one predicate, not a conjunction); its accept_prob reads as the per-attempt success probability for the resolver-emitted κ-label being ≤_lex target, and its U6 bandwidth-bits reading is -log2(accept_prob). Applications instantiate C = TargetCommitment at the model declaration site to opt into the search-cost-typed admission surface; the catamorphism’s ψ_9 dispatch consults the threshold predicate inline, and the wire format’s CommitmentEvaluated event carries the foundation-vetted LexicographicLessEqThreshold IRI. The alias is canonical (foundation-published, not application-emitted) so downstream substrates compose against a single foundation-owned IRI for the search-cost commitment shape. |
observable:ValueThresholdObservable |
The Observable taxonomy subclass per ADR-038’s closed catalog, introduced by ADR-049 parallel to observable:StratumObservable / observable:SpectralObservable / observable:MetricObservable, classifying UOR observables whose value is a big-endian integer reading of a byte sequence subject to a threshold comparison against a static target. The only catalog member at present is LexicographicLessEqThreshold per ADR-049, realizing the type:LexicographicLessEqBound catalog primitive per ADR-040. The subclass closes the 1:1 correspondence between the BoundShape catalog of ADR-040 and the foundation-published ObservablePredicate impl surface of ADR-049. |
| UOR Cryptanalysis Battery | The substrate-level test primitive uor_foundation::axis::cryptanalyze::<H: Hasher>(samples: usize) → CryptanalysisReport per ADR-049 that runs eight structural tests against a candidate Hasher impl plus two predicate-calibration tests, emitting a structured report enumerating each test’s observed statistic, critical threshold, and pass/fail verdict. The eight structural tests cover the Hardening Principle’s U1 (§A triadic-coordinate uniformity, §C Walsh–Hadamard spectrum, §F p-adic stratification), U4 (§B ultrametric avalanche, §H differential cryptanalysis), and U5 (§D stratum autocorrelation, §E κ-derivation autocorrelation, §G joint admission independence). The two predicate-calibration tests cover U1 marginal calibration (§I) and U2 joint-independence per disjoint-support pair (§J) for the foundation-declared ObservablePredicate impls per ADR-049. Foundation’s CI runs the battery at samples = 10^7 against DefaultHasher and prism-crypto’s published impls per ADR-031 on every release; failure on any test is a substrate-level non-conformance signal. The battery is the empirical witness for ADR-047’s U1–U6 axioms. |
| Sealed type | A coined term referring to a type whose values cannot be constructed by code outside the type’s owning crate, where construction is gated through a single sanctioned path. Prism seals seven types in two crates: four UOR-domain types in uor-foundation (Datum, Triad, Derivation, FreeRank; cross-crate construction via mint primitives reserved for prism's pipeline by ADR-016); three Prism-mechanism types in prism (Validated, Grounded, Certified; reachable from outside prism only via pipeline::run or certify_from_trace). (Constraint TC-02; ADR-011, ADR-016.) |
ShapeViolation |
A typed value returned when validation fails along the principal data path’s Validation stage. Indicates that the input did not satisfy a constraint declared by the ConstrainedTypeShape impl. One form of impossibility witness (section 8, Error Model). |
shape_iri_registry |
Foundation module per ADR-057 housing the closed catalog of ConstrainedTypeShape impls admissible as ConstraintRef::Recurse.shape_iri targets. Members: RegisteredShape (the registered-shape carrier), lookup_shape(iri: &str) → Option<RegisteredShape> (consulted by ψ_1 NerveResolver at evaluation time to resolve a Recurse reference to the referenced shape’s CONSTRAINTS), and the foundation-internal __register_shape registration entry point. SDK clients register shapes through the register_shape! macro per ADR-057, which emits the registration call into a foundation-known link-section; the link-time collection assembles the registry without runtime dispatch. Parallel in role to the observable-IRI registry per ADR-038/049 (collecting ObservablePredicate impls) and to the substitution-axis content-address catalog per ADR-007/030 (collecting AxisExtension impls); all three follow the same closure-disciplined link-time-registration / runtime-resolution pattern. The verifier-side mirror is built the same way and reflects the same registered set when prism and prism-verify link against the same foundation version. (Constraint TC-04; ADR-013/TR-08.) |
RegisteredShape |
Foundation struct per ADR-057 carrying a registered shape’s identifiers and constraint geometry inside shape_iri_registry: iri: &'static str (the content-addressed shape IRI per ADR-017’s closure rule), site_count: usize (the shape’s SITE_COUNT), constraints: &'static [ConstraintRef] (the shape’s CONSTRAINTS array), and cycle_size: u64 (saturated at u64::MAX per ADR-032 when the CONSTRAINTS array contains a ConstraintRef::Recurse reference). ψ_1 NerveResolver consumes the registered carrier when unrolling Recurse references; the bounded unrolling consults the descent budget on each reference and bottoms out at the typed feature hierarchy’s irreducible leaves. |
register_shape! |
SDK macro per ADR-057 for declaratively registering a ConstrainedTypeShape impl in foundation’s shape_iri_registry at link time. Emitted automatically by partition_coproduct! / partition_product! expansions that use recurse(<bound>):<T> operand markers (so the referenced shape is guaranteed registry-present before evaluation can reach the Recurse reference); also callable by application authors who declare recursive shapes via the trait-impl path. The macro’s expansion places the registration call into a foundation-known link-section, mirroring the link-section pattern foundation uses for ObservablePredicate registration per ADR-038/049. Architecturally parallel to axis!, verb!, resolver!, and commitment! (future): a single SDK macro contributing a foundation-vetted catalog entry at compile time with no runtime cost. |
| Bounded recursive structural typing | A coined term naming the ADR-057 substrate primitive that enables ConstrainedTypeShape impls to declare self-referential or mutually-referential constraint geometry through ConstraintRef::Recurse { shape_iri, descent_bound } references resolved against shape_iri_registry at ψ_1 NerveResolver evaluation time, with a per-reference descent budget bounding the unrolling. Completes the constraint-geometry-level parallel to Term::Recurse at the Term level. Substrate-amendment-via-foundation per ADR-013/TR-08 — closure-disciplined (content-addressing per ADR-017, registry-driven dispatch, ADR-013/TR-08-bounded amendment). Use cases the substrate primitive covers without per-application invention of cycle-break mechanisms: JSON values, XML documents, syntax trees of programming languages, S-expressions of homoiconic languages, ASN.1 / Protocol-Buffer message families, filesystem-like hierarchies, and inductively-defined categorical constructions (rose trees, bounded forests, etc.). The strong-reading commitment per ADR-001 + ADR-019 — constraint-geometry-level typed distinction reaching the application’s natural bound, not a sub-language compromise nor a top-level-only compromise — extends to bounded recursive structural typing through this amendment. |
| Standard-library Layer-3 sub-crate | A coined term (ADR-031) referring to a Layer-3 implementation crate published from the Prism repository under foundation maintenance, contributing axis declarations and verb declarations for an application-neutral vocabulary that the prism façade re-exports. The standard-library sub-crate roster (operational, not architectural per ADR-031’s amendment): prism-numerics, prism-crypto, prism-tensor, prism-fhe. The roster’s decomposition is a packaging convention that aids developers in discovering canonical references; the substrate evaluates against the canonical-reference set regardless of which sub-crate publishes which canonical reference, and reorganizing the roster is admissible operational policy so long as the closure discipline (ADR-024), content-addressing rule (ADR-017), conformance discipline (ADR-031), and substrate-Term-verb-body discipline (ADR-054 + ADR-055’s universal scope) are preserved. Format-specific vocabularies (graph-format imports such as ONNX, GGUF, TensorFlow GraphDef, PyTorch JIT) and architecture-specific compositions (transformer blocks, convolutional networks, state-space models, etc.) are not in the standard library; they live in third-party Layer-3 crates that consume the standard-library vocabularies. The architecture treats standard-library and third-party Layer-3 crates identically — the closure discipline applies the same way; standard-library inclusion is operational (foundation-maintained, conformance-tested, recommended-for-production), not architectural. The standard-library sub-crate’s role is to be the canonical reference for the axes it declares; content-addressing is invariant across standard-library and third-party crates per ADR-017. |
SubstrateTermBody |
A foundation-declared sealed supertrait on AxisExtension per ADR-055 enforcing the universal substrate-Term verb body discipline at compile time. Every AxisExtension impl (standard-library AND application-author custom) MUST also impl SubstrateTermBody, providing a static body_arena() → &'static [Term] accessor returning the Term arena slice the axis kernel decomposes to. The catamorphism’s Term::AxisInvocation fold-rule per ADR-029 reads this slice and recursively folds it inductively rather than calling an opaque kernel function — fold-fusion’s structural reach extends to the leaf level across every axis surface. The trait is sealed via the standard __sdk_seal::Sealed pattern per ADR-022 D1; the axis! SDK macro per ADR-030 + ADR-052 emits both AxisExtension and SubstrateTermBody impls together when the author provides a normative body clause carrying the Term composition via the closure-body grammar per ADR-022 D3 + ADR-026 + ADR-033 + ADR-034 + ADR-035. Axis impls that fail to provide a body decomposition fail to satisfy the trait bound and fail to compile — the discipline is type-system-enforced, not policy-enforced. Per ADR-019’s initial-algebra commitment, every prism operation is substrate-Term decomposable; operations that cannot be decomposed are not prism operations and must be hosted at the host boundary outside the catamorphism’s reach. ADR-054’s standard-library-only canonical axis impl body discipline (RA2) is superseded; ADR-010’s arbitrary-Rust Hasher carve-out is amended. |
| Substrate-Term verb body | A coined term naming the body realization every AxisExtension impl carries per ADR-055’s universal substrate-Term verb body discipline: a verb!-style Term composition over substrate PrimitiveOp s and prism operators per ADR-024, emitted as the static slice the SubstrateTermBody::body_arena() accessor returns, rather than an arbitrary-Rust function body. The axis surface (declared via axis! per ADR-030) remains as the typed-extension contract; the body discipline applies to its realization at the compile-time-enforced SubstrateTermBody supertrait bound per ADR-055. Examples: prism-crypto’s Sha256Hasher compression realized as substrate-Term W32 {Add, Xor, And, Or, Bnot} plus rotate; prism-numerics' PrimeFieldNumericSecp256k1 kernel methods realized as substrate-Term W256 ring primitives plus mod-P reduction; prism-tensor’s CpuI8MatmulSquare realized as substrate-Term W8/W16/W32 primitives plus sign-extension; prism-fhe’s OneTimePadFhe encrypt/decrypt realized as substrate-Term Xor composition; application-author custom axes provide the same form via the axis! macro’s body clause. ADR-054’s standard-library-only canonical axis impl body discipline (RA2) is superseded by ADR-055’s universal scope; ADR-010’s arbitrary-Rust Hasher carve-out is amended. The Fold-Fusion Principle per ADR-054 reaches the leaf level across every axis surface for every axis impl — there is no opaque axis-kernel boundary anywhere in any conforming implementation. |
| Substitution axis | A coined term naming a dimension along which a Prism implementation may vary. Prism specifies exactly three substitution axes: HostTypes, HostBounds, and the third position originally Hasher per ADR-007 — generalized to AxisTuple per ADR-030, a tuple of axis trait selections (each declared via the axis! SDK macro per ADR-030 against AxisExtension per the meta-bound, with concrete axes such as HashAxis declared by Layer-3 sub-crates per ADR-031; HashAxis from prism-crypto subsumes the prior Hasher). The axes are allocated across Prism’s three containers in a fixed three-position pattern (ADR-007): uor-foundation defines the trait family, prism declares the bound the trait must satisfy, the application author selects the implementation (the AxisTuple selection now potentially carrying multiple axis members for cross-domain models per ADR-030). |
Term::Literal (wide-value carrier) |
The first Term variant per ADR-022 D3 G1, carrying an immediate value at a declared Witt level. Per ADR-051 (carrier shape amended by ADR-060), the variant is declared Literal { value: TermValue<'a, INLINE_BYTES>, level: WittLevel } — the literal’s bytes occupy the source-polymorphic carrier’s Inline variant, whose byte-length MUST equal level.witt_length() / 8; mismatched constructions are rejected at Term-arena construction time with a ShapeViolation. The fold-rule per ADR-029 emits the carrier’s bytes directly. Wide-value literals (256-bit, 512-bit, etc., up to WITT_LEVEL_MAX_BITS) are single Term::Literal records — pre-ADR-051 codegen patterns that composed Concat-of-narrow Term::Literal records for wide values dissolve into single records. The SDK helper literal_u64(value, level) per ADR-051 preserves the narrow-construction surface for u64 literals. The Term enum and the catamorphism’s evaluate carry the 'a and INLINE_BYTES parameters per ADR-060, instantiated at the application boundary via carrier_inline_bytes::<B>(). |
Term::AxisInvocation |
A Term variant (ADR-029, generalized per ADR-030) for substitution-axis-realized verbs whose structural decomposition exceeds the substrate’s current PrimitiveOp vocabulary. The fold-rule for Term::AxisInvocation { axis_index, kernel_id, inputs } is "evaluate each input term (recursive fold) to produce a slice of TermValue s; dispatch through <A as AxisTuple>::dispatch(axis_index, kernel_id, &evaluated_inputs) per ADR-030; emit the kernel’s result." Emitted by the prism_model! macro from the closure-body axis-trait method call form (ADR-026 G19). This admits axis-realized verbs across domains (cryptographic projections through the prism-crypto standard-library sub-crate’s HashAxis, tensor operations through prism-tensor’s TensorAxis, homomorphic operations through prism-fhe’s FheAxis, etc.) at the catamorphism’s evaluation level: the verb’s body lives in the application’s chosen axis impl within the AxisTuple, and the Term tree references it through AxisInvocation. The substitution-axis-realization mechanism is first-class per ADR-024’s Layer 3 verb-closure pattern; verbs whose structural decomposition fits within the substrate’s PrimitiveOp vocabulary use direct Term::Application chains instead. Generalizes the prior Term::HasherProjection variant (which was Hasher-specific) to the universal substrate-extension form per ADR-030’s commitment. |
Term::ProjectField |
The eleventh Term variant (ADR-033). Carries { source_index: u32, byte_offset: u32, byte_length: u32 }. The fold-rule (per ADR-029’s extended per-variant rules) evaluates the source term identified by source_index recursively producing a TermValue, then emits the byte slice [byte_offset .. byte_offset + byte_length] from the source’s evaluation result as the variant’s carrier value. The proc-macro computes byte_offset and byte_length at expansion time from the receiver shape’s structural metadata; out-of-bounds projections are caught at proc-macro expansion. Emitted by the prism_model! and verb! macros from the closure-body field-access form <expr>.<name> or <expr>.<index> per ADR-022 D3 G20. Coproduct destructuring goes through Term::Match per G6, not through Term::ProjectField. |
Term::FirstAdmit |
The twelfth Term variant (ADR-034). Carries { domain_size_index: u32, predicate_index: u32 }. The fold-rule (per ADR-029’s extended per-variant rules) evaluates domain_size_index recursively producing a non-negative integer N; iterates idx ascending from 0 to N sequentially with structural short-circuit on first admission, evaluating predicate_index in extended scope where the foundation-fixed FIRST_ADMIT_IDX_NAME_INDEX binds to a TermValue carrying idx at the same WittLevel as N’s; emits a coproduct-shaped TermValue — either (0x01, idx_bytes) for the first admitting idx or (0x00, padding) if no idx admits across the full range. The discriminator byte structurally distinguishes "found" from "not-found" without conflating with any in-range idx value (idx=0 admits and the not-found sentinel are distinct results). Emitted by the prism_model! and verb! macros from the closure-body ++first_admit(<domain>, |
| <idx> | <predicate>)++ form per ADR-026 G16. Foundation’s catamorphism’s structural short-circuit is the architectural commitment that lets first_admit evaluate end-to-end without escape to the implementation runtime per ADR-026 G16’s three-way responsibility split. |
Term::Nerve |
The thirteenth Term variant (ADR-035). Carries { value_index: u32 } referencing a Term arena index whose evaluation produces a per-value byte sequence. The fold-rule consults the model declaration’s R: ResolverTuple per ADR-036 (the NerveResolver<A> instance via R::nerve_resolver(), parameterized by the model’s A: AxisTuple + Hasher substrate parameter), calls resolver.resolve(value_bytes, out_buffer) per ψ_1’s ontology identity N(constraints) → SimplicialComplex (the resolver encodes the application’s "what constraints does this value induce?" semantics), and emits a TermValue carrying the SimplicialComplex byte serialization. ShapeViolations carrying the RESOLVER_ABSENT discriminator propagate through Term::Try per ADR-022 D3 G9. Emitted from nerve(<value_expr>) per G21 + ADR-035. The first stage of the canonical k-invariants branch. |
Term::ChainComplex |
The fourteenth Term variant (ADR-035). Carries { simplicial_index: u32 }. The fold-rule consults R::chain_complex_resolver() per ADR-036 and applies ψ_2’s ontology identity C(K) → ChainComplex. Emits a TermValue carrying the ChainComplex byte serialization. Emitted from chain_complex(<simplicial_expr>) per G22 + ADR-035. Not part of the canonical k-invariants branch; used by narrower compositions. |
Term::HomologyGroups |
The fifteenth Term variant (ADR-035). Carries { chain_index: u32 }. The fold-rule consults R::homology_group_resolver() per ADR-036 and applies ψ_3’s ontology identity H_k© = ker(∂k) / im(∂{k+1}). Emits a TermValue carrying the HomologyGroups byte serialization. Emitted from homology_groups(<chain_expr>) per G23 + ADR-035. Not part of the canonical k-invariants branch. |
Term::Betti |
The sixteenth Term variant (ADR-035). Carries { homology_index: u32 }. The fold-rule extracts the Betti-number array directly from the HomologyGroups byte serialization per ψ_4’s ontology identity β_k = rank(H_k) — pure computation, resolver-free, no axis-as-hasher threading. Emits a TermValue carrying the BettiNumbers byte serialization per the substrate’s BettiNumbers shape (foundation-vetted byte layout at reconciliation). Subsequent Term::ProjectField emissions extract individual β-numbers per the substrate’s BettiNumbers field-projection rules; the SDK proc-macro validates the projection’s k-index against the substrate’s BettiNumbers cap at expansion time. Emitted from betti(<homology_expr>) per G24 + ADR-035. Strictly weaker invariant than the canonical k-invariants branch (β_k is the rank of H_k; k-invariants classify the full homotopy type). |
Term::CochainComplex |
The seventeenth Term variant (ADR-035). Carries { chain_index: u32 }. The fold-rule consults R::cochain_complex_resolver() per ADR-036 and applies ψ_5’s ontology identity C^k = Hom(C_k, R). Emits a TermValue carrying the CochainComplex byte serialization. Emitted from cochain_complex(<chain_expr>) per G25 + ADR-035. Not part of the canonical k-invariants branch. |
Term::CohomologyGroups |
The eighteenth Term variant (ADR-035). Carries { cochain_index: u32 }. The fold-rule consults R::cohomology_group_resolver() per ADR-036 and applies ψ_6’s ontology identity H^k© = ker(δ^k) / im(δ^{k-1}). Emits a TermValue carrying the CohomologyGroups byte serialization. Emitted from cohomology_groups(<cochain_expr>) per G26 + ADR-035. UCT-equivalent to homology in discriminating power; strictly weaker than k-invariants. |
Term::PostnikovTower |
The nineteenth Term variant (ADR-035). Carries { simplicial_index: u32 } referencing a Term arena index whose evaluation produces a simplicial-complex value (typically a Term::Nerve emission). The fold-rule consults R::postnikov_resolver() per ADR-036 and applies ψ_7’s ontology identity KanComplex(N©) → PostnikovTower. The PostnikovResolver performs Kan-completion (per homology:KanComplex / HornFiller) as part of its resolve semantics, then computes the truncation tower π_{≤k} for k = 0..dim(N©); verb authors do not construct KanComplex values explicitly. Emits a TermValue carrying the PostnikovTower byte serialization. Emitted from postnikov_tower(<simplicial_expr>) per G27 + ADR-035. The second stage of the canonical k-invariants branch. |
Term::HomotopyGroups |
The twentieth Term variant (ADR-035). Carries { postnikov_index: u32 }. The fold-rule consults R::homotopy_group_resolver() per ADR-036 and applies ψ_8’s ontology identity extracting π_k from each truncation stage. Emits a TermValue carrying the HomotopyGroups byte serialization. Emitted from homotopy_groups(<postnikov_expr>) per G28 + ADR-035. The third stage of the canonical k-invariants branch. |
Term::KInvariants |
The twenty-first Term variant (ADR-035). Carries { homotopy_index: u32 }. The fold-rule consults R::k_invariant_resolver() per ADR-036 and applies ψ_9’s ontology identity computing κ_k classifying the Postnikov-tower extensions per homology:KInvariant. Emits a TermValue carrying the KInvariants byte serialization — the canonical maximum-discriminating structural witness for the framework’s verifiability commitment per ADR-001 + ADR-019. Emitted from k_invariants(<homotopy_expr>) per G29 + ADR-035. The terminal stage of the canonical k-invariants branch; the verb body’s outermost ψ-Term emission in the canonical composition. Two values are computationally equivalent iff their k-invariants match. |
| Trace | A coined term naming the value emitted alongside every Grounded<T>. The trace is sufficient for an independent party (the application user, or a third party they trust) to re-derive the same Certified<GroundingCertificate> without invoking the author’s deciders or any hash function (constraint TC-05). The trace’s wire format is defined in uor-foundation (data definitions in bridge); produced by prism's pipeline; consumed by prism-verify re-exporting prism's certify_from_trace. Specified normatively in section 8. |
TraceEvent |
A data-definition type defined in uor-foundation's bridge::trace component. The discriminated-union type whose variants record stage transitions along the principal data path. Each variant carries the data necessary for the verifier to confirm the corresponding transition was well-typed (section 8, Trace Wire Format). |
TRACE_REPLAY_FORMAT_VERSION |
A constant in uor-foundation carrying the version number of the trace wire format. Traces produced by pipeline::run carry this version in their format_version field; verifiers reject traces whose format version they do not recognize (section 8, Trace Wire Format). |
tree_fold |
A prism-layer operator (ADR-026) that performs pairwise tree reduction. Takes a binary reducer route and a list of leaves with finite, compile-time-known cardinality bounded by HostBounds; produces a route from the leaves' partition-product shape to the reducer’s output. Lowers to fold_n over levels with depth ceil(log2(leaves.len())). The closure-body grammar G15 (ADR-026’s extension of ADR-022 D3) recognizes tree_fold(<reducer>, <leaves>). |
Triad |
A sealed type in uor-foundation. One of the four UOR-domain sealed types. Carries the (stratum, spectrum, address) coordinate triple computed for a value at a specific Witt level: stratum is the two-adic valuation, spectrum is the Walsh-Hadamard image, address is the canonical content-address coordinate. Materialized at grounding time and accessed thereafter through named accessors. Constructed via the mint_triad mint primitive. |
| UORassembly | A coined term naming the set of type-level constraints that any Rust source compiling to a Prism executable MUST satisfy. The contract is enforced bilaterally by prism (constraint TC-04): uor-foundation MUST satisfy prism's bounds, and the application author’s crate MUST satisfy the surface prism exposes. |
uor-foundation |
One of the three crates that realize Prism. The substrate: contains the type-declaration vocabulary (including the shape proc-macros via an internal sub-crate), the four UOR-domain sealed types (Datum, Triad, Derivation, FreeRank), the trace and certificate wire-format type definitions, the mint primitives (cross-crate construction surface), and the kernel/primitives substrate. Defines (does not bind) the substitution axis traits. Published from the UOR-Foundation/UOR-Framework repository. |
user |
A component within uor-foundation (section 5, Level 2). Hosts the application-author-facing type-construction surface — morphism, state, and type-witness scaffolds the shape proc-macros emit code against. Distinct from "application user" (the L1 actor). |
use_verbs! |
An SDK macro (ADR-024) for importing verbs from another implementation crate into the importing implementation’s verb set. Parallel to Rust’s use statement but specific to verb identifiers; takes a from <other_crate> { verb_name_a, verb_name_b, … }; form. The macro emits trait-method-style re-exports for the named verbs, gated on the imported crate’s seal regime (the imported crate’s verb! impls are sealed via the standard __sdk_seal::Sealed pattern). The importing implementation’s verb-closure check treats imported verbs as opaque atoms satisfying the closure invariant; the imported implementation’s own verb! macro performs that implementation’s closure check. Imported verbs participate in the importing implementation’s acyclicity check (the verb-reference graph including imports must be acyclic outside recurse). |
Validated<T, Phase> |
A sealed type in prism representing a value that has passed the validation phase of the principal data path. One of the three Prism-mechanism sealed types; sealed by pub(crate) constructors in prism's seal regime. No code outside prism can construct a Validated value (constraint TC-02). pipeline::run consumes a Validated<CompileUnit, Phase> and produces a Grounded<T> plus a Trace. |
verb! |
An SDK macro (ADR-024) for declaring a verb in an implementation’s verb set. Takes a closure-bodied form analogous to prism_model!'s route declaration: the body is composed of prism operators (G12–G19) applied to substrate primitives (G1–G11) and other verbs declared in the same implementation. The macro emits the verb's term-tree fragment as a &'static slice and a pub fn whose body the prism_model! macro can reference by name during route-closure expansion. The verb-closure check (closure under foundation primitives ∪ own-implementation verbs ∪ imported verbs; acyclicity through non-recurse operators) is performed at the application’s compile time at the verb! invocation site; a final whole-implementation cycle check is performed at the prism_model! macro over the verb-reference graph reachable from the model’s route. |
| Verb | A coined term (ADR-024) referring to a named, reusable composition of prism operators applied to substrate primitives within an implementation’s declared verb set. Each verb is declared via the verb! SDK macro (ADR-024). Verbs are the implementation-layer’s closure unit: verbs may cross-reference each other within the same implementation provided the verb-reference graph through non-recurse operators is acyclic. Cross-implementation verb imports proceed through the use_verbs! macro at the importing crate’s root (ADR-024). Verbs are not prism operators — they introduce no new structural forms; they’re named compositions only. |
vocabulary re-exports |
A component within prism (section 5, Level 2). Re-exports of uor-foundation's type-declaration vocabulary (traits, the four UOR-domain sealed type definitions, the wire-format types, and the shape proc-macros) so application authors import only prism. The mechanism by which closure under uor-foundation (ADR-013) is exposed to authors. |
<B as HostBounds>::AFFINE_COEFFS_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the ConstraintRef::Affine fixed-array coefficient count cap. Replaces the prior foundation-fixed AFFINE_MAX_COEFFS. The Affine ConstraintRef variant’s coefficient array becomes [u8; <B as HostBounds>::AFFINE_COEFFS_MAX]. |
AXIS_OUTPUT_BYTES_MAX (removed per ADR-060) |
Formerly a HostBounds associated constant per ADR-037 clause (1) carrying the per-axis kernel output byte-buffer ceiling. Removed by ADR-060: axis kernels emit a source-polymorphic TermValue (Inline of foundation-derived width, Borrowed, or Stream); there is no separate axis-output byte-width ceiling. |
<B as HostBounds>::BETTI_DIMENSION_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the BettiNumbers byte-serialization dimension cap. Replaces the prior foundation-fixed MAX_BETTI_DIMENSION per ADR-035. The Term::Betti fold-rule emits a [u32; <B as HostBounds>::BETTI_DIMENSION_MAX] byte sequence; subsequent Term::ProjectField emissions extract individual β-numbers per the BettiNumbers field-projection rules, with k < <B as HostBounds>::BETTI_DIMENSION_MAX validated at proc-macro expansion time. |
<B as HostBounds>::CONJUNCTION_TERMS_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the ConstraintRef::Conjunction.conjuncts fixed-array term count cap. Replaces the prior foundation-fixed CONJUNCTION_MAX_TERMS. The Conjunction ConstraintRef variant’s conjuncts array becomes [LeafConstraintRef; <B as HostBounds>::CONJUNCTION_TERMS_MAX]. The Conjunction variant is depth-limited to one level — its conjuncts are LeafConstraintRef (every ConstraintRef variant except Conjunction itself). |
<B as HostBounds>::FOLD_UNROLL_THRESHOLD |
A HostBounds associated constant per ADR-037 clause (1) carrying the fold_n unroll-vs-recurse threshold (the count at and below which the SDK emits an unrolled Term::Application chain rather than Term::Recurse). Replaces the prior foundation-fixed pipeline::FOLD_UNROLL_THRESHOLD. |
<B as HostBounds>::JACOBIAN_SITES_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the Jacobian-stage site-set capacity. Replaces the prior foundation-fixed JACOBIAN_MAX_SITES. |
<B as HostBounds>::NERVE_CONSTRAINTS_MAX, <B as HostBounds>::NERVE_SITES_MAX
|
HostBounds associated constants per ADR-037 clause (1) carrying the ψ_1 nerve-stage data-shape caps: maximum constraint count and maximum site count. Replace the prior foundation-fixed NERVE_CONSTRAINTS_CAP and NERVE_SITES_CAP. The application’s NerveResolver impl materializes simplicial complexes whose shapes fit within these ceilings; every application declares its own HostBounds impl with appropriate values (there is no DefaultHostBounds per ADR-060). Per ADR-060 the ψ_1 nerve carrier’s byte width derives from these counts via the foundation const fn nerve_carrier_bytes::<B>() (count × foundation-fixed per-element wire width), not from a removed byte-width ceiling. |
<B as HostBounds>::OP_CHAIN_DEPTH_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the operation chain depth ceiling. Replaces the prior foundation-fixed MAX_OP_CHAIN_DEPTH. |
<B as HostBounds>::RECURSION_TRACE_DEPTH_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the recursion trace depth ceiling. Replaces the prior foundation-fixed RECURSION_TRACE_MAX_DEPTH. |
ROUTE_INPUT_BUFFER_BYTES, ROUTE_OUTPUT_BUFFER_BYTES (removed per ADR-060) |
Formerly HostBounds associated constants per ADR-037 clause (1) carrying the route input/output buffer byte-sizes. Removed by ADR-060: there is no fixed route buffer. Route input flows as a borrowed &'a [u8] source (TermValue::Borrowed); route output flows as a TermValue (Inline of foundation-derived width, Borrowed, or Stream for unbounded output). Oversized payloads are no longer rejected (see TR-10, resolved). |
TERM_VALUE_MAX_BYTES (removed per ADR-060) |
Formerly a HostBounds associated constant per ADR-037 clause (1) carrying the catamorphism’s per-variant TermValue byte-buffer capacity ceiling (and, before ADR-037, the contrived foundation-fixed 4096-byte value). Removed by ADR-060: the TermValue carrier is source-polymorphic (see TermValue), its Inline width is foundation-derived via carrier_inline_bytes::<B>(), and its Borrowed/Stream variants carry no byte-width ceiling. No per-variant byte-buffer capacity constant exists. |
TermValue (source-polymorphic carrier) |
The catamorphism’s per-variant value carrier per ADR-029, declared post-ADR-060 as the source-polymorphic enum TermValue<'a, const INLINE_BYTES: usize> with three variants: Inline { bytes: [u8; INLINE_BYTES], len: usize } (a stack buffer whose width derives from carrier_inline_bytes::<B>() — admitting integer literals at any Witt level up to WITT_LEVEL_MAX_BITS, cryptographic digests up to FINGERPRINT_MAX_BYTES, and the κ-label ASCII form); Borrowed(&'a [u8]) (a slice descriptor into an upstream byte source — input bytes, sibling-ψ-stage scratch, axis-kernel output — with no copy and no byte-width ceiling); and Stream(&'a dyn ChunkSource) (a chunk-emitting source for unbounded payloads, with no byte-width ceiling). Replaces the pre-0.5.0 fixed [u8; TERM_VALUE_MAX_BYTES] buffer struct. The σ-projection at ψ_9 dispatches on the variant — Inline/Borrowed fold their bytes once, Stream folds chunk-by-chunk via ChunkSource::for_each_chunk into Hasher::fold_bytes. The alloc-gated TermValue::to_vec() helper is the only allocation surface (opt-in per caller; materializes a Borrowed/Stream into an owned Vec<u8>). |
ChunkSource |
The trait per ADR-060 backing TermValue::Stream: fn for_each_chunk(&self, f: &mut dyn FnMut(&[u8])) folds each chunk into the closure in canonical order (total folded byte count unbounded; per-call slice lifetime, not retained), and fn total_bytes(&self) → Option<usize> returns the total byte count if statically known. Realizations whose canonical form is unbounded (model-weight container formats with multi-GB tensor-data sections, large attestation envelopes) emit TermValue::Stream(&'a dyn ChunkSource) from their canonicalization step; the σ-projection folds the chunks directly into the Hasher without materializing the full byte sequence, so peak resident memory is the derived inline width plus the chunk source’s internal state. |
carrier_inline_bytes::<B>() |
The foundation const fn per ADR-060 deriving the minimum admissible INLINE_BYTES width for the TermValue::Inline carrier from the application’s HostBounds primitives: the maximum over the Witt-literal width (WITT_LEVEL_MAX_BITS / 8), the fingerprint width (FINGERPRINT_MAX_BYTES), and the κ-label ASCII width (HASHER_IDENTIFIER_BYTES + 1 + 2 × FINGERPRINT_MAX_BYTES — the hex-encoded digest doubles the fingerprint width). The three-term maximum is the self-consistent derivation: every value class that flows inline (integer literals, digests, the κ-label) fits, with no padding for structural payloads (those flow as Borrowed/Stream). The application never picks the width; the foundation computes it from primitives the application has already committed to. The companion per-ψ-stage const fns (nerve_carrier_bytes::<B>(), chain_complex_carrier_bytes::<B>(), …, k_invariants_carrier_bytes::<B>()) derive each ψ-stage carrier’s width as structural-count × foundation-fixed per-element wire width. All are plain const fn calls admissible in array-length position on stable Rust (no generic_const_exprs). |
<B as HostBounds>::UNFOLD_ITERATIONS_MAX |
A HostBounds associated constant per ADR-037 clause (1) carrying the Term::Unfold iteration ceiling. Replaces the prior foundation-fixed UNFOLD_MAX_ITERATIONS. |
| Eight ψ-stage resolver output byte-width ceilings (removed per ADR-060) | Formerly eight HostBounds associated constants per ADR-037 clause (1) — NERVE_OUTPUT_BYTES_MAX, CHAIN_COMPLEX_OUTPUT_BYTES_MAX, HOMOLOGY_GROUPS_OUTPUT_BYTES_MAX, COCHAIN_COMPLEX_OUTPUT_BYTES_MAX, COHOMOLOGY_GROUPS_OUTPUT_BYTES_MAX, POSTNIKOV_TOWER_OUTPUT_BYTES_MAX, HOMOTOPY_GROUPS_OUTPUT_BYTES_MAX, K_INVARIANTS_OUTPUT_BYTES_MAX — bounding each ψ-stage resolver’s output byte buffer. Removed by ADR-060: ψ-stage resolvers return a TermValue directly, and each ψ-stage carrier’s byte width derives from a foundation const fn (nerve_carrier_bytes::<B>(), chain_complex_carrier_bytes::<B>(), …, k_invariants_carrier_bytes::<B>()) computing structural-element-count × foundation-fixed per-element wire width. No application-declared per-ψ-stage byte-width ceiling exists; the κ-label carrier width is k_invariants_carrier_bytes::<B>() = HASHER_IDENTIFIER_BYTES + 1 + 2 × FINGERPRINT_MAX_BYTES. |
MAX_RESOLVER_TUPLE_ARITY (foundation-vetted impl-table cap) |
A foundation-vetted pub const usize (ADR-036 + ADR-037 clause (2)) bounding ResolverTuple arity. Per ADR-037 clause (2), this is a type-system tuple-impl-table cap with explicit Rust-language carve-out from ADR-018 (Rust’s lack of variadic generics requires per-arity blanket-impl emission at foundation’s build time). The architectural lower bound is card(ResolverCategory) — the cardinality of the resolver-category enumeration (currently 8: Nerve, ChainComplex, HomologyGroup, CochainComplex, CohomologyGroup, Postnikov, HomotopyGroup, KInvariant) — plus headroom for future ADR-013/TR-08 substrate amendments. Foundation revision adjusts the value as ResolverCategory grows. |
| Canonical k-invariants branch (verdict realization per ADR-039) | The architectural commitment per ADR-035 + ADR-039 that the canonical ψ-pipeline composition ψ_1 (Nerve) → ψ_7 (PostnikovTower) → ψ_8 (HomotopyGroups) → ψ_9 (KInvariants) is the framework’s verdict-production mechanism for typed feature hierarchies whose admission relations are inhabitance questions. The branch produces both a homotopy-classification structural witness (the κ-label, at the terminal ψ_9 stage) and concrete value-tuple witnesses (0-simplices of Term::Nerve's SimplicialComplex emission, at the initial ψ_1 stage); both flow into the verdict envelope’s payload properties per ADR-039. |
observable:AxisProjectionObservable |
A closed-catalog observable:Observable subclass per ADR-038. A top-level Observable subclass parallel to the seven internally-derived Observable categories (StratumObservable, MetricObservable, PathObservable, ReductionObservable, CatastropheObservable, CurvatureObservable, HolonomyObservable); structurally distinct because its values carry from the substrate-extension surface per ADR-030, not from the framework’s internal algebraic/topological structure. The observable’s value is the byte sequence produced by applying an axis kernel (a method on an AxisExtension trait declared via the axis! macro per ADR-030) to a specified set of typed sites. The specific axis identity, kernel selector, and source site range are carried by the ConstraintRef::Bound.args_repr canonical-string-form per ADR-038’s encoding rules: axis_address=<hex>;kernel=<symbolic>;sites=<site-list>[;target=<target-spec>]. Axis identification is by content-address (AXIS_ADDRESS per ADR-030, content-derived from trait name + method signatures + bounds via foundation’s content-addressing per ADR-017), not by tuple position — preserving application-invariant identity for closed-catalog Observable individuals. The constraint declaration is consumed by the application’s ψ_1 NerveResolver per ADR-036, which resolves the axis_address to a concrete axis kernel through the application’s AxisTuple and constructs the simplicial complex over the projected observable’s structural relationship to the bound shape’s target. |
cert:InhabitanceCertificate |
An ontology closed-catalog primitive — a ComputationCertificate verdict primitive that decides carrier non-emptiness on a type:ConstrainedType. The positive-verdict certificate envelope. Carries properties cert:witness → schema:ValueTuple (a specific value tuple in the carrier when the verdict is positive), cert:searchTrace → trace:InhabitanceSearchTrace (the audit trail), and cert:certifiedType → type:ConstrainedType. Per ADR-039 clause (1), a successful Grounded<Output> IS the cert:InhabitanceCertificate envelope for typed feature hierarchies whose admission relations are inhabitance questions: the κ-label (the Term::KInvariants emission per ADR-035) is the homotopy-classification structural witness at ψ_9; the concrete cert:witness ValueTuple is derivable from Term::Nerve's 0-simplices at ψ_1; cert:searchTrace is realized as Grounded::derivation().replay(). The κ-label and cert:witness are different witness granularities the canonical k-invariants branch produces at different stages. |
cert:InhabitanceImpossibilityCertificate |
An ontology closed-catalog primitive — a certificate attesting that the inhabitance decider concluded the input is unsatisfiable. The negative-verdict certificate envelope. Per ADR-039 clause (1), an Err(PipelineFailure) whose structural cause is "the constraint nerve has empty Kan completion" realizes a cert:InhabitanceImpossibilityCertificate envelope. Distinguished from proof:InhabitanceImpossibilityWitness: the certificate is the envelope; the witness is the proof payload carried inside. |
proof:InhabitanceImpossibilityWitness |
An ontology closed-catalog primitive — a specialisation of proof:ImpossibilityWitness produced when the inhabitance search determines that the carrier of a type:ConstrainedType is empty. Carries property proof:contradictionProof → xsd:string ("The Lean 4 by-contradiction derivation over the predicate vocabulary attesting that no value tuple satisfies the constraint system"). The proof payload carried inside cert:InhabitanceImpossibilityCertificate. Per ADR-039 clause (1), the failure trace’s canonical-form encoding flows into proof:contradictionProof; the witness is the proof object distinct from the certificate envelope. |
predicate:InhabitanceDispatchTable |
An ontology closed-catalog primitive — a three-rule dispatch table routing inhabitance questions to specific deciders (TwoSatDecider, HornSatDecider, ResidualVerdictResolver per the three rules). Per ADR-039 clause (1), an application-supplied NerveResolver<H> impl MAY consult this dispatch table internally to route its inhabitance dispatch through the ontology-vetted decider hierarchy; the consultation is the resolver impl’s design choice, not a substrate requirement. |
trace:InhabitanceSearchTrace |
An ontology closed-catalog primitive — a subclass of trace:ComputationTrace specialised to inhabitance-search execution, recording the sequence of derivation:InhabitanceStep entries the resolver traversed. Per ADR-039 clause (1), Grounded::derivation().replay() — the trace recoverable from the catamorphism’s output per ADR-019’s anamorphism dual — populates cert:InhabitanceCertificate.cert:searchTrace for typed feature hierarchies whose admission relations are inhabitance questions. |
type:LessEqBound (semantic extension per ADR-038) |
A closed-catalog type:BoundShape individual with predicate form observable(datum) ⇐ bound for integer-valued observables. Used by hamming, depth, carry, and site-rank bound constraints. Byte-sequence-valued observables use type:LexicographicLessEqBound per ADR-040 instead. The closed BoundShape catalogue carries 7 individuals. |
| Per-ψ-stage resolver trait (wiki term for family (1) of the four-family resolver landscape per ADR-039) | The framework’s normative term for the eight ADR-036 resolver traits (NerveResolver<H>, ChainComplexResolver<H>, HomologyGroupResolver<H>, CochainComplexResolver<H>, CohomologyGroupResolver<H>, PostnikovResolver<H>, HomotopyGroupResolver<H>, KInvariantResolver<H>). Each is a per-value byte-buffer content provider for one of the resolver-bound ψ-Term variants per ADR-035. Sealed via __sdk_seal::Sealed; only the SDK resolver! macro emits impls. Per ADR-039 clause (2), these traits constitute one of four distinct resolver-trait families — they do not stand in a subclass relationship with the ontology’s resolver:Resolver hierarchy or the bridge/morphism resolver families; the four families coexist as parallel resolution categories operating at different layers. |
resolver:Resolver (ontology term — family (4) of the four-family resolver landscape per ADR-039) |
The ontology’s closed-catalog supertype — "A strategy for resolving a type declaration into a partition of the ring." Subclasses span 20+ resolution-strategy specifications at the ontology layer: resolver:DihedralFactorizationResolver, resolver:CanonicalFormResolver, resolver:EvaluationResolver, resolver:CompletenessResolver, resolver:WittLevelResolver, resolver:SessionResolver, resolver:TypeSynthesisResolver, resolver:IncrementalCompletenessResolver, resolver:MonodromyResolver, resolver:JacobianGuidedResolver, resolver:SuperpositionResolver, resolver:GroundingAwareResolver, resolver:MeasurementResolver, resolver:TowerCompletenessResolver, resolver:InhabitanceResolver, resolver:ResidualVerdictResolver, resolver:MultiplicationResolver, resolver:HomotopyResolver, resolver:ModuliResolver, and others. Per ADR-039 clause (2), this hierarchy is one of four distinct resolver-trait families; the four families operate at different layers in parallel resolution categories, not in a subclass relationship. The ontology’s resolution-strategy specifications are not surfaced as foundation traits — they may be consulted internally by application-supplied resolver impls in families (1), (2), (3) per application design. |
type:LexicographicLessEqBound (per ADR-040) |
The 7th individual in the closed BoundShape catalogue. Predicate form: observable(datum) ⇐ bound with byte-sequence comparison under canonical big-endian unsigned ordering — for fixed-length sequences identical to lexicographic order; for variable-length sequences lexicographic with shorter-prefixed-sequences-less-than-longer-sequences-with-matching-prefix. Distinguished from type:LessEqBound (integer-valued observables only). Use LexicographicLessEqBound for byte-sequence-valued observables (observable:AxisProjectionObservable per ADR-038 plus any future byte-sequence-valued Observable); the catalog declaration alone determines the comparison semantics — resolvers do not dispatch on observable type. The closed BoundShape catalogue: EqualBound, LessEqBound, GreaterEqBound, RangeContainBound, ResidueClassBound, AffineEqualBound, LexicographicLessEqBound. |
| ψ-stage typed-coordinate carriers (per ADR-041) | Nine #[repr(transparent)] newtype wrappers around byte slices, one per ψ-stage output shape: SimplicialComplexBytes<'a>(pub &'a [u8]) (ψ_1 output), ChainComplexBytes<'a> (ψ_2 output), HomologyGroupsBytes<'a> (ψ_3 output), BettiNumbersBytes<'a> (ψ_4 output), CochainComplexBytes<'a> (ψ_5 output), CohomologyGroupsBytes<'a> (ψ_6 output), PostnikovTowerBytes<'a> (ψ_7 output), HomotopyGroupsBytes<'a> (ψ_8 output), KInvariantsBytes<'a> (ψ_9 output — the κ-label carrier). Each is zero-cost at runtime (layout identical to &[u8]; type wrapper is purely compile-time) and provides type-system discrimination of ψ-stage outputs. The eight ψ-stage resolver traits per ADR-036 take the prior ψ-stage’s typed carrier as input (and &[u8] for NerveResolver's per-value input at ψ_1) and write the current stage’s bytes into a &mut [u8] output buffer (zero allocation). Cross-stage composition is type-checked at compile time. |
| InhabitanceCertificate<'a, T> (per ADR-042) | A foundation-declared zero-allocation typed view over &Grounded<T> per ADR-042, exposing the verdict-envelope coordinates from ADR-039’s mapping. #[repr(transparent)] so the view’s layout is identical to &Grounded<T>. Accessor methods: kappa_label() returns KInvariantsBytes<'_> per ADR-041 (the homotopy-classification structural witness at ψ_9); witness() returns WitnessValueTuple<'_> derived from Term::Nerve's 0-simplices at ψ_1 (the concrete cert:witness ValueTuple); search_trace() returns the recoverable Trace via Grounded::derivation().replay() (the cert:searchTrace audit trail); certified_type() returns the ConstrainedTypeShape::IRI (the cert:certifiedType reference). Constructed via Grounded::as_inhabitance_certificate(&self). Universal — available for any Grounded<T> regardless of whether the application’s admission relation is an inhabitance question; opt-in by call site. |
| InhabitanceImpossibilityCertificate<'a> (per ADR-042) | A foundation-declared typed view over &PipelineFailure per ADR-042, exposing the negative-verdict envelope’s proof payload from ADR-039’s mapping. Accessor contradiction_proof() returns the canonical-form encoding of the catamorphism’s failure trace (the proof:contradictionProof payload, suitable for Lean 4 by-contradiction reconstruction). Constructed via PipelineFailure::as_inhabitance_impossibility_certificate(&self) → Option<…> which returns Some(…) when the failure’s structural cause is "the constraint nerve has empty Kan completion" and None otherwise. Carries no allocation; views the existing PipelineFailure envelope’s payload. |
inhabitance::dispatch_through_table (per ADR-042) |
A foundation-provided helper per ADR-042 abstracting predicate:InhabitanceDispatchTable consultation. Application NerveResolver<H> impls invoke this helper from inside their resolve body to route inhabitance-style admission relations through the ontology-vetted three-rule dispatch table (TwoSatDecider, HornSatDecider, ResidualVerdictResolver). The helper returns either a SimplicialComplex byte serialization (positive verdict path) or a ShapeViolation with the canonical-form failure trace (negative verdict path). Opt-in — resolver impls that don’t consult predicate:InhabitanceDispatchTable need not use it; resolver impls whose constraint-set shapes don’t fit the three rule arms implement the admission-relation logic directly. |
| Verdict realization (wiki commitment per ADR-039) | The architectural mapping per ADR-039 clause (1) committing how the canonical k-invariants branch (per ADR-035) realizes the ontology’s three-primitive inhabitance verdict structure. For typed feature hierarchies whose admission relations are inhabitance questions: a successful Grounded<Output> IS the cert:InhabitanceCertificate envelope, carrying the κ-label as homotopy-classification structural witness (at ψ_9), a concrete cert:witness ValueTuple derivable from Term::Nerve's 0-simplices (at ψ_1), and cert:searchTrace realized as Grounded::derivation().replay(); an Err(PipelineFailure) realizes the cert:InhabitanceImpossibilityCertificate envelope, carrying proof:InhabitanceImpossibilityWitness as proof payload with proof:contradictionProof as the canonical-form encoding of the failure trace. The κ-label and cert:witness are different witness granularities the same canonical k-invariants branch produces at different stages; both flow into the certificate envelope’s payload properties. The mapping is structural — Grounded<Output> and Err(PipelineFailure) are the certificate envelopes; the κ-label, the 0-simplices, and the trace are the structural witnesses; no new substrate machinery is introduced. The framework’s verifiability commitment per ADR-001 + ADR-019 is preserved end-to-end. |
Generated from sources at UOR-Framework.wiki. Do not edit pages directly via the GitHub web UI — edits are overwritten by the next build. See README for the authoring workflow.