Sov · Research

The Physics of Memory

Six laws governing how a sovereign system remembers, forgets,
and decides what it is allowed to know.

B. — March 2026

Overview

The S(R, F) Series asks: what is the shape of coherence? One rigid element, one fuzzy element, one binding — the minimal pattern that generates authorization, time, identity, truth, governance, action, and geometry.

This paper asks the complementary question: what happens inside the shape? When you fill S(R, F) with actual data — millions of vectors representing documents, decisions, identities, and events — what are the physical laws that govern how that data is stored, retrieved, aged, protected, audited, and eventually forgotten?

There are six. Each is a conservation law — something that the system preserves even as everything else changes. Together, they define the physics of sovereign memory.

Law	Conserved Quantity	Schema
I. Compression	Ranking order	f32 → i8 : rank preserved
II. Opacity	Governance budget	mask & W → O(1) per entry
III. Decay	Temporal ordering	w(t) = e^−λΔt → monotonic fade
IV. Integrity	Hash chain	H(n) = BLAKE3(n \|\| H(n−1)) → tamper-evident
V. Echo	Institutional memory	Active → Modified → Retired → echo
VI. Composition	Independence	9 nodes · 0 circular deps · ∞ configurations

Each law preserves one thing while everything else changes. Together they define a memory that is governed, temporal, auditable, and modular.

Law I

Compression Preserves Order

Can you lose precision without losing meaning?

q_i = clamp( round( v_i × 127 ), −127, +127 )

A 768-dimensional embedding vector occupies 3,072 bytes as 32-bit floats. Multiply every component by 127, round, clamp to [-127, +127], and store as a signed byte. The vector is now 768 bytes. 75% of the memory is gone.

The question is whether the compression destroys the thing you actually need. You don't need the exact distances. You need the ranking — which vectors are closest to the query. If the nearest neighbor in f32 space is still the nearest neighbor in i8 space, the quantization is lossless in the only dimension that matters.

Noise Level

Dimensions

Rank Correlation—

Max Error—

RAM Saved—

Fig. I — Twenty random vectors. Left: f32 L2 distances. Right: i8 L2 distances. Lines cross when rank order changes. Drag noise to see when compression starts losing meaning.

The conserved quantity is ranking order. At low noise — the regime where real embedding models operate — the quantized distances produce the same top-k results as the originals. The absolute distances change. The relative ordering is preserved.

L2²(a, b) = Σ (a_i − b_i)² — computed in i64 arithmetic

SIG-S14 — zero floating-point on the hot path. Pure integer ALU.

The deeper principle: meaning lives in relative distance, not absolute position. Two vectors that are 0.0312 apart and two that are 4.0 apart occupy the same informational relationship — one is nearer than the other. Quantization preserves relationships. It discards coordinates.

Law II

Opacity Preserves the Governance Budget

Can access control cost nothing?

allowed = ( entry.mask & query.mask ) == query.mask

Every vector database does access control backwards. Search first — compute expensive distances against every vector in the corpus — then filter out the results the user isn't allowed to see. The governance cost is O(n × d), where n is corpus size and d is dimensionality. The system does full work, then throws most of it away.

Canon inverts this. Governance comes first. Every stored vector carries a W-bit capability mask — a 64-bit integer where each bit encodes a governance capability. Every query carries a required mask. Before any distance computation, a single bitwise AND determines access:

Entry Mask

Query Mask

Entry Bits—

Query Bits—

AND Result—

Verdict—

Fig. II — Drag both masks. The entry is visible only when every required bit in the query mask is also set in the entry mask. One CPU instruction.

One instruction. One cycle. The AND gate either passes or blocks. If it blocks, the system never loads the vector, never computes the distance, never touches the memory beyond the 8-byte mask word. The unauthorized vector is opaque — not just filtered, but invisible to the computation.

After the mask gate, five additional predicates run before distance computation: manifold membership, temporal validity, trust threshold, classification level, and provenance depth. All five are scalar comparisons — O(1) each. Only entries that survive all six gates reach the distance function.

Cost_traditional = O(n × d) then filter

Cost_canon = O(n × 1) then O(k × d) where k « n

SIG-X07 — the governance gate is O(1) per entry. Distance computation happens only on authorized entries.

The conserved quantity is the governance budget. Traditional systems spend compute on vectors the user will never see. Canon spends one cycle per entry on governance, then spends the expensive distance computation only on the survivors. The budget is conserved — governance doesn't cost more as the corpus grows, only as the authorized subset grows.

Law III

Decay Preserves Temporal Order

How does memory fade without losing sequence?

w(t) = e^−λΔt where λ = ln 2 / τ

A memory that was relevant yesterday is less relevant today. A memory accessed this morning is more alive than one untouched for a month. Time matters — not as a filter, but as a weight. Canon doesn't exclude old memories. It lets them fade.

The decay function is exponential with a configurable half-life τ. After one half-life, the weight is 0.5. After two, 0.25. After ten, approximately 0.001. The function never reaches zero — a memory that decays is still findable, just ranked lower. This is the difference between forgetting and losing.

Half-life τ

Access Age

Creation Age

Creation Weight—

Access Weight—

Freshness—

τ—

Fig. III — The decay curve. Drag the half-life to reshape it. The two vertical markers show creation age and access age — freshness is their average weight. Recently accessed old memories stay warm.

Freshness is the average of two decay signals: how old is the memory (creation age), and how long since it was last touched (access age). A ten-year-old document accessed this morning is fresher than a one-week-old document never accessed since creation. Use keeps memories alive.

But time in Canon isn't a scalar. It's an 8-dimensional vector — the Kronos spiral from the S(R, F) Series, Paper III. Daily, weekly, and yearly cycles encoded as sinusoidal pairs, plus linear epoch and bias. This means "Monday morning" is a direction in 8D space. "Last winter" is a region. Temporal queries become geometric operations.

t⃗ = [ sin(h), cos(h), sin(d), cos(d), sin(w), cos(w), sin(y), cos(y) ]

SIG-D01 — 8D Fourier spiral. Time as geometry, not timestamp.

The conserved quantity is temporal ordering. Decay changes the magnitude of every weight, but it never reverses the order — a memory created before another will always have a higher creation-age decay, regardless of half-life. The sequence of events is preserved. Only the salience changes.

Law IV

Integrity Preserves the Chain

How do you know nothing has been changed?

H(n) = BLAKE3( entry_n || H(n−1) )

Every vector that enters Canon leaves a record in the Shadow Ledger — an append-only persistent store with BLAKE3 hash-chained entries. Each record carries the hash of the previous record. Modify any historical entry and every subsequent hash mismatches. The chain breaks forward.

This isn't a blockchain. There's no consensus mechanism, no distributed ledger, no token. It's a simple cryptographic audit trail: a linked list where each link is a hash of the previous content. Verification is O(n) in the chain length — walk forward, recompute hashes, compare. If they all match, nothing has been touched.

Tamper Entry

Chain Length8

Tampered—

First Break—

Fig. IV — Eight hash-chained entries. Drag the slider to tamper with an entry. Watch the cascade: every entry after the tampered one turns red — the hashes no longer match. Entry 0 = no tampering.

The ledger stores five tables: lineage (the hash chain itself), vectors (quantized embeddings), metadata, Merkle log (change events by epoch), and Merkle root (a periodic summary hash). The Merkle layer provides a second integrity check at a different granularity — you can verify the entire epoch without walking every individual entry.

// Lineage record — each carries the hash of its predecessor Lineage { genesis_hash: Hash, // identity of the origin actor previous_hash: Hash, // H(n-1) — the chain link embedding: Vec<i8>, // quantized vector spiral_time: [f32; 8], // 8D Kronos temporal encoding allowed_drift: f32, // maximum coherence drift before revocation }

The conserved quantity is the chain itself. You can append to it. You can never modify it. Any historical change is detectable by any reader at any future time. The ledger doesn't prevent tampering — it makes tampering visible.

Law V

Echo Preserves Institutional Memory

How do you delete data without losing knowledge?

Active → Modified → Retired → Echo

Compliance requires deletion. Privacy demands it. GDPR, CCPA, data retention policies — at some point, you must destroy the content. But hard deletion creates a different problem: the organization forgets that it ever knew something.

Canon uses a three-phase lifecycle with a fourth state that survives deletion.

Phase

State—

Content—

Searchable—

Chain—

Fig. V — Drag through the four phases. The echo record at the end is a ghost — searchable, but the original content is gone. The hash chain never breaks.

Active: Full content. Fully searchable. Full governance participation.

Modified: An update creates a new version linked to the old one by hash.

Retired: The content is deleted. The vector is removed from the spatial index. But an echo record remains — enough to know that something existed and roughly what it concerned.

Active → Modified → Retired → Echo

content: full → both versions → deleted → summary only

The echo is a faded memory. Findable, not restorable. The chain is never broken.

The conserved quantity is institutional memory. You can comply with deletion mandates and still remember the shape of what you knew.

Law VI

Composition Preserves Independence

How many configurations can nine independent nodes produce?

2⁹ − 1 = 511 valid deployments

Canon is not a monolith. It is the type foundation of a workspace where nine independent knowledge nodes each handle one concern.

Nodes9

Crates35

Circular Deps0

Fig. VI — The knowledge workspace. Canon (types) at the foundation. Nine co-equal nodes above. The hub orchestrates. Click a node to see its concern.

Node	Concern	Crates
Canon	Types, manifold, bridge, stages — the shared vocabulary	5
Shadow	Append-only audit ledger with BLAKE3 hash chains	2
Index	HNSW spatial search engine (brute + hierarchical)	2
Metronome	Temporal spine — tick counting, spiral encoding, trust decay	2
Library	Document ingestion, chunking, metadata	2
DNA	Geometric N-helix identity encoding	3
Rita's Chamber	Property graph for behavioral inference	2
Repository	Code artifact storage and versioning	2
Model Vault	ML model registry and lifecycle	2

The connection fabric is canon-types — a shared crate providing QuantizedVector, Lineage, CanonNode, and governance metadata types.

Pipeline composition happens through StructuredStage. Inter-node communication happens through CanonRef.

CanonRef = [ BLAKE3[0..16] | index_hint[4] ] = 20 bytes

Zero-copy reference. Fits in a Pulse envelope. Points to any evidence in any manifold.

The conserved quantity is independence. Adding a tenth node doesn't change existing node behavior.

The Six Laws

Six conservation laws. One memory system. One owner.

I.  Compression preserves ranking order — distances change, neighbors don't.
II.  Opacity preserves the governance budget — one cycle per entry, no wasted computation.
III.  Decay preserves temporal order — salience fades, sequence endures.
IV.  Integrity preserves the chain — append-only, tamper-evident, verifiable.
V.  Echo preserves institutional memory — delete the data, keep the scar.
VI.  Composition preserves independence — each node stands alone, together they compose.
Six things that don't change. Everything else does.

The S(R, F) Series describes the grammar of coherence — the shapes.
The Physics of Memory describes the thermodynamics of knowledge — the laws.
One tells you what the pattern looks like.
The other tells you what the pattern does.

I. Compression · II. Opacity · III. Decay · IV. Integrity · V. Echo · VI. Composition

The Physics of Memory · Canon · Sov Research · Mirror