Universal Ideal Standards & Universal Interaction Platform — UIS / UIP v0.1.0
A constitutional doctrine of the ecosystem: what should conform, and how conforming systems interact — standards that define correctness, protocols that achieve it, and a constitutional lifecycle that keeps them apart.Status: Doctrine Constitutional dependencies: USCP (six primitives) · URS v0.1.0 (specs.initialcore.net/urs.html) · CORE-LD v0.1.0 · UAM v0.2.0 (specs.initialcore.net/uam.html) · USE v0.1.0 (specs.initialcore.net/use.html) Scope: The entire ICore ecosystem — every standard, protocol, implementation, and conformance exercise Registry prefixes: UIS · UIP
# Part I — The Doctrine
1. The Constitutional Lifecycle
ICore is not a collection of technologies — it is a constitutional lifecycle. Every layer answers a distinct constitutional question, and together they form a continuous pipeline from first principles to trustworthy operation:
| Constitutional question | Layer | Existing instance |
|---|---|---|
| What must always be true? | **USCP** (Universal Sovereign Constitutional Principles) | The six primitives |
| What should conform? | **UIS** (Universal Ideal Standards) | URS, CORE-LD family, UAS, USDS |
| How is it represented? | **URS** — canonical representation, spanning the lifecycle | URS v0.1.0 (23 invariants) |
| How do conforming systems interact? | **UIP** (Universal Interaction Platform) | UCN substrate, libisp, LD payload semantics |
| What should be selected or decided? | **USE** (Universal Selection Engine) | USE v0.1.0 (USE-1..6) |
| How are constitutional artifacts forged? | **UCF** (Universal Constitutional Forge) | Forge, attestation, registry |
| How are they executed consistently? | **USR / CoreFab** | CoreFab runtime |
Build around constitutional responsibilities, not technological dependencies. Technologies become replaceable implementations; the constitutional pipeline remains stable.
2. UIS — What Should Conform
UIS defines the ideal specifications and conformance targets derived from the principles. Standards define what is correct: data models, representations, APIs, security, interoperability, conformance criteria. URS, the CORE-LD family, UAS, and USDS are UIS instances — each a specification of what a conforming artifact is.
Standards evolve slowly. A standard changes only by constitutional process — versioned, never rewritten. Stability is the point: the deeper the layer, the slower it moves.
3. UIP — How Conforming Systems Interact
UIP governs interaction — exchange, negotiation, synchronization, verification, coordination. Protocols define how correctness is achieved during interaction. UIP is the Universal Interaction Platform: the constitutional interaction layer, independent of any transport, runtime, language, or network.
- libp2p is one UIP transport profile (the UCN substrate).
- QUIC, WebRTC, WebTransport are future transport profiles.
- UIP itself never changes when a transport changes.
The most valuable lesson from the networking ecosystem, elevated into a constitutional principle:
**One constitutional specification → Multiple implementations → Shared conformance → Guaranteed interoperability.**
This is more general than libp2p: it applies to every ICore layer, and the kernel already executes it — cross-implementation tests (21 green) prove interop by shared conformance, not identical code.
4. The libp2p Boundary — Already Drawn
libp2p standardizes communication; ICore standardizes trustworthy intelligence. libp2p leaves meaning, identity semantics, constraints, policies, trust, proofs, decisions, knowledge, memory, reasoning, execution, and governance to the application. Those are precisely the layers ICore already occupies: URS/CORE-LD (meaning), UAS (identity), TRUST-LD/POLICY-LD (trust and policy), MEMORY-LD (memory), USE (decision), UAM (application governance). Networking is one interchangeable implementation beneath constitutional intelligence — never a dependency of it.
5. Evolution Rates — the Ecosystem Discipline
| Layer | Evolves | Boundary discipline |
|---|---|---|
| Principles (USCP) | Rarely | Principles never prescribe implementations |
| Standards (UIS) | Slowly, by constitutional process | Standards never prescribe protocols |
| Protocols (UIP) | When interaction patterns change | Protocols never prescribe languages or runtimes |
| Implementations | Rapidly | Always replaceable; never elevated to requirements |
| Conformance (UCF) | Stable, measurable | Objective and machine-verifiable |
This is the same philosophy behind the Internet (IETF), the Web (W3C), and Unicode — applied through a constitutional lens. Strict about outcomes, tolerant about methods: the ecosystem can evolve for decades without accumulating complexity or technology lock-in.
# Part II — The Specification
1. Classification
UIS instances (standards — what should conform): URS, CORE-LD family (INPUT/MEMORY/POLICY/TRUST-LD, JSON/CBOR bindings, canonicalization), UAS, USDS. Each declares its derivation chain and conformance suite.
UIP instances (protocols — how systems interact): UCN substrate (libp2p profile), libisp (sovereign protocol, ConstitutionalLog), LD payload semantics over any transport. Each declares its transport profile and interoperability tests.
New artifacts are classified at minting: a standard enters the UIS registry; an interaction rule enters the UIP registry; anything else is an implementation, a preference, or a proposal.
2. UIS Invariants
| # | Invariant | Mechanical verification |
|---|---|---|
| UIS-1 | **Derivation.** Every standard traces through the constitutional chain (USCP → … → its layer) and declares its position. | Derivation table present in the standard's record (UCF) |
| UIS-2 | **Conformance targets.** Every standard defines machine-verifiable conformance criteria; a standard without a conformance suite is a proposal. | Conformance suite exists and runs green |
| UIS-3 | **Standards do not prescribe protocols.** A standard specifies what conforms; it never mandates how interaction occurs. | No transport/language/runtime mandate in standard text (CCA §4 check) |
| UIS-4 | **Stability by process.** Standards change only by versioned constitutional process — never by rewrite. | Version history; prior versions remain attested |
3. UIP Invariants
| # | Invariant | Mechanical verification |
|---|---|---|
| UIP-1 | **Transport independence.** The interaction layer is independent of any transport, runtime, language, or network. | Transport profiles declared; core layer has no transport import |
| UIP-2 | **One spec, many implementations.** Each UIP protocol has one specification and at least two independent implementations with shared conformance. | Cross-implementation suite green (kernel `cross-implementation`, 21 tests) |
| UIP-3 | **Interoperability by conformance.** Interop is guaranteed by shared conformance, never by identical code. | Interop exercised via conformance, not code sharing |
| UIP-4 | **Meaning on the wire.** Constitutional interaction carries constitutional meaning: payloads validate against URS/CORE-LD before action. | Payload validation precedes any protocol action (USE-1 chain) |
| UIP-5 | **Protocols do not prescribe runtimes.** Implementations remain replaceable adapters. | Adapter boundary declared; substitution demonstrated (UAM-6) |
4. Four-Question Stress Test (condensed)
| Claim | What invariant | How verified | If absent |
|---|---|---|---|
| Standards define correctness | UIS-1, UIS-2 | Conformance suites green | Standards become opinions |
| Protocols achieve correctness | UIP-3, UIP-4 | Cross-impl + payload validation | Interop becomes faith |
| Transport independence | UIP-1 | Profile registry, no core imports | Lock-in to a network stack |
| Evolution-rate separation | UIS-3, UIP-5, UIS-4 | Boundary checks at minting | Complexity and lock-in accumulate |
5. Freeze Gate
UIS/UIP v0.1.0 flips Doctrine → Frozen upon the first external UIP conformance exercise — the W3C DID/VC interop profile — running green against UIP-1..5, together with the CodeLab (USE's gate). Until then, Doctrine. Claim discipline holds: self-conformance certifies internal consistency; external review certifies nothing until it runs.
End of UIS/UIP Doctrine v0.1.0 — August 2, 2026. Doctrine. Derives from USCP + URS v0.1.0 + CORE-LD v0.1.0 + UAM v0.2.0 + USE v0.1.0.