[{"data":1,"prerenderedAt":4},["ShallowReactive",2],{"0byxoHbxhA":3},"\u003Cp align=\"center\">\n  \u003Cpicture>\n    \u003Csource media=\"(prefers-color-scheme: dark)\" srcset=\"docs/assets/aisfa-logo-dark.svg\">\n    \u003Cimg src=\"docs/assets/aisfa-logo.svg\" alt=\"AISFA: AI Safety Formalization Atlas. Two quotation corners above a solid gold square, the end-of-proof mark.\" width=\"310\">\n  \u003C/picture>\n\u003C/p>\n\n# AI Safety Formalization Atlas\n\n[![CI](https://github.com/mbrcic/ai-safety-formalization-atlas/actions/workflows/ci.yml/badge.svg)](https://github.com/mbrcic/ai-safety-formalization-atlas/actions/workflows/ci.yml)\n[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/mbrcic/ai-safety-formalization-atlas?quickstart=1)\n[![Software DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21483033.svg)](https://doi.org/10.5281/zenodo.21483033)\n[![Whitepaper DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23088951.svg)](https://doi.org/10.5281/zenodo.23088951)\n\n**Machine-checked mathematical infrastructure for AI safety.**\n\nAISFA is an open Lean 4 library for formalizing, reproducing, auditing and\nextending mathematical results relevant to AI safety: shared definitions,\ntheorems, counterexamples, open conjectures, and reviewed bridges from the\nmathematics to AI systems.\n\n- **Whitepaper:** [*The AI Safety Formalization Atlas: a machine-checked memory\n  for AI safety mathematics*](https://doi.org/10.5281/zenodo.23088951) (preprint,\n  2026; DOI for all versions)\n- **Software:** [DOI for all versions](https://doi.org/10.5281/zenodo.21483033);\n  latest release v0.8.0, [DOI](https://doi.org/10.5281/zenodo.22654735)\n- **Start:** [Open in Codespaces](https://codespaces.new/mbrcic/ai-safety-formalization-atlas?quickstart=1)\n  — the toolchain provisions itself and one example compiles in minutes — then\n  pick a [first task](docs/guide/contributor-tasks.md#open-now). Prefer local?\n  `scripts/setup.sh --pointer` (docs only, no Lean) or `scripts/setup.sh --quick`\n  (one example). Full detail: [Get started](#get-started).\n\n## At a glance\n\n\u003C!-- BEGIN GENERATED REGISTRY SCOPE -->\n| Metric | Current |\n|---|---:|\n| Declarations recorded in the registry | **379** |\n| Results stating a source claim | **49** |\n| Results recording a formalization only | **95** (86 on root import) |\n| AI-system bridges (`BRIDGE` declarations) | **37**: 30 interpretation-reviewed, 7 statement-reviewed only |\n| Source-claim rows with a reviewed AI interpretation | **3** (+1 statement-reviewed only) |\n| Open conjectures | **3** |\n| Claim results with statement-match | **16** |\n| Claim results with `RELATED`-only formalization | **9** |\n\n`EXACT`/`EQUIVALENT` = conservative citation grade (completely\nformalization-covered source statements). `RELATED` = value-based scoped\nformalization, with documented deltas; it does **not by itself** mean\nunfinished, but postponed until justified (paper residuals stay in\nprovenance). The two grade rows count **claim results**, not\nformalization records: one result may carry several, and an artifact\nrow's own grade is never in these numbers. Detail:\n[formalization status](docs/status/formalization-status.md);\n[by mathematical area](docs/status/by-area.md);\nper-source reports under [`docs/status/sources/`](docs/status/sources/).\n\u003C!-- END GENERATED REGISTRY SCOPE -->\n\nStatement coverage of the 28 graded sources is **300 `Yes` / 17 `Partial` / 208\n`No` / 41 `Beyond`**, graded by hand against the printed text in\n[`source-coverage-audit.md`](docs/provenance/source-coverage-audit.md). Builds\nare reproducible against pinned Lean and Mathlib, and CI checks the axioms of\nevery headline declaration. What the atlas does **not** have is counted too:\n[Library status](#library-status).\n\n## Why AISFA\n\nAI-safety mathematics lives in papers, prose, scattered proofs and incompatible\nformalisms, so every citation rebuilds the model and words it a little\ndifferently. AISFA turns claims into reusable, machine-checked objects with\nexplicit assumptions, provenance and interpretation boundaries.\n\nIt keeps three questions apart, because they fail independently:\n\n1. **Is the proof valid?** The Lean kernel decides this.\n2. **Is the formal statement the claim in the source?** Graded per statement,\n   by hand, in the coverage audit.\n3. **Does the result say anything about a real AI system?** Only through a\n   separately reviewed bridge, and a kernel-checked proof does not by itself\n   establish it.\n\n## Explore\n\n| If you want to | Go to |\n|---|---|\n| read the idea | [Whitepaper](https://doi.org/10.5281/zenodo.23088951) |\n| inspect the evidence | [Formalization status](docs/status/formalization-status.md), [source coverage audit](docs/provenance/source-coverage-audit.md) |\n| browse results | [Landscape index](docs/status/landscape-index.md), [by mathematical area](docs/status/by-area.md) |\n| work on an open problem | [Conjectures](docs/guide/conjectures.md), [open work](docs/guide/open-work.md) |\n| see how grading works | [Methodology](docs/guide/methodology.md) |\n| use the library | [Get started](#get-started), [depending on the Atlas](#depending-on-the-atlas-from-your-own-project) |\n| contribute | [First tasks](docs/guide/contributor-tasks.md#open-now), [contributing](#contributing) |\n| see where it is going | [Roadmap](ROADMAP.md) |\n\n## The longer argument\n\n**The situation.** AI systems are gaining capability faster than anyone is\ngaining understanding of them, and they are being deployed on the near side of\nthat gap. Decisions about what is safe to build and release are being made now.\n\n**Why mathematics.** Most of the evidence behind those decisions is empirical —\nevaluations, red-teaming, incident review. That evidence is one-sided by\nconstruction: testing can show that a system fails, never that it cannot. As\ncapability grows the space of behaviors grows with it, so the fraction any test\nsuite covers shrinks. A proof is the only form of evidence that speaks about\nevery case. Its assumptions can still stop matching the system, which is why\nnothing here is read as a claim about a real system without a separate reviewed\nstep.\n\n**Why now.** The same systems that make this urgent are what make it tractable.\nAutoformalization has turned mechanization from a specialist craft into ordinary\nwork: models draft the Lean, and a kernel that does not care who wrote it decides\nwhether the proof holds. Trust never routes through the model. What this\naccelerates is implementation, not discovery — stating the right property, and\nreviewing whether it matches the system, still move at human speed. AI is the\nsubject, the instrument, and the deadline at once.\n\nWhat the kernel settles is whether a proof is valid. Whether it is the right\nstatement stays a human question — and that is the bottleneck. Stating a safety\nproperty exactly enough to be checkable is the hard part, and it does not require\nknowing what a proof assistant is.\n\n**Bring a question.** Alignment, control, oversight, interpretability,\nrobustness—if you can make a safety property precise, this is where you turn it\ninto something machine-checked. Impossibility and possibility both count (e.g.\nDeepMind debate reproduced as\n[`LAND-DEBATE-001`](docs/provenance/debate-reproduction.md); continuous free\nlunches BY-022 [open](docs/guide/contributor-tasks.md#open-now)).\n\n**If the question is causal identifiability**, the `AISafetyAtlas.Causal.*` modules carry\nfinite categorical Bayesian networks over an ordered field, interventions and\nregret, Everitt's structural models and influence diagrams, and the objects the\nMAIS-A2 agenda phrases its query problems over — a semialgebraic class, the\n`K(G)` parameter chart, and a rational-weight query layer. Two behaviourally\nidentical models with different graphs are exhibited, not assumed.\n\n**If you want an open question instead of a theorem**,\n[`conjectures.yaml`](conjectures.yaml) tracks precise statements — mostly\ncausal-identifiability questions from\n[MAIS](https://github.com/lionellevine/MAIS)'s open-problems agenda, together\nwith three singular-learning problems from its A6 and A7 agendas, plus one\nquestion from an information-theory survey. Every conjecture entry names a closed, compiling `Prop`, and the ledger also holds determine-problem specifications and printed problems with no Lean object at all;\ndefining one asserts nothing about its truth, and the rows that are settled\nsay so and name the proof. Worked models establish that the hypotheses can be met\nwhere a row says so, and the rows whose antecedents still have no witness\ndisclose it — the MAIS-O26 row needs a solution to MAIS-O24, and no such\nsolution is exhibited in this tree, so that statement may hold vacuously. See\n[conjectures](docs/guide/conjectures.md).\n\n**Solutions other people submitted to those problems** are transcribed and\nchecked here too, and what checking them found is a generated table:\n[MAIS submitted solutions](docs/status/mais-solutions.md). It separates two\nfacts a reader will otherwise merge — whether the mathematics checks, and which\nartifact the ledger row is graded against — because a submission can be fully\nproved and still be graded against the printed problem rather than against\nitself. Checking someone's mathematics is not peer review and not co-authorship,\nand no row says a submission is accepted upstream.\n\n**If the question is singular learning**, the `AISafetyAtlas.SingularLearning.*`\nmodules carry the local-pair machinery for the two-layer linear network\n`x ↦ BAx` against the square loss: the local invariant as MAIS-A7 defines it, by\nthe band volume `vol{|L(w') − L(w)| \u003C ε} ≍ ε^λ (log 1/ε)^(m−1)`, together with\nthe elimination chart, the orbit reduction and the chamber calculus that the\nreduced-rank fibre needs. It is an off-root facade, so `import\nAISafetyAtlas.SingularLearning` is explicit rather than carried by the root.\nThree MAIS problems sit on top of it, and two of the answers are unconditional:\n**MAIS-O7 is false** — `isO7Counterexample` refutes the opposing-staircases\nconjecture at every positive scalar target — and **MAIS-O77(b) holds**, pair\n`(1,1)` at every point of every nonterminal critical set. The Morse lemma this\nrests on is not ours: eight modules of the Tau Ceti development are vendored\nunder [`vendor/TauCeti/`](vendor/TauCeti/PROVENANCE.md), Apache-2.0 and pinned.\n\n**Some results in that layer are conditional, and the atlas says which.**\nMAIS-O77(a) and the first two clauses of MAIS-O70 are proved over propositions\nthis tree states and does **not** prove — the real-Wishart eigenvalue law chief\namong them. A theorem `frontier → X` reads exactly as strong whether the\nfrontier is true or false, and neither a green build nor a clean axiom audit\ntells the two apart, so each assumption is named, frozen, given unconditional\nstress artifacts, and recorded with who it is owed to and what discharging it\nwould cost. Two of the three are owed to the *candidate solution*, which cites\nthem rather than deriving them; one is owed to the printed source. The table is\n[the MAIS source report](docs/status/sources/mais-2026.md), and\n`scripts/check_frontier_evidence.py` prints the whole debt on every run.\nPassing that check is not evidence a frontier is true.\n\n**If the question is control**, `AISafetyAtlas.Control` carries Ashby's variety\nbounds and Touchette–Lloyd's information limits at their printed quantifiers: a\nregulator cannot hold an outcome steadier than its own repertoire allows, and\nfeedback improves on open loop by at most the information the sensor actually\nsupplied. **If it is the reach of a no-free-lunch argument**,\n`AISafetyAtlas.Learning.Sharp` proves the characterization in both directions —\nperformance is algorithm-independent *exactly* on priors closed under relabelling\nthe search space — together with the count saying almost no prior is one. Several\nof the survey's control rows are still empty; see\n[open work](docs/guide/open-work.md). Reading these across domains:\n[symmetry and impossibility](docs/guide/symmetry-and-impossibility.md).\n\n## Who this is for\n\n- **Lean formalizers and AI-safety theory researchers** (and proof agents)\n  developing, reproducing, or auditing formal claims.\n- **Formal-methods and safety engineers** using cores as reference\n  specifications or to pressure-test assumptions in a larger assurance\n  argument.\n- **Contributors** willing to make a claim precise, including with help from\n  formal-methods collaborators or agents.\n\nA theorem is **not** a system safety case. Applying it to a real system needs a\nscoped reviewed bridge where relevant, implementation evidence, and the rest of\nthe assurance argument. Bridge review validates a scoped interpretation; it does\nnot by itself prove operational safety.\n\n## Library status\n\n**Primary goal:** develop, reproduce, and machine-check formal AI-safety results\n(including using shared foundations to discover new ones), for AI safety and\nrelated computable governance/ethics. **Also:** keep cores usable as reference\nspecifications downstream. **Not a goal:** growing counts, or growing a product\nmonorepo in-tree. Reusable structure and honest grading over volume.\n\nThe counts are under [At a glance](#at-a-glance).\n\n**What the atlas does not have, stated here rather than left to be found.** The\ntable above counts registry rows, not the tree: the working tree pins far more\npublic names than it records results. Three ratios a reader is entitled to\nbefore reading further:\n\n- **Statement coverage of the graded sources: 300 `Yes` / 17 `Partial` / 208\n  `No` / 41 `Beyond`,** across 28 sources. A `No` is a printed statement the\n  atlas does not have. The per-statement grading is\n  [`source-coverage-audit.md`](docs/provenance/source-coverage-audit.md).\n- **Scope debt: 4 cells** graded `Narrower` or `Mixed` are owed a closure, a\n  regrade, an unclosability proof or a cost, and each declares one; 2 more\n  record a closure. The\n  standing rule is scope ≥ print, so each of those is a defect until discharged.\n  `scripts/check_coverage_audit.py` computes both figures.\n- **Witness debt: 3 theorems of 2,686 are ungrounded and 31 reach no worked\n  application** under `AISafetyAtlas/Examples/`. The second is the number that\n  says how much of the library the build actually exercises; the first also\n  counts a registry citation, and a citation is not built. Two of the three are\n  leaves, and both **cannot be witnessed at all**: their antecedent is a type the\n  tree proves empty. They are recorded in `docs/status/witness-vacuity.json` with\n  the emptiness proof named, stay inside both counts, and leave the work queue.\n\nNone of these is an argument against the results that are here. They are the\nnumbers that make the results legible, and they are generated rather than\nasserted.\n\nPublished units must rebuild under documented commands and the axiom policy\n([Validation](#validation)).\n\n## Depending on the Atlas from your own project\n\nAdd it to your `lakefile.toml`. There is no Reservoir entry, so require it by git:\n\n```toml\n[[require]]\nname = \"ai-safety-formalization-atlas\"\ngit = \"https://github.com/mbrcic/ai-safety-formalization-atlas.git\"\nrev = \"v0.8.0\"\n```\n\n`v0.8.0` is the published release and is what that stanza gets you. **The module\nlist below describes the working tree, which is ahead of it** — anything added\nsince the tag is not in `v0.8.0`, so check the tag's own module list before\ndepending on a name you read here.\n\nThen `import AISafetyAtlas.Knowledge` (or whichever module below) and instantiate\nthe statements at your own types — they are unbundled maps, not an atlas-specific\nagent structure, so your `State` does not have to be one of ours.\n\nThree things worth knowing before you do:\n\n- **Your toolchain has to match, exactly.** Lean `v4.33.0`, Mathlib at the\n  `v4.33.0` tag, and Foundation and PFR pinned by commit — PFR is a research\n  development whose API is not stable across revisions, which is why it is pinned\n  that way. If your project already sits on a different Mathlib, this is not a\n  drop-in.\n- **You inherit every dependency**, Mathlib, Foundation and PFR, because Lake\n  resolves requirements per package rather than per import. Splitting the counting\n  half of Ashby's law out of the PFR-importing module (`Control.VarietyCounting`)\n  means less has to be *elaborated*, not less fetched.\n- **`warningAsError` is this package's option and does not reach yours** —\n  verified, not assumed.\n\n## Domain imports\n\nPrefer a facade over the full root import when starting a proof. Some parents\nre-export their domain (`Wireheading`, `Compositional`, `Control`,\n`Oversight.JointObservation`); the kernels do not, so `Knowledge` and\n`Preference` specializations are imported one by one, and `Verification`\nsupplies its mathematical base without the `AgentBehavior` and `Robot` bridges.\n`Inference` re-exports its own subtree, so one import carries the whole Wolpert\ndevelopment; `Knowledge.Devices` is the transport between the two and imports\nboth. `InformationTheory` deliberately has **no** parent — each module is one\nresult and none is built on the others, so there is no surface for a facade to\naggregate. **`Causal` has no parent either, for a stronger reason**: the domain\nholds two different objects, and an aggregating import would force a consumer of\none to take the other. `Causal.Model` is a causal Bayesian network — a graph with\nconditional probability tables. `Causal.StructuralModel` is Everitt's structural\ncausal model, influence diagram and SCIM, where the randomness sits in exogenous\nvariables and the endogenous variables are related deterministically. Neither is\na special case of the other as rendered here. Import contracts per module:\n[`AISafetyAtlas.lean`](AISafetyAtlas.lean).\n\n**Two senses of \"control\" live in this tree.** `Inference` has Wolpert's, which\nis a device controlling another device; `Control` has Ashby's and\nTouchette–Lloyd's, which is a regulator against a disturbance. No theorem\nidentifies them.\n\n```lean\nimport AISafetyAtlas.Control       -- Ashby variety bounds + Touchette–Lloyd limits (facade)\nimport AISafetyAtlas.Control.RequisiteVariety -- or one module at a time\nimport AISafetyAtlas.InformationTheory.Fano   -- peers, no facade: import the one needed\nimport AISafetyAtlas.InformationTheory.DataProcessing\nimport AISafetyAtlas.InformationTheory.ChannelCapacity\nimport AISafetyAtlas.Combinatorics.PermInvariance -- relabelling-invariance machinery\nimport AISafetyAtlas.SingularLearning         -- local pairs for the two-layer linear network (off-root facade)\nimport AISafetyAtlas.Learning      -- finite NFL cores\nimport AISafetyAtlas.Learning.Sharp -- the permutation-closed characterization, both directions\nimport AISafetyAtlas.Preference    -- planner/reward unidentifiability (kernel)\nimport AISafetyAtlas.Preference.Override -- overriding human reward functions\nimport AISafetyAtlas.Preference.Regret   -- half-maximal regret not ruled out\nimport AISafetyAtlas.Wireheading   -- reward channels, self-modification\nimport AISafetyAtlas.Compositional -- rectangles, hyperproperties, networks\nimport AISafetyAtlas.Oversight.JointObservation -- coalition evidence, coverage, collision\nimport AISafetyAtlas.Knowledge     -- exact knowability, decoders, indistinguishability (kernel)\nimport AISafetyAtlas.Knowledge.Embedded -- restriction, meshing, self-measurement limits\nimport AISafetyAtlas.Knowledge.Embedded.Composition -- complement ⇒ proper inclusion; positive boundary\nimport AISafetyAtlas.Knowledge.Embedded.Finite -- finite cardinality gap ⇒ proper inclusion\nimport AISafetyAtlas.Knowledge.Temporal -- time-indexed knowability, collisions, delay\nimport AISafetyAtlas.Knowledge.Ambiguity -- finite fibre ambiguity, counting obstruction\nimport AISafetyAtlas.Knowledge.SelfReference -- model as part of the state it models\nimport AISafetyAtlas.Knowledge.Accumulation -- window ambiguity bounds over time\nimport AISafetyAtlas.Knowledge.Devices -- transports between the kernel and inference devices\nimport AISafetyAtlas.Knowledge.Check -- executable checkers, each with an agreement theorem\nimport AISafetyAtlas.Inference     -- Wolpert devices: weak/strong inference, control, physical knowledge\nimport AISafetyAtlas.SelfAwareness -- process composition and complete-awareness limits\nimport AISafetyAtlas.Oversight.Debate -- doubly-efficient debate (vendored; NOT on the root import)\n```\n\nCross-surface consumer pattern (compositional boundary + nonzero regret +\npreference certificate): `AISafetyAtlas.Examples.WorkbenchConsumers`. Primary\nnames live in each facade docstring; root `import AISafetyAtlas` remains\navailable.\n\n`Oversight.Debate` is the one facade root `import AISafetyAtlas` does **not**\nbring in: it wraps a vendored development that declares its names in the root\nnamespace, so it is imported on its own and audited separately. Its module\ndocstring gives the reason.\n\n## Epistemic scope\n\nA machine-checked proof establishes its encoded mathematical statement. It does\nnot by itself establish that the statement fully captures an informal AI-safety\nclaim. Math results and AI-system bridges are separate layers; bridges need\nhuman review.\n\n**Citation grades stay conservative:** do not raise `EXACT`/`EQUIVALENT` by\nweakening fidelity. `RELATED` is a useful core with an explicit scope delta; it\ndoes not by itself mean unfinished, and residual paper gaps remain documented.\nA bridge may be `REVIEWED` while the formalization stays `RELATED` (e.g. robot).\nSee the [`v0.7 release scope`](docs/releases/v0.7.md) and\n[`docs/guide/methodology.md`](docs/guide/methodology.md).\n\n## Repository contents\n\n- [`registry.yaml`](registry.yaml) records every result: claim rows carrying\n  source provenance, and artifact rows for formalizations and public Lean\n  surface the library develops or reproduces on its own account.\n- [`AISafetyAtlas/`](AISafetyAtlas/) contains attributed Lean integrations.\n- [`Main.lean`](Main.lean) is `atlas-check`: it reads a finite model as JSON and\n  prints the verdict together with the declaration that certifies it, so a\n  question about a particular model can be answered without writing Lean. Every\n  checker behind it is paired with a theorem saying it agrees with the `Prop`.\n  See the [guide](docs/guide/atlas-check.md) — including what the output is\n  *not*, which is a proof term the kernel has checked for that instance.\n- [`CONTRIBUTING.md`](CONTRIBUTING.md) explains how to propose and verify changes.\n- [`ROADMAP.md`](ROADMAP.md) presents the public strategy and contributor entry points.\n- [`STATE.md`](STATE.md) reports the current phase, blockers, and next tasks.\n- [`conjectures.yaml`](conjectures.yaml) records source-faithful conjecture\n  statements that compile in Lean without a proof, together with settled rows;\n  an open row asserts nothing, and a settled one names its proof.\n- [`tasks.yaml`](tasks.yaml) is the maintained task board;\n  [`docs/guide/contributor-tasks.md`](docs/guide/contributor-tasks.md) is\n  generated from it.\n- [`docs/`](docs/README.md) is split by role — start with the [documentation map](docs/README.md):\n  - [`docs/guide/`](docs/guide/) — methodology, open work, model notes, tasks\n  - [`docs/status/`](docs/status/) — generated coverage tables and indexes\n  - [`docs/provenance/`](docs/provenance/) — discovery search + external reproduction\n  - [`docs/interpretation-reviews/`](docs/interpretation-reviews/) — bridge review packages and evidence\n  - [`docs/releases/`](docs/releases/) — release evidence notes\n\n## Lean API\n\nDownstream proofs need only the root import:\n\n```lean\nimport AISafetyAtlas\n```\n\nThe stable entry points are conventional theorem names under domain namespaces:\n\n- `AISafetyAtlas.Computability.rice` and `rice_code_iff`\n- `AISafetyAtlas.Computability.halting_problem`\n- `AISafetyAtlas.SocialChoice.arrow`\n- `AISafetyAtlas.SocialChoice.Utility.arrow`\n- `AISafetyAtlas.Logic.chaitin_incompleteness` and `chaitin_bound`\n- `AISafetyAtlas.Logic.godel_first_incompleteness` and `godel_second_incompleteness`\n- `AISafetyAtlas.Logic.tarski_undefinability`\n- `AISafetyAtlas.Logic.loeb`\n- `AISafetyAtlas.Verification.rice`\n- `AISafetyAtlas.Verification.AgentBehavior.no_behavioral_safety_verifier`\n- `AISafetyAtlas.Verification.Robot.action_safety_unverifiable`\n- `AISafetyAtlas.Composition.independent_iff_rectangular` and\n  `not_independent_of_failed_splice`\n- `AISafetyAtlas.Observability.factors_through_iff_fiber_invariant` and\n  `no_perfect_monitor_of_collision`\n- `AISafetyAtlas.Compositional` — rectangularity, hyperproperties, and network symmetry\n- `AISafetyAtlas.Wireheading` — objective, corruption, and goal-preservation cores\n- `AISafetyAtlas.Preference` — preference-unidentifiability and override cores\n- `AISafetyAtlas.Oversight.JointObservation` — `covers_iff_no_collision`, the certified\n  finite checker `decideCoverage`, the repair boundary, and the bounded portfolio target\n  (landscape `LAND-JOINTOBS-001`; see the\n  [joint observation model](docs/guide/joint-observation-model.md))\n- `AISafetyAtlas.Logic.lawvere_fixed_point` — the types-and-functions Lawvere\n  fixed-point wrapper (not the categorical statement; see `CLM-LAWVERE-CCC-001`)\n- `AISafetyAtlas.Learning.no_free_lunch` and `no_free_lunch_supervised` — finite NFL cores\n- `AISafetyAtlas.Learning.Sharp.nfl_adaptive_iff_permInvariant` — the sharp form:\n  performance is algorithm-independent **iff** the prior is closed under\n  relabelling the search space. With `card_closedUnderPermutation_nonempty`\n  (almost no prior is) this is the result that says where an NFL argument may be\n  used at all\n- `AISafetyAtlas.Control` — Ashby and Touchette–Lloyd behind one import.\n  `ashby_variety_ge` and `ashby_logVariety_ge` are the law in\n  counting and logarithmic form, `ashby_variety_ge_isSharp` says it is attained;\n  `outcome_eq_comp` and `exists_strategy_forcing` are §11/14;\n  `controlLoss_eq_condMutualInfo` identifies control loss with\n  a conditional mutual information and `entropyReduction_le_of_openLoopBound`\n  bounds feedback's advantage over open loop. Every one of those is in\n  `namespace AISafetyAtlas.Control`, whichever of the ten modules declares it, so\n  each is importable one at a time; see the facade docstring for the map\n- `AISafetyAtlas.InformationTheory.Fano` and `.DataProcessing` — Fano's\n  inequality at printed constants and the data-processing inequality with its\n  equality case, both over an arbitrary probability space.\n  `.ChannelCapacity` is the noiseless capacity, owned by neither\n- `AISafetyAtlas.Combinatorics.PermInvariance` — what relabelling-invariance\n  forces. `spectrum_eq_iff_mem_permOrbit` (the multiset of values is the complete\n  invariant), `closedUnderPermutationEquivSet` (invariant families *are* families\n  of multisets), and `exists_perm_rel_not_iff` (no non-trivial relation survives).\n  Domain-neutral, reusable, and the shared half of the NFL result above\n- `AISafetyAtlas.Knowledge` — start with the\n  [knowability model](docs/guide/knowledge-model.md).\n  `Knowable` in decoder form, `knowable_iff_no_collision`,\n  `IndistinguishabilityWitness`, and the informativeness boundary `Knowable.mono` /\n  `not_knowable_comp`. `JointObservation`'s coverage laws are this kernel applied to\n  `q.observe`\n- `AISafetyAtlas.Knowledge.Embedded` — restriction, inference maps, meshing, and the\n  abstract self-measurement no-gos (`EQUIVALENT` to Breuer 1995 §3.5; see `LAND-SELFMEAS-002`)\n- `AISafetyAtlas.Knowledge.Temporal` — `KnowableFrom` / `KnowableAt`,\n  `CollisionAt`, `EvidenceMonotone`, `DelayedKnowable`. Keeps *knowing the state\n  as of `s` from evidence at `t`* apart from *knowing the current state at `t`*, which\n  is the difference distributed snapshots exploit\n- `AISafetyAtlas.Knowledge.Ambiguity` — `ambiguity` counts the target values one\n  observation leaves open. `card_image_le_of_knowable` is a counting obstruction that\n  never names a colliding pair; `ambiguity_le_of_comp` says coarsening never lowers the\n  shortfall. Finite counting only — no probability or entropy\n- `AISafetyAtlas.Knowledge.SelfReference` — where the observation stops being an\n  arbitrary map: the observer's model is a *component* of the state. Complete\n  self-knowledge holds **iff** nothing else is in the state\n  (`selfComplete_iff_subsingleton_rest`), so it is achievable only degenerately\n- `AISafetyAtlas.Knowledge.Accumulation` — ambiguity about a *window* of targets.\n  Widening never reduces it and never exceeds the product of the steps. Growth itself\n  is not a theorem: it depends on dynamics, and both extremes are exhibited\n- `AISafetyAtlas.SelfAwareness` — active observation-and-predictive-modelling of\n  internal processes during a bounded horizon. `process_not_self_aware` is the\n  local strict-extension result; `limited_self_awareness` lifts it through\n  recursive process composition without assuming the awareness graph is acyclic\n\nEvery facade above carries a short primary-surface table and explicit non-claims\nin its module docstring; read that before the declarations. Residual gaps are\nrecorded per cluster, not in one place: `Compositional`, `Wireheading`,\n`Preference` and `Oversight.JointObservation` in the\n[A1–A3/B1–B3/B7 re-verification](docs/provenance/a1-a3-b1-b3-b7-reverification.md),\nand the `Knowledge` facades in the\n[self-measurement kernel note](docs/provenance/self-measurement-kernel.md) and the\n[landscape sweep](docs/provenance/embedded-self-knowledge-landscape.md). The\nprocess-compositional BY-044 interpretation has its own\n[source map and fidelity residual](docs/provenance/limited-self-awareness.md).\n\n**Landscape declarations** — results the library develops or reproduces on its\nown account rather than as coverage of a catalogued source. Most carry\n`root_import: true` — the count is in the table above; most are the `Knowledge`, `Oversight` and `Compositional`\nentry points listed above. The full list, with the declarations each row owns, is\ngenerated: [landscape index](docs/status/landscape-index.md), and how the rows\nstand to one another is [relations](docs/status/relations.md).\n\nThe one that has no facade bullet above:\n\n- `AISafetyAtlas.Explainability.attribution_impossibility` (DASH trilemma;\n  not BY-029/BY-042 without a separate statement map)\n- `AISafetyAtlas.Composition.independent_iff_rectangular` (`LAND-COMP-001`,\n  native): a global safe set decomposes into independent per-agent contracts\n  iff it is splice-closed; certified multi-agent counterexamples in\n  [`AISafetyAtlas/Examples/Composition/`](AISafetyAtlas/Examples/Composition/)\n- `AISafetyAtlas.Observability.no_perfect_monitor_of_collision`\n  (`LAND-OBS-001`, native): perfect monitoring is exactly hazard\n  observability; see\n  [compositional boundaries](docs/provenance/compositional-boundaries.md)\n\nReproduced external formalizations that carry no Lean interface are pinned in\n`registry.yaml`, listed in the\n[landscape index](docs/status/landscape-index.md), and rebuilt with\n`scripts/reproduce_isabelle.sh`:\n\n- `Gibbard_Satterthwaite` (`LAND-GS-001`, Isabelle/HOL; Arrow-session\n  provenance related to BY-007). Lean consumer interface:\n  `AISafetyAtlas.SocialChoice.gibbard_satterthwaite` (`LAND-GS-002`, vendored\n  SocialChoiceLean GS closure)\n- `no_free_lunch_ML` (`LAND-NFL-001`, Isabelle/HOL; the Shalev-Shwartz–Ben-David\n  PAC no-free-lunch — the formal core of \"generalization needs inductive bias\" —\n  distinct from the Wolpert NFL survey rows BY-020/BY-021; see\n  [CT-2 triage](docs/provenance/ct2-nfl-triage.md))\n\nThe Rice verification bridge concerns properties of partial input/output\nbehavior; `AgentBehavior` is a downstream consumer that models encoded agents\nand total behavioral safety verifiers. The independent Robot bridge concerns\ntotal reactive action traces under an explicit effective switching certificate\nand reduces directly to the halting problem. The Logic layer covers Chaitin\n(BY-015, vendored KolmogorovMathlib), classical Gödel I/II (BY-013, Foundation),\nTarski undefinability (BY-016), and Löb (BY-027); see\n[logic incompleteness](docs/guide/logic-incompleteness.md). Neither classical nor\nbridge theorem asserts that a particular AI system or practical verification\ntask satisfies its model. Generated checks in\n`AISafetyAtlas.Examples.Registry` compile every registry-listed declaration\nthrough the root import. The hand-written examples in\n`AISafetyAtlas.Examples.PublicAPI` additionally protect the intended theorem\nsignatures; the explicit targets in `scripts/lean_build_targets.txt` also build\nworked examples, most of which are intentionally outside the public root\nimport. The twelve `AISafetyAtlas.Examples.Causal.*` modules are the exception\nand are on the root import.\nKernel axiom cleanliness of the headline surface is checked by\n`scripts/check_print_axioms.py`.\n\nExternal reproduction of the Kolmogorov pin (upstream checkout, not the\nvendored tree):\n\n```console\nscripts/reproduce_chaitin.sh\n```\n\n## Get started\n\n\u003C!-- BEGIN GENERATED ROUTING -->\n\u003C!-- Generated by scripts/generate_registry_views.py; do not edit by hand. -->\n\n| I have… | It goes in | Then |\n|---|---|---|\n| a pointer to a result, or a proof, that is not recorded here | the [discovery issue form](https://github.com/mbrcic/ai-safety-formalization-atlas/issues/new?template=known-formalization.yml) — we classify it and place it | nothing to install |\n| a correction to a record you have already found | the ledger file that holds it | `scripts/setup.sh --pointer` |\n| an open question and no proof | the [conjecture issue form](https://github.com/mbrcic/ai-safety-formalization-atlas/issues/new?template=conjecture.yml) | no Lean needed; the statement enters the ledger after it compiles |\n| a proof to write, or any Lean change | the facade for your area (see Domain imports); for new coverage, dependencies, or public API, start with the [formalization proposal](https://github.com/mbrcic/ai-safety-formalization-atlas/issues/new?template=formalization-proposal.yml) | `scripts/setup.sh`, then build + gate + `check_print_axioms.py` |\n| a change to a contributor task | `tasks.yaml` — never the generated Markdown | regenerate + gate |\n| evidence that something does not exist | `novelty_checks` in `docs/provenance/formalization-search.json` | update search evidence, then regenerate + gate |\n| a new source to catalogue | `source_catalog` in `registry.yaml`, with its `role`; add a `CLM-*` row with `original_source_refs` if it states a result | regenerate + gate |\n\n**regenerate** `python3 scripts/generate_registry_views.py` · **gate** `./scripts/agent_gate.sh` · **build** `lake build`\n\nNothing here needs the whole picture: take the row that matches what you\nhave and ignore the rest.\n\u003C!-- END GENERATED ROUTING -->\n\nNo toolchain needed for the first row — the validators need only Python 3.12 or\nnewer and its standard library. One check reads a ledger through PyYAML and is\nskipped with a notice if that is absent; `pytest` and `ty` are likewise optional\nlocally. CI installs all three, so none of them is optional on a pull request:\n\n```console\nscripts/setup.sh --pointer   # cheap validators only; no Lean toolchain\n```\n\nFor anything touching Lean, one command provisions everything — it installs\n[`elan`](https://lean-lang.org/install/manual/) if it's missing, fetches the\nprebuilt Mathlib, builds, and runs the validators:\n\n```console\nscripts/setup.sh --quick   # fast path: toolchain + Mathlib cache + one example compiling\nscripts/setup.sh           # full: whole build closure + validators (run before a Lean PR)\n```\n\nZero local install: open the repo in **GitHub Codespaces** — or any editor's\n[Dev Container](.devcontainer/devcontainer.json) — and the toolchain provisions\nitself on first boot (via `--quick`, so the cold start stays short; run the full\n`scripts/setup.sh` before submitting a Lean change).\n\n\u003Cdetails>\n\u003Csummary>What \u003Ccode>scripts/setup.sh\u003C/code> runs, to do it by hand\u003C/summary>\n\n```console\nlake exe cache get   # fetch prebuilt Mathlib — skips an hours-long local compile\nlake build\nxargs lake build \u003C scripts/lean_build_targets.txt\n./scripts/agent_gate.sh\n```\n\u003C/details>\n\nThe repository pins Lean, Mathlib, and every transitive dependency:\n[`lake-manifest.json`](lake-manifest.json) is the lock. Build from it directly —\ndo **not** run `lake update` unless you are deliberately bumping a dependency, as\nit re-resolves floating revisions off the pinned set. Released Lean files follow\nthe [strict-trust and build-closure policy](docs/guide/methodology.md#new-proofs-and-bridges).\n\n## Contributing\n\n**There is always something to do.** [Get started](#get-started) routes what you\nhave to the one file it belongs in; bounded units are in\n[contributor tasks](docs/guide/contributor-tasks.md).\n\nWorking with an LLM or agent: draft against a facade, then `lake build` →\n`agent_gate.sh` → `check_print_axioms.py` (see [CONTRIBUTING](CONTRIBUTING.md)).\nGreen Lean is kernel validity of the encoding — not source match, model\nadequacy, or system interpretation.\n\nFull tracks and rungs: [CONTRIBUTING.md](CONTRIBUTING.md). Issue forms for\nproposals that change coverage, dependencies, or the public Lean interface.\n\n### Tooling an agent may use\n\nNone of this is required to contribute, and none of it is a dependency — the\ngate and CI use only what `lake-manifest.json` pins. It is listed because an\nagent that does not know these exist re-derives things the ecosystem already\nhas.\n\n| tool | what it is | how to get it |\n|---|---|---|\n| [lean-lsp-mcp](https://github.com/oOo0oOo/lean-lsp-mcp) | the Lean language server over MCP: diagnostics, goal state, hover, references. Answers per file in seconds what `lake build` reports in minutes, which is the right tool after a rename | `uvx lean-lsp-mcp`, wired through a `.mcp.json` in the repository root. That file is **gitignored**, so each contributor writes their own: `{\"mcpServers\":{\"lean-lsp\":{\"type\":\"stdio\",\"command\":\"uvx\",\"args\":[\"lean-lsp-mcp\"]}}}` |\n| [lean-explore](https://github.com/justincasher/lean-explore) | semantic search over Lean 4 declarations — by meaning, not by name | an MCP server; install per its README |\n| [LeanSearchClient](https://github.com/leanprover-community/LeanSearchClient) | [leansearch](https://leansearch.net) and [loogle](https://loogle.lean-lang.org) queries from inside Lean | **already a dependency** — in `lake-manifest.json`, no setup |\n| [lean4-skills](https://github.com/cameronfreer/lean4-skills) | \"Lean 4 theorem proving skill and workflow pack for AI coding agents\" — proof repair, golfing, axiom elimination. MIT | install into your agent harness; not published by this project and not required |\n\n**A semantic search is not evidence.** These indexes are not pinned by this\nrepository, so a miss is not reproducible and cannot support a claim that a\nresult does not exist.\n[`docs/agent/policy/lean-reuse-sources.md`](docs/agent/policy/lean-reuse-sources.md)\nsays what such a claim may cite, and lists the libraries worth searching before\nyou write a proof of your own.\n\n## License\n\nApache-2.0. Individual external formalizations remain subject to their own\nlicenses; the registry records those licenses when verified.\n",1791742498117]