docs/IMPLEMENTATION.md

# Implementation contract

## State and semantics

The exact backend uses a column state h over a small prime field, action matrices
T_a, and an observation matrix Q. A word (a,b) is chronological: apply a then b,
so T_word = T_b T_a. The closure stores actual witness rows, not RREF combinations,
so every added distinction can be traced to an executable future program.

`close_operators` generates an independent row basis C. It expands each admitted
row once under each action. `Closure.compile` constructs H_a and O such that
C T_a = H_a C and Q = O C. The offspring executes only y = C h, H_a and O.

## Split and tether

`split_with_tether` accepts an action cover and creates local minimal quotient
memories. Its tether is a complementary row basis required to reconstruct the
parent quotient from the combined child quotient values. Child views may overlap.
There is no assumption that their raw memories are independent.

`fractalize` recursively applies balanced action partitions. That partitioning
policy is a reference baseline, not a learned productive-divergence policy.
`regenerate_tree` reconstructs all internal seeds from child observations and
co-basis tethers. An absent nonrecoverable fragment correctly blocks reconstruction.

## Weave transaction

1. Generate the action-closed query space.
2. Test surviving relation consistency and semantic identifiability.
3. Produce an ambiguity witness when the result is not identified.
4. Optionally acquire a minimum-cardinality supplement from an explicitly supplied
   scalar oracle. The observation budget is checked before acquisition.
5. Compile the future quotient and generate a polynomial erasure-coded seed.
6. Return an executable offspring; no parent state is needed for frozen execution.

The reference `weave` function counts closure products and acquisitions. It does
not claim an exact all-phase FLOP ledger: compilation, matrix solves, serialization,
metadata storage and model proposal costs must also be charged in full AI evaluations.

## What is learned

The inherited ESRE kernel estimates an alternating interaction matrix from mixed
commutator probes. Its mathematical family is supplied. The quotient compiler then
finds the relevant representation inside that family. No transformer is trained.

## General transformer adapter design

A proposer should emit typed, sandbox-executable candidate operators, a world-model
family, query maps, empirical or formal validity domains, provenance, and predicted
resource use. The deterministic backend then performs closure/repair checks for the
admitted family. Candidate operators outside the finite-linear backend require a
new certified or explicitly approximate backend; they are not silently accepted.

The proposer, learned split scheduler, training loop and neural tensor integration
are specified in the manuscript but are not hidden behind a nonfunctional API stub.
They are deliberately not represented as completed executable features.

## Exactness and damage

The exact contracts cover known erasures of state-code symbols. Redundant equations
can detect some corruption, but consistent corruption can evade an unchecked decoder.
`Capsule.correct` is a small exhaustive bounded-distance decoder. Its declared radius
and subset budget are explicit. It is not intended for large codes.

Program matrices and query maps are distinct from the per-state seed. The main
frozen-state test retains those matrices. A separate operator-excision experiment
codes and reconstructs a small operator matrix; this is ordinary erasure coding.

## Deployment

Python 3.10+ and NumPy are enough for the reference kernel. Pytest is used for tests.
No GPU or external model access is needed. Dense matrix dimensions are limited by
validation, and the implementation is a correctness-first reference, not optimized
production linear algebra or a neural inference engine.