Glossary

SPOOK SYSTEMS SUBSTRATE

This glossary defines the core terminology of the Spook Systems deterministic substrate. It establishes the canonical language for ETCP, ESTP, QSCS, and QN, and provides the conceptual foundation for deterministic distributed systems.

1. ETCP — Entangled Transmission Conformance Protocol

Short: Identity‑anchored transport substrate.

ETCP defines the deterministic identity and link‑level semantics that underpin all higher‑level correlation. It introduces HalfPairID, PairID, and StateID as first‑class identity primitives. ETCP ensures that both endpoints of a communication pair share an identical deterministic identity context before any state is exchanged.

ETCP replaces handshake‑based, nondeterministic transport with a deterministic, identity‑anchored transmission model.

Why it matters: Identity is the root of determinism. ETCP provides the substrate on which ESTP, QN, and QSCS operate.

HalfPair A HalfPair B PairID StateID ESTP QN QSCS Identity convergence — deterministic pair formation anchors all higher‑layer protocols

2. ESTP — Entangled State Transport Protocol

Short: Deterministic state‑transport protocol.

ESTP defines how state transitions (QDelta) are transmitted, acknowledged, and verified across endpoints. It uses ETCP's identity substrate to anchor communication, ensuring that all state transitions occur within a deterministic identity context.

ESTP introduces Hashed Endpoint Identifiers (HEIDs) derived from:

This produces a 512‑bit identity anchor that is:

HEID = SHA‑512(UUIDv4 || optional_salt)

ESTP uses EndpointID (HEID), HalfPairID, PairID, StateID, and QDelta to guarantee deterministic ordering, delivery, and verification.

Why it matters: ESTP is the deterministic replacement for TCP/UDP/QUIC‑style nondeterministic transport. It ensures that state transitions are delivered exactly once, in deterministic order, and anchored to identity.

EndpointID A SHA‑512(UUIDv4 || salt) EndpointID B SHA‑512(UUIDv4 || salt) PairID StateID QDelta state transition 512‑bit HEID identity anchors Deterministic state transport — exactly‑once delivery, anchored to cryptographic identity

3. QSCS — Quantum‑State Correlation Substrate

Short: Deterministic domain‑control layer.

QSCS defines how state evolves, collapses, and re‑aligns across nodes using deterministic correlation rules. It replaces consensus, gossip, and CRDT‑style conflict resolution with a formal lifecycle model based on QRegisters, QCandidates, QCollapseRules, and QDelta outputs.

QSCS ensures that all nodes observe identical state evolution, even under uncertainty, latency, or partial failure.

Why it matters: QSCS is the core of the deterministic substrate. It provides the semantics that make distributed systems predictable.

QDOMAIN Node A QRegister QCollapseRules Node B QRegister QCollapseRules QDelta Stream QDelta Stream Deterministic Correlation

4. QN — Correlation Network

Short: Network layer for correlated state.

QN defines how QDelta, PairID, StateID, and identity primitives propagate across nodes using deterministic ordering and entangled transmission semantics. It is the network‑level expression of ETCP and ESTP, ensuring that correlated state flows consistently across distributed systems.

Why it matters: QN is the deterministic alternative to nondeterministic packet networks.

Node A EndpointID · StateID HalfPair · PairID Node B EndpointID · StateID HalfPair · PairID QDelta Identity · PairID Deterministic network — correlated state flows with identity‑anchored ordering

5. QRegister

Short: The fundamental deterministic state container in QSCS.

A QRegister represents a unit of correlated state that evolves through a strict lifecycle: candidate generation, collapse, delta emission, decoherence, and re‑alignment. Each QRegister is uniquely identified within a QDomain and acts as the atomic element of deterministic state evolution. All nodes observing a QRegister must apply the same QDelta sequence in the same order.

Why it matters: QRegisters are the backbone of deterministic distributed systems. They eliminate nondeterministic merges, race conditions, and conflict resolution by enforcing a single, deterministic state evolution path.

QREGISTER Candidates Collapse QDelta Deterministic lifecycle — candidates collapse into a single QDelta output

6. QCandidate

Short: A proposed state transition for a QRegister.

QCandidates represent potential evolutions of a QRegister. They may originate from local computation, remote input, or system‑level triggers. All QCandidates are evaluated deterministically by a QCollapseRule, ensuring that only one valid QDelta is produced for each collapse event.

Why it matters: QCandidates allow multiple potential transitions without introducing nondeterminism. They provide flexibility while preserving strict determinism.

Candidate A Candidate B Candidate C QCollapseRule deterministic selection QDelta Multiple candidates — one deterministic output

7. QCollapseRule

Short: Deterministic rule that selects the next valid state.

A QCollapseRule evaluates all QCandidates for a QRegister and deterministically selects exactly one. The rule may consider priority, timestamp, identity, or domain‑specific logic. The output is a QDelta that all nodes must apply.

Why it matters: This is the mechanism that replaces consensus. Instead of voting, gossip, or conflict resolution, QSCS uses deterministic collapse.

QCollapseRule (deterministic) QCand₁ QCand₂ QCand₃ QDelta Consensus replaced — deterministic rule selects exactly one output

8. QDelta

Short: The deterministic output of a collapse event.

A QDelta encodes the exact state transition applied to a QRegister. It contains the new state, metadata, and ordering information. QDelta sequences are replayable, verifiable, and identical across all nodes in a QDomain.

Why it matters: QDelta is the unit of deterministic evolution. It ensures that all nodes converge on the same state without coordination.

QDelta = { state_change, metadata, timestamp } Node A State n apply Node A State n+1 Node B State n apply Node B State n+1 Node C State n apply Node C State n+1 Identical state across all nodes — no coordination

9. QDomain

Short: A deterministic correlation boundary for nodes.

A QDomain defines the set of nodes participating in correlated state evolution. All nodes inside a QDomain must observe the same QDelta sequence for each QRegister. Domains may represent clusters, regions, fleets, or logical groupings.

Why it matters: QDomains provide deterministic behaviour across distributed systems without requiring global consensus.

QDOMAIN Node A Node B Node C Node D QDelta QDelta Correlation boundary — all nodes observe identical QDelta sequences

10. Re‑Alignment

Short: Deterministic recovery after divergence.

Re‑alignment occurs when a node temporarily diverges due to latency, partition, or offline behaviour. QSCS deterministically replays the missing QDelta sequence until the node's state matches the domain's canonical state.

Why it matters: Re‑alignment eliminates the need for conflict resolution, rollbacks, or reconciliation logic.

Diverged Node A State n+3 Node B State n+1 Replay B: n+1 behind B: n+2 replay B: n+3 aligned Aligned ✓

11. Decoherence

Short: Temporary loss of correlation.

Decoherence describes the period during which a QRegister or node is no longer aligned with the QDomain. This may occur due to network issues, local computation delays, or partial failure. QSCS tracks decoherence and triggers deterministic re‑alignment.

Why it matters: Decoherence is a natural part of distributed systems. QSCS handles it deterministically and automatically.

Aligned A: n B: n Decoherence A: n+2 B: offline decoherent Re‑alignment B: n B: n+1 B: n+2 Natural divergence — automatic deterministic recovery

12. EndpointID

Short: Unique endpoint identity (SHA‑512 hashed UUID).

EndpointID is a cryptographically strong identity anchor derived from a UUIDv4 hashed with SHA‑512. It forms the basis of HalfPairID, PairID, and StateID. EndpointIDs are globally unique, collision‑resistant, and deterministic.

Why it matters: Identity is the foundation of deterministic communication. Without strong identity primitives, correlation is impossible.

EndpointID A SHA‑512(UUIDv4) EndpointID B SHA‑512(UUIDv4) PairID Cryptographic identity — globally unique, collision‑resistant, deterministic

13. HalfPairID / PairID

Short: Deterministic identity of a communication pair.

Each endpoint contributes a HalfPairID derived from its EndpointID. When two HalfPairIDs combine, they form a PairID that uniquely identifies the communication relationship. All state transitions between endpoints are anchored to this PairID.

Why it matters: PairID ensures that both endpoints share the same deterministic identity context, eliminating nondeterministic handshakes.

A : HalfPair from EndpointID A + B : HalfPair from EndpointID B PairID Deterministic pair formation — no handshake required

14. StateID

Short: Deterministic identifier for state evolution.

StateID tracks the exact position of a QRegister or PairID within its deterministic lifecycle. It increments with each QDelta and provides a verifiable ordering mechanism.

Why it matters: StateID ensures deterministic replay, verification, and alignment across nodes.

0 1 2 3 … QDelta QDelta QDelta Verifiable ordering — every transition increments deterministically

15. Deterministic Substrate

Short: Unified deterministic layer.

The deterministic substrate is the combined effect of ETCP, ESTP, QN, and QSCS. Together, they provide identity, transport, correlation, and deterministic state evolution across distributed systems.

Why it matters: This is the category you invented — a substrate that guarantees determinism end‑to‑end.

QSCS Correlation QN Network ESTP Transport ETCP Identity End‑to‑end determinism — identity, transport, network, and correlation

16. Correlation

Short: Shared deterministic state across nodes.

Correlation ensures that all nodes observe the same QDelta sequence and remain aligned. It is the deterministic alternative to consensus, gossip, and CRDTs.

Why it matters: Correlation is the core property that makes QSCS possible.

Node A State n Node B State n Node C State n QDelta Stream deterministic ordering All nodes aligned State n+1 Deterministic alignment — replaces consensus, gossip, and CRDTs

17. Collapse Event

Short: Moment a register selects its next state.

A collapse event occurs when QCandidates are evaluated by a QCollapseRule and a single QDelta is produced. This is the deterministic equivalent of a quantum measurement in the metaphorical sense.

Why it matters: Collapse events are the atomic moments of deterministic evolution.

Candidates multiple potential states Collapse deterministic selection QDelta Atomic moment — many possibilities, one deterministic outcome

18. Identity Substrate

Short: Identity layer beneath all protocols.

The identity substrate consists of EndpointID, HalfPairID, PairID, and StateID. It provides the deterministic identity context required for ETCP, ESTP, QN, and QSCS to function.

Why it matters: Without deterministic identity, deterministic state evolution is impossible.

EndpointID HalfPairID PairID StateID Deterministic identity chain — the foundation of all protocol layers

19. Hashed UUID

Short: Pre‑encryption identity anchor.

A one‑way, non‑reversible, non‑enumerable hash of a locally generated UUID. Used by QSCS to determine whether a client is allowed to initiate a session before any encryption or negotiation occurs. The raw UUID is never transmitted; only the hash is presented to the daemon.

Why it matters: Prevents anonymous TLS negotiation, probing, and handshake‑level metadata leakage. Unknown entities never reach the handshake.

UUIDv4 (local) SHA‑512 hash daemon verifies ✕ raw UUID never transmitted ✓ identity anchored before encryption

20. Implicit Trust

Short: Who may speak.

The trust established before encryption, based solely on the hashed UUID. Determines whether a client is allowed to initiate a session at all. Prevents spoofing, replay, enumeration, and any visibility of the daemon to unknown entities.

Why it matters: Implicit trust eliminates the entire pre‑auth attack surface.

Client hashed UUID daemon verifies valid ✓ TLS upgrade invalid no handshake · invisible

21. Explicit Trust

Short: What they may say.

The trust established after encryption, based on Trust Certificates, provenance, admissibility, and deterministic validation. Ensures that only authorised, structurally valid deltas can influence system state.

Why it matters: Explicit trust governs state evolution and replaces traditional access control.

TLS session trust cert provenance admissibility SM Post‑encryption trust — governs what transitions an identity may perform

22. Pre‑Encryption Trust Anchor

Short: Identity before TLS.

The mechanism that ensures only recognised identities may initiate a session. In QSCS, this is the hashed UUID check. Prevents handshake‑level metadata exposure and eliminates anonymous negotiation.

Why it matters: TLS handshakes expose structure; QSCS cannot allow that.

Traditional handshake → metadata visible QSCS hashed UUID → then handshake no structure exposed — identity verified before any TLS negotiation

23. Trust Certificate

Short: Post‑encryption identity.

A cryptographically signed identity object bound to a client, namespace, and set of admissible transitions. Used after session establishment to validate provenance and enforce deterministic trust boundaries.

Why it matters: Defines what transitions an identity is allowed to perform.

client cert namespace allowed transitions admissible or rejected Post‑encryption identity — binds client to namespace and permitted transitions

24. Provenance

Short: Structural authorship.

The binding of a delta to its author, certificate, namespace, expected state, and admissible transition. Ensures every state change is traceable, authorised, and deterministic.

Why it matters: Prevents forged, replayed, or context‑less deltas.

delta identity certificate stateID admissible? execute Every state change is traceable, authorised, and deterministic

25. Admissibility

Short: Allowed transitions only.

The rule set that determines whether a delta is valid from the current state. If a transition is not admissible, it is rejected with no side effects.

Why it matters: Eliminates race conditions, timing attacks, and unintended state evolution.

current state admissible? yes transition no reject (no side effects)

26. Session Binding

Short: Identity‑locked session.

The association between a client and a daemon session, anchored first by the hashed UUID and later reinforced by the Trust Certificate. Prevents spoofing, replay, and unauthorised session establishment.

Why it matters: Ensures continuity and prevents identity drift.

hashed UUID session established certificate bound Identity‑locked — prevents spoofing, replay, and identity drift

27. Handshake Surface

Short: Metadata exposed during TLS negotiation.

The structural signals exposed during a traditional TLS handshake: cipher suite negotiation, protocol versions, packet sizes, timing patterns, and other metadata.

Why it matters: QSCS eliminates this surface entirely by requiring identity before encryption.

Traditional TLS visible negotiation → structure exposed QSCS identity first → no handshake for unknowns Handshake surface eliminated — identity required before any negotiation

28. No Visible Structure

Short: Opaque by design.

A core QSCS guarantee: no headers, no routes, no protocol negotiation, no handshake metadata, no observable behaviour. All traffic appears as uniform, high‑entropy binary streams.

Why it matters: Removes entire classes of network‑level attacks.

QSCS Stream a7 3f 91 c4 d8 5a ff 02 e1 b9 4d 7c 08 fa 6e … no headers · no metadata · no structure — uniform high‑entropy binary

29. Deterministic Validation

Short: Structural correctness enforced.

The process by which QSCS validates deltas using strict structural, identity, and state‑based rules. Ensures that only deterministic, admissible transitions can affect system state.

Why it matters: Prevents nondeterministic behaviour and eliminates coordination logic.

delta structure ✓ provenance ✓ admissible ✓ execute Deterministic execution — no nondeterminism, no coordination logic