Whether this module belongs to kernel-space (immutable, compiled), user-space (parameterizable, runtime), or bridge (kernel-computed, user-consumed). Values: 'kernel', 'user', 'bridge'.
Content-addressable identifiers represented as Braille strings. Each address is a sequence of Braille glyphs encoding a unique content-derived identifier.
A content-addressable identifier represented as a Braille string. Each Address uniquely identifies a piece of content via its Braille-encoded hash.
A single Braille cell encoding 6 bits of an address. The bijection between Braille cells and 6-bit values is the foundational encoding of the UOR content-addressing scheme.
The Braille string representation of an address. Each character in the string is a Braille glyph (cell).
The Unicode codepoint of a Braille glyph. Braille glyphs occupy the range U+2800–U+28FF.
The 6-bit integer value (0–63) encoded by this Braille glyph. The bijection maps each of the 64 Braille patterns to a unique 6-bit value.
The number of Braille glyphs in an address string.
Core value types and term language for the UOR ring substrate. Defines Datum (ring element), Term (syntactic expression), and the Ring container.
An element of the ring Z/(2^n)Z at a specific quantum level n. The primary semantic value type. Disjoint from Term: datums are values, terms are syntactic expressions that evaluate to datums.
A syntactic expression in the UOR term language. Terms are evaluated to produce Datums. Disjoint from Datum.
A three-component structure encoding an element's position in the UOR address space: stratum (ring layer), spectrum (bit pattern), and glyph (Braille address).
A term that directly denotes a datum value. A Literal is a leaf node in the term language — it refers to a concrete Datum via schema:denotes without being a Datum itself.
A term formed by applying an operation to one or more argument terms. The application's value is the result of evaluating the operator on the evaluated arguments.
The ambient ring Z/(2^n)Z at a specific quantum level n. The Ring is the primary data structure of the UOR kernel. Its two generators (negation and complement) produce the dihedral group D_{2^n} that governs the invariance frame.
The integer value of a datum element. For a Datum in Z/(2^n)Z, this is an integer in [0, 2^n).
The quantum level n of a datum, where the datum's ring is Z/(2^n)Z. Determines the bit width and modulus of the datum.
The ring-layer index of a datum, indicating its position in the stratification of Z/(2^n)Z.
The bit-pattern representation of a datum, encoding its position in the hypercube geometry of Z/(2^n)Z.
The Braille address associated with this datum, linking the algebraic value to its content-addressable identifier.
The operation applied in an Application term.
An argument term in an Application. The ordering of arguments follows rdf:List semantics.
The bit width n of the ring Z/(2^n)Z. Distinct from schema:quantum on Datum — ringQuantum is the container's bit width; datum quantum is a membership property.
The modulus 2^n of the ring. Equals 2 raised to the power of ringQuantum.
The generator element π₁ (value = 1) of the ring. Under iterated successor application, π₁ generates all ring elements.
The ring reflection involution: neg(x) = (-x) mod 2^n. One of the two generators of the dihedral group D_{2^n}.
The hypercube reflection involution: bnot(x) = (2^n - 1) ⊕ x. The second generator of the dihedral group D_{2^n}.
The datum value that a Literal term denotes. Bridges the Term/Datum disjointness: a Literal refers to a Datum without being one. Evaluation of a Literal produces its denoted Datum.
The unique generator of R_n under successor. Value = 1 at every quantum level. Under iterated application of succ, π₁ generates every element of the ring.
The additive identity of the ring. Value = 0 at every quantum level. op:add(x, zero) = x for all x in R_n.
Ring operations, involutions, algebraic identities, and the dihedral symmetry group D_{2^n} generated by neg and bnot.
An operation on the ring Z/(2^n)Z. The root class for all UOR kernel operations.
A unary operation on the ring: takes one datum and produces one datum.
A binary operation on the ring: takes two datums and produces one datum.
A unary operation f such that f(f(x)) = x for all x in R_n. The two UOR involutions are neg (ring reflection) and bnot (hypercube reflection).
An algebraic identity: a statement that two expressions are equal for all inputs. The critical identity is neg(bnot(x)) = succ(x) for all x in R_n.
A group: a set with an associative binary operation, an identity element, and inverses for every element.
The dihedral group D_{2^n} of order 2^(n+1), generated by the ring reflection (neg) and the hypercube reflection (bnot). This group governs the symmetry of the UOR type space.
The number of arguments this operation takes. 1 for unary operations, 2 for binary operations.
A description of the geometric role of this operation in the UOR ring and hypercube geometry. Examples: 'ring_reflection', 'hypercube_reflection', 'rotation', 'translation', 'scaling'.
Whether this binary operation satisfies op(x,y) = op(y,x) for all x, y in R_n.
Whether this binary operation satisfies op(op(x,y),z) = op(x,op(y,z)) for all x, y, z in R_n.
The identity element of this binary operation: the value e such that op(x, e) = op(e, x) = x for all x in R_n.
The inverse operation: the operation inv_op such that op(x, inv_op(x)) = e for all x, where e is the identity.
Ordered list of operations this operation is composed from. Uses rdf:List to preserve application order (first element applied innermost). E.g., succ = neg ∘ bnot is encoded as [op:neg, op:bnot] meaning neg applied to the result of bnot.
The left-hand side operation of an algebraic identity.
The right-hand side operation of an algebraic identity.
The quantifier scope: the variable(s) over which this algebraic identity holds (e.g., 'x ∈ R_n').
An operation that generates this group. The dihedral group D_{2^n} is generated by op:neg and op:bnot.
The number of elements in the group. For D_{2^n}, the order is 2^(n+1).
The group presentation (generators and relations). Annotation only — not used for reasoning. Example: ⟨r, s | r^{2^n} = s² = e, srs = r⁻¹⟩
Ring reflection: neg(x) = (-x) mod 2^n. One of the two generators of the dihedral group D_{2^n}. neg(neg(x)) = x (involution property).
Hypercube reflection: bnot(x) = (2^n - 1) ⊕ x (bitwise complement). The second generator of D_{2^n}. bnot(bnot(x)) = x.
Successor: succ(x) = neg(bnot(x)) = (x + 1) mod 2^n. The critical identity: succ is the composition neg ∘ bnot.
Predecessor: pred(x) = bnot(neg(x)) = (x - 1) mod 2^n. The inverse of succ. pred is the composition bnot ∘ neg.
Ring addition: add(x, y) = (x + y) mod 2^n. Commutative, associative; identity element is 0.
Ring subtraction: sub(x, y) = (x - y) mod 2^n. Not commutative, not associative.
Ring multiplication: mul(x, y) = (x × y) mod 2^n. Commutative, associative; identity element is 1.
Bitwise exclusive or: xor(x, y) = x ⊕ y. Commutative, associative; identity element is 0.
Bitwise and: and(x, y) = x ∧ y. Commutative, associative.
Bitwise or: or(x, y) = x ∨ y. Commutative, associative.
The foundational theorem of the UOR kernel: neg(bnot(x)) = succ(x) for all x in R_n. This identity links the two involutions (neg and bnot) to the successor operation, making succ derivable from neg and bnot.
The dihedral group of order 2^(n+1), generated by neg (ring reflection) and bnot (hypercube reflection). Every element of this group acts as an isometry on the type space 𝒯_n.
Information extraction queries. Users initiate queries; the kernel resolves them against the ring substrate.
A request for information from the UOR kernel. The root abstraction for all query types.
A query for the ring-coordinate position of a datum: its stratum, spectrum, and address within the ring geometry.
A query for a metric value between two datums: ring distance, Hamming distance, or their divergence (curvature).
A query for the canonical representation of a datum or term: its normal form under the active resolver strategy.
Type resolution strategies implementing the partition map Π : T_n → Part(R_n). Resolvers transform type declarations into ring partitions.
A strategy for resolving a type declaration into a partition of the ring. The kernel dispatches to a specific resolver based on the type's structure.
Resolves types by factoring the ring under dihedral group action. Identifies orbits under D_{2^n} to determine irreducibility boundaries.
Resolves types by computing canonical forms via term rewriting. Applies the critical identity and normalization rules to reduce terms to unique canonical representatives.
Resolves types by direct evaluation: applies operations to enumerate ring elements and classify them as irreducible, reducible, unit, or exterior.
The type of input this resolver accepts.
The type of output this resolver produces. For all UOR resolvers, the output is a partition:Partition.
A human-readable description of the resolution strategy this resolver implements.
The computational complexity of this resolver, expressed as a big-O string (e.g., 'O(n)', 'O(2^n)').
Runtime type declarations that parameterize the resolution pipeline. Types are declared by Prism applications and resolved to partitions of the ring.
A runtime type declaration. The root class for all UOR types. Each TypeDefinition, when resolved, produces a partition of the ring at the specified quantum level.
A primitive type defined by a fixed bit width. The carrier is the entire ring Z/(2^n)Z at the specified quantum level.
A product (Cartesian) type formed from multiple component types. The carrier is the product of the component carriers.
A sum (disjoint union) type formed from multiple variant types. The carrier is the disjoint union of the variant carriers.
A type formed by constraining a base type with a predicate. The carrier is the subset of the base carrier satisfying the constraint.
The bit width of a primitive type (the quantum level n). The carrier is Z/(2^n)Z.
The base type that a constrained type restricts.
The constraint predicate applied to the base type. Expressed as a string in the Prism constraint language.
The content-derived address of this type definition, uniquely identifying the type in the UOR address space.
Irreducibility partitions produced by type resolution. A partition divides the ring into four disjoint components: Irreducible, Reducible, Units, and Exterior.
A four-component partition of R_n produced by resolving a type declaration. The four components — Irreducible, Reducible, Units, Exterior — are mutually disjoint and exhaustive over the carrier.
A single component of a partition: a set of datum values belonging to one of the four categories.
The set of irreducible elements under the active type: elements whose only factorizations involve units or themselves. Analogous to prime elements in a ring.
The set of reducible non-unit elements: elements that can be expressed as a product of two or more non-unit elements.
The set of invertible elements (units) in the carrier: elements with a multiplicative inverse. In Z/(2^n)Z, the units are the odd integers.
Elements of R_n that fall outside the active carrier — i.e., outside the type's domain. These are ring elements that do not participate in the current type resolution.
The irreducible component of this partition.
The reducible component of this partition.
The exterior component of this partition.
A datum value belonging to this partition component.
The number of elements in this partition component. The cardinalities of the four components must sum to 2^n.
The irreducible density of this partition: |Irr| / |A|, where A is the active carrier.
The type declaration that was resolved to produce this partition.
The quantum level n at which this partition was computed. The ring has 2^n elements at this level.
Observable quantities and metrics computed by the UOR kernel. Includes ring-metric, Hamming-metric, curvature, holonomy, and catastrophe-theoretic observables.
A measurable quantity in the UOR Framework. All observables are kernel-computed and user-consumed.
An observable measuring stratum-level properties: position within the ring's layer structure.
An observable measuring geometric distance between ring elements under a specific metric.
An observable measuring properties of paths through the ring: path length, total variation, winding number.
An observable measuring cascade properties: the length and count of operation sequences.
An observable measuring catastrophe-theoretic properties: thresholds at which qualitative changes occur in the partition.
An observable measuring the curvature of the UOR geometry: the gap between ring-isometry and Hamming-isometry for a given transform.
An observable measuring holonomy: the accumulated transformation when traversing a closed path in the ring.
Distance between two ring elements under the ring metric: d_R(x, y) = |x - y| mod 2^n.
Distance between two ring elements under the Hamming metric: the number of bit positions where they differ.
The metric incompatibility between two ring elements: the divergence between their ring-metric and Hamming-metric distances, measuring geometric curvature.
The difference in stratum between two ring elements.
The sequence of strata traversed by a path through the ring.
The length of a path through the ring, measured in operation steps.
The total variation of a path: the sum of metric distances between consecutive elements.
The winding number of a closed path: the number of times the path wraps around the ring.
The number of operation applications in an operation cascade.
The number of distinct cascades in a computation.
A critical value at which a qualitative change occurs in the partition structure.
The number of catastrophe events (qualitative partition changes) in a computation.
The commutator [f, g](x) = f(g(x)) - g(f(x)) of two operations, measuring their non-commutativity.
The integrated curvature over a region of type space: the total metric incompatibility accumulated.
The monodromy of a closed path: the net transformation accumulated when traversing a loop in the type space.
The parallel transport of a vector along a path: the canonical lift of the path to the tangent bundle of the ring.
An element of the dihedral group D_{2^n} acting on the type space. Each dihedral element induces an isometry of 𝒯_n.
The numeric value of an observable measurement.
The unit of measurement for this observable (e.g., 'bits', 'ring_steps', 'dimensionless').
The source object of this measurement (datum, partition, or path start point).
The target object of this measurement (for metrics and path-end measurements).
Kernel-produced verification proofs attesting to algebraic properties of UOR objects and operations.
A kernel-produced attestation that a given algebraic property holds. The root class for all proof types.
A proof of coherence: the type system and ring structure are mutually consistent at a given quantum level.
A proof of the critical identity: neg(bnot(x)) = succ(x) for all x in R_n. This is the foundational theorem of the UOR kernel.
Supporting data for a proof: specific examples, counter-examples checked, or intermediate computation results.
The quantum level at which this proof was verified.
Whether this proof has been verified by the kernel.
The time at which this proof was produced.
Human-readable statement of the critical identity proven. E.g., 'neg(bnot(x)) = succ(x) for all x in R_n'.
A specific input value used as a witness for the critical identity check.
Whether the identity neg(bnot(x)) = succ(x) holds for this specific witness.
The algebraic identity this proof establishes. Provides a canonical object reference alongside the existing proof:criticalIdentity string property, which remains for human readability.
Computation witnesses recording term rewriting sequences from original terms to their canonical forms.
A complete term rewriting witness: the full sequence of rewrite steps transforming an original term into its canonical form.
A single rewrite step in a derivation: the application of one rewrite rule to transform a term.
Metrics describing the size and complexity of a term.
The term at the start of the derivation, before any rewriting.
The canonical form produced at the end of the derivation.
The datum value obtained by evaluating the canonical term.
Metrics for the canonical term produced by this derivation.
The rewrite rule applied in this step (e.g., 'critical_identity', 'involution', 'associativity').
The total number of rewrite steps in this derivation.
The number of nodes in the canonical term's syntax tree.
Execution traces recording the sequence of kernel operations, intermediate results, and accumulated metrics for a computation.
A complete record of a kernel computation: the input, output, every operation step, and accumulated metrics.
A single step in a computation trace: one operation applied to produce one output from one or more inputs.
Summary metrics for a computation trace: total steps, accumulated ring distance, and accumulated Hamming distance.
The monodromy accumulated by this computation: the net dihedral group element produced by the full operation sequence.
The input datum of this computation step.
The output datum of this computation step.
The operation applied in this computation step.
The zero-based sequential index of this step within its trace.
Total number of computation steps in this trace.
Total ring-metric distance accumulated across all steps.
Total Hamming-metric distance accumulated across all steps.
Kernel-produced attestation certificates for transforms, isometries, and involutions. Each certificate verifies that a specific structural property holds.
A kernel-produced attestation. The root class for all certificate types.
A certificate attesting to the properties of a morphism:Transform. Certifies that the transform maps source to target correctly.
A certificate attesting that a morphism:Isometry preserves metric distances. Certifies the transform is a metric isometry with respect to the specified metric.
A certificate attesting that an operation is an involution: f(f(x)) = x for all x in R_n.
The type of transform this certificate attests to (e.g., 'isometry', 'embedding', 'action').
The verification method used to produce this certificate (e.g., 'exhaustive_check', 'symbolic_proof', 'sampling').
The operation this certificate applies to.
Whether this certificate has been verified by the kernel.
The quantum level at which this certificate was produced.
The time at which this certificate was issued.
Runtime abstractions for maps between UOR objects: transforms, isometries, embeddings, and group actions. The foundation provides the vocabulary; Prism writes the sentences.
A map between UOR objects. The root abstraction: source, target, and optionally what structure (if any) is preserved. This is what cert:TransformCertificate certifies.
A transform that preserves metric structure with respect to a specified metric. In UOR, isometry is metric-relative: neg is a ring isometry, bnot is a Hamming isometry. A transform can be an isometry with respect to one metric but not the other. This is what cert:IsometryCertificate certifies.
An injective, structure-preserving transform across quantum levels. The canonical instance is the level embedding ι : R_n → R_{n'} (n < n'), which preserves addition, multiplication, and content addressing.
The mechanism by which a group applies transforms systematically to a set. Each group element induces a transform of the set. The dihedral action on type space is an action by isometries — every element of D_{2^n} produces an isometric transform of 𝒯_n.
The structure preserved by this transform (if any). E.g., a ring homomorphism preserves addition and multiplication.
The specific metric this isometry preserves. Points to observable:RingMetric or observable:HammingMetric. A transform that preserves both is an isometry of the full UOR geometry. A transform that preserves one but not the other has nontrivial curvature — observable:CurvatureObservable measures this gap.
The quantum level n of the source ring for an embedding.
The quantum level n' of the target ring for an embedding. Must satisfy n' > n (embeddings go to larger rings).
The set being acted upon by this group action.
Whether every transform induced by this action is an isometry. True for the dihedral action on 𝒯_n (Frame Theorem).
The computation trace that realized this transform at runtime. A Transform is an abstraction; a trace is the kernel's record of how it was executed via concrete operations.
Parameterized address spaces, context management, binding lifecycle, and state transitions. The user-space overlay onto the kernel's read-only ring substrate.
A bounded set of populated UOR addresses. The parameter space for a resolution cycle. Contexts hold bindings that map addresses to datum values.
The association of a datum value with an address in a context. The write primitive: creating a binding populates an address.
The visibility boundary determining which bindings are in scope for a given resolution. A frame is a view into a context: it selects which bindings the resolver sees.
A state change: the transformation of one context into another through binding or unbinding. The sequence of transitions is the application's computation history.
The UOR address being bound in this binding.
The datum value bound to the address in this binding.
The type under which this binding's datum is resolved.
The time at which this binding was created.
The maximum number of bindings this context can hold.
The content-derived address of this context, uniquely identifying its current state in the UOR address space.
The quantum level of this context's address space.
The bindings currently in scope for this frame.
The constraint determining which bindings from the context are visible in this frame.
Bindings added to the context in this transition.
Bindings removed from the context in this transition.
The computation trace recording the kernel operations that effected this state transition.