Understanding UOR
The Universal Object Reference is a formal ontology built on ring theory. Every computable object lives in the ring Z/(2n)Z — integers modulo a power of two. The framework specifies how objects are uniquely identified (content-addressed), decomposed (factorized under the dihedral group), and verified (certified by algebraic proofs).
Choose Your Path
The ontology spans algebraic foundations, computational pipelines, and formal verification. Start with the path closest to your background:
For Mathematicians
Begin with the algebraic substrate and build up to the full proof system.
For Engineers
Understand the pipeline, then dive into serialization formats and tooling.
For Ontologists
Start with the specification, then explore the formal structure.
The Resolution Pipeline
Every resolution passes through three stages: Define (kernel-space declarations), Resolve (bridge-space factorization), and Certify (attestation). Read the full pipeline guide →
Core Concepts
Deep-dive explanations connecting formal ontology definitions to the intuitions behind the framework:
- bridge Certification and Verification — The final stage of the PRISM pipeline is **Certify**: every resolution result must be attested with a machine-verifiable certificate before it leaves the pipeline. The cert namespace encodes this attestation layer.
- kernel Content Addressing — Content addressing is the foundational principle of UOR: an object is identified by *what it is*, not *where it is*. The u namespace formalizes this with the Element class and the ContentAddressed interface.
- bridge Homological Analysis — The homology and cohomology namespaces add an algebraic topology layer to UOR. When constraints interact in complex ways, topological invariants diagnose whether Resolution will converge or stall.
- user Morphisms and Transformations — The morphism namespace defines the maps between UOR objects. Where the kernel namespaces declare *what* objects are, and bridge namespaces compute *how* to resolve them, morphisms specify *how objects relate to each other* through structure-preserving transformations.
- bridge Observables & Measurement — The observable namespace defines what can be measured during resolution. Observables are bridge-space objects that quantify geometric, topological, and algebraic properties of ring elements and their types.
- bridge The Partition Decomposition — The partition namespace decomposes the address space into disjoint subsets. Every ring element is classified as irreducible, reducible, a unit, or exterior. This four-way decomposition is the structural backbone of the Resolve stage in the [PRISM](../pipeline/) pipeline.
- bridge Proofs, Derivations & Traces — The proof, derivation, and trace namespaces implement the certification pathway of the [PRISM](../pipeline/) pipeline. Every algebraic identity must be *proved*, every proof must be *derived* from axioms, and every derivation must be *traced* for reproducibility.
- bridge Resolution & Queries — Resolution is the core operation of the [PRISM](../pipeline/) pipeline's Resolve stage. A Query specifies what to resolve; a Resolver computes the answer by factorizing the input under the dihedral group D_{2^n}.
- kernel The Ring Substrate — Every UOR computation operates over a ring — specifically the modular integer ring Z/(2^n)Z, where n is determined by the Witt level. This document explains the ring structure, its physical motivation, and how it grounds the entire ontology.
- bridge Site Bundle Semantics — UOR organizes typed data using the mathematical structure of a site bundle. Understanding site bundles explains why types in UOR behave the way they do, and why the Partition exists as a structural separator between kernel and user concerns.
- user State, Sessions, and Accumulation — The state namespace models the mutable side of the UOR framework. While the kernel is immutable and the bridge is purely computed, state captures what happens when a resolver accumulates bindings across a sequence of queries.
- kernel Witt Levels — Witt levels W8--W32 are the four scaling tiers of the UOR Ring substrate. Every computation, identity, and proof in UOR is valid at one or more Witt levels. Understanding Witt levels is essential for reading the algebraic identities and their associated proofs.
Reference
- Namespaces — auto-generated reference for every namespace
- Identities — searchable browser for algebraic identities
- Dependency Graph — interactive namespace dependency explorer