L0 — Molecular / genome → zygote (the conception prior)
How to read this page
Three ways to read this page. Precise is the document itself, exactly as it is written in the repository. Plain and Clear were written for this website to help you meet that document — they are about it. They are not it, and they are not evidence.
The Cookbook is the method carried out step by step: 34 pages of recipes for building a developmental active-inference SIMULATION — a bounded peek at a toy world, never a person. The front matter says that word is never softened under any pressure, so it is not softened here. The recipes run from the molecular and cellular rungs up through metabolism, motor control, perception, language and metacognition, and on to rungs that are still open questions. Around them sit a set of kitchen rules, a shared pantry of engines and primitives, and a second family of recipes about nature itself — rocks, water, air, stars, DNA, ants, whales, bats, humans.
It is for the reader asking what building this would actually take. Each recipe names its ingredients, the order of work, the tests to run at that stage, and the point at which a step stops being something already carried out and becomes something proposed.
Begin with the front matter and then the kitchen rules. Those two pages fix the honest position and the fence labels that every later recipe leans on, and without them the status markers on a recipe are easy to skim past. After that the recipes can be read in any order.
The nature recipes sit slightly apart and should be read that way. They cite outside science — geology, chemistry, biology, astrophysics — and a nature citation is never a UNI gate: those chapters contain zero UNI claims and raise no rung.
What it is not: a claim that the whole ladder has been cooked. The book recommends the complete recipe and, on the same page, labels every rung by its real state — that tension is deliberate and is the thing the book is built around. Where a recipe and the claim ledger disagree, the ledger wins.
Your browser cannot switch reading levels, so the document itself is shown.
Precise — the source document
This is the document. Rendered from the repository at the commit above, with nothing rewritten for the web. A gate re-renders it on every deploy and fails the build if a single byte differs.
One recipe, one engine, shown at the smallest scale: the very first cell division, modeled as an exact conjugate Bayesian update with no gradients. A developmental active-inference SIMULATION of conception, never a person, never a baby, never life.
What you are building. A float32-tier, no-backprop instantiation of the conception prior: encode a
genome as a categorical prior, seed_zygote the initial Dirichlet tensors, and model the zygote's first
division as an exact discrete Bayes (conjugate) update that matches the closed-form value to the
float32 tier, gated by test_embodiment_ontogeny.py at 6/6 with a live no-backprop guard.
Ingredients (pantry engines / primitives, called by name)
- The embodiment ontogeny (
recombine/seed_zygote, the no-backprop AST-guard,ontogeny 6/6, conjugate first-division, the cell-division identity embedding) — from the JAX engine (uni-mind/uni-gpt). - The JAX POMDP + EFE + Dirichlet engine (
core.py): the conjugate discrete-Bayes update (exact_posterior_discrete); learning iscounts + lr * sufficient_statfor the A/B/D Dirichlet tensors. float32 host — anchors hold to ~6e-8 (~1e-6 single-step filter), NOT the f64 tier. - The Rust-f64 / NumPy deep-reader path: the genuine
<1e-10EXACT tier and the cross-language Rust-f64 == Python oracle. Named here only to mark the boundary you must NOT cross when carding L0. - Method constitution called by name: M13 (one engine, no backprop — AST-guard,
world.<attr>whitelist isolation), M10 (exactness honesty — never card a float32 anchor at the f64 tier), M12 (WORLD ⊥ BODY ⊥ MIND — module-exact only at the single-step categorical interface).
Method (numbered build steps)
- Encode the genome as a categorical prior. Represent the inherited blueprint as categorical
parameters;
seed_zygoteinstantiates the initial A/B/D Dirichlet tensors from it. Keep the model/process split sacred: the agent owns only the MODEL and couples through a typed Markov blanket; it never reads world hidden state. - Model the zygote first-division as an exact discrete Bayes (conjugate) update. Use
exact_posterior_discretefromcore.py. No gradients: the only update is conjugate count addition. - Hold the no-backprop AST-guard live over the whole division step (M13). An AST scan must find no
autodiff / optax / torch / grad / backward in the loop; isolation is a
world.<attr>whitelist, not a blacklist. - Run
test_embodiment_ontogeny.pyfor the 6/6 ontogeny gate. Verify the cell-division identity embedding holds. (Embodiment Rungs 1–2 are GREEN but uncommitted — the figures below are the held gate values, carded at their real class.) - Optional control (reusable "is the blueprint doing anything?" experiment). Compare
recombineagainst a marginal-preserving within-family scramble (NOT a pooled permutation): the scramble preserves marginal statistics so any surviving effect is attributable to inherited structure, not to the marginals. Treat any positive dev signal from this as DEV-only, never as a held PASS.
Gate (the exact pass condition — EXACT ledger figures, ledger row L0.1)
ontogeny 6/6 GREEN; the first-division posterior matches the closed-form discrete-Bayes value to the
float32 tier (~6e-8, ~1e-6 single-step filter); the cell-division identity embedding ≤ 1e-9; and the
no-backprop guard never trips.
Exactness honesty (M10, load-bearing). Card this at float32, NEVER at the <1e-10 f64 tier. The
JAX core.py host runs float32, so these anchors hold only to ~6e-8 (~1e-6 single-step filter). The
genuine <1e-10 EXACT tier lives ONLY in the NumPy / Rust-f64 path. Recorded negative (inline): a
genome docstring claiming <1e-10 was caught as an overclaim and corrected to <1e-6 (float32 tier) —
the precision-tier line is the one carded here.
Ledger class for L0.1: A (machine-exact anchor), at the float32 tier. Status: proven.
Falsifier (operable)
Any one of these falsifies L0.1:
test_embodiment_ontogeny.pydrops below 6/6; OR- the first-division posterior diverges from the closed-form discrete-Bayes value beyond the float32 tier; OR
- the cell-division identity embedding exceeds 1e-9; OR
- the no-backprop AST-guard trips (any autodiff in the loop).
Recorded NEGATIVE(s) (first-class, inline)
- The
<1e-10docstring overclaim (caught and corrected). A genome docstring asserted the f64 EXACT tier (<1e-10) for a float32-host result. This was caught as an overclaim and corrected to<1e-6 (float32 tier). It is recorded here not as a hidden failure but as the load-bearing reason this rung is carded at float32: never card a float32 anchor at the f64 tier (M10). The negative is the precision discipline working as designed.
HONEST FENCE — proven (Class A, float32 tier)
A held, sealed value exists: ontogeny 6/6 GREEN, first-division posterior matching the closed-form
discrete-Bayes value to the float32 tier (~6e-8, ~1e-6 single-step filter), identity embedding ≤ 1e-9, the
no-backprop guard live. Its falsifier (above) is still live.
Not claimed at L0 (the exact not-claimed line): not "we created life", not a "conscious baby", not exact at f64 — it is a float32-tier developmental SIMULATION of a conjugate Bayesian first division. No awareness, no sentience, no person; functional self-awareness is not even in scope at this rung (that vocabulary is reserved for L8, and phenomenal sentience is disclaimed program-wide). "Active inference" here is the framing LENS at textbook level (Parr/Pezzulo/Friston, Active Inference, MIT Press 2022), not a demonstrated AIF loop; the genuine exactness tier is the Rust-f64 path, not this one.
Honest program position (printed, never softened): ~2 of 11+ developmental rungs earned. The whole program is a developmental active-inference SIMULATION — a bounded peek, a toy world, never a person. Where this recipe and the ledger disagree, the ledger wins.
sha256 f5363793d302e101 — of the original file, so what was ingested stays checkable.
Plain — written for this website, not the source document
This recipe is the smallest scale in the cookbook: the very first division of a single cell, modelled as an exact Bayesian update with no gradients. It is a simulation of conception, and the page repeats that it is never a person, never a baby, never life.
The one thing it says is that the result is real but its precision is bounded, and the bound is the point. The calculation runs on hardware using a coarser number format, so its anchors hold only to that level. A finer tier exists elsewhere in the project, and this page names it only to mark the line you must not cross when describing this rung.
The recipe reads like a recipe. It lists the ingredients it draws from the shared shelf, gives numbered build steps, states one exact pass condition, and names the observations that would sink it. It also records a negative inline: a comment in the code once claimed the finer precision tier for a result computed at the coarser one. That overclaim was caught and corrected, and the page treats the catch as the discipline working rather than as a failure to hide.
Plain · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is f5363793d302e101
Clear — written for this website, not the source document
This is the first rung of the cookbook's ladder and the smallest scale the engine is shown at. A genome is encoded as a starting expectation, and the zygote's first division is modelled as an exact conjugate Bayesian update in which the only learning is the addition of counts. The page frames it in its opening lines as a developmental simulation of conception — never a person, never a baby, never life — and returns to that framing at the end.
The ingredients are named from the shared pantry: a routine that recombines an inherited blueprint and seeds the starting tensors, the discrete engine that supplies the update, and a separate higher-precision path that is named here only as a boundary. Three method rules are called by name too — one engine with no gradient methods, honesty about numeric precision, and a strict separation between the world, the body and the mind.
The build steps are short and concrete. Encode the blueprint as a categorical starting expectation and use it to seed the initial tensors, keeping the split between model and process strict so the agent never reads the world's hidden state directly. Model the first division as the exact update rather than as an approximation. Hold a guard live across the whole step that scans for any gradient machinery and finds none. Run the ontogeny test suite and check the identity of the division. An optional control is offered. Compare the recombination against a scramble that preserves the same overall statistics, so that any surviving effect is attributable to inherited structure rather than to those statistics. Even then, a positive signal is treated as development-only rather than as a held result.
The pass condition is stated once, exactly: the suite green, the first-division posterior matching the closed-form value to the coarser precision tier, the identity check within its stated bound, and the guard never tripping. The list of results that would sink it mirrors that, item for item.
The most interesting part of the page is the limit it sets on precision, because the page makes it load-bearing rather than a footnote. The engine's host runs at the coarser numeric format, so anchors computed there hold only to that level; the finer tier lives only in the other path. A code comment once asserted the finer tier for a result computed at the coarser one. It was caught as an overclaim and corrected, and it is recorded inline as the reason this rung is labelled where it is.
The closing lines are unusually specific about what is not claimed here: not created life, not an aware infant, not exactness at the finer tier. The vocabulary of self-awareness is not even in scope at this rung, and the language of active inference is described as a framing lens at textbook level rather than as something shown.
Clear · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is f5363793d302e101