# The Minimal Core *See the whole paradox in the smallest environment that can host it.* [![Minimal Core](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml) [![Complete Project](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml) One self-contained Lean file - [`ZeroParadox/Miniature.lean`](ZeroParadox/Miniature.lean), about three hundred lines, importing only Mathlib - exhibits the entire **shape** the Zero Paradox is built on, on the smallest concrete objects that can carry it. Most steps are decided by computation or proved in a line or two: computed, not asserted. The technique is standard: one abstract shape, several concrete instances, joined by a shared interface rather than by claiming the objects are equal. This is the front door. The file it points to is the back door - the same thing, checkable. --- ## Two ways in **If you just want the idea** - keep reading below. **If you want to check it** - read [`Miniature.lean`](ZeroParadox/Miniature.lean) top to bottom, or run it yourself from the repository root: ``` lake env lean ZeroParadox/Miniature.lean ``` Nothing is left unproven (0 `sorry`). And you do not have to take anyone's word for it: the [Minimal Core CI gate](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml) re-checks the file on every change with Lean - a proof assistant whose only job is to reject a false step - and writes a plain-language report of exactly what passed. The badge above is green when it does. --- ## What it shows The framework's central claim is that one structure - a **diagonal fixed point** (the point that is its own image under a self-map; the home of the classical self-reference arguments, after Lawvere 1969) - sits at the bottom of several mathematical fields, and that a forced one-way transition off it - the **snap**, this project's shorthand - is a theorem. The minimal core puts that structure on minimal witnesses: - **The engine** - Lawvere's diagonal: self-reference, once it closes, forces a fixed point (formally, a point-surjection forces every self-map to have one). Its seed - that negation has no fixed point - is the wall side, the same argument failing to close. - **The wall and the floor** - a classifier, relative to whichever class of self-maps you admit, that sorts the two: where self-reference *cannot* close (the **wall** - Cantor, Russell, Turing, Tarski) and where it *does*, landing on a self-referential bottom element (the **floor**). - **The pole** - the two-element `{0, ∞}`, its exactly four self-maps, and why the wall sits at the inversion `0 ↔ ∞` and the floor at a collapse. - **The snap, in both directions** - it is at once a one-way collapse *and* an ascent to a limit that is itself a bottom. On the minimal chain, the top point is *simultaneously* the supremum of the climb (a limit) and the least fixed point of successor (the bottom of the fixed points) - which is exactly why the snap needs both directions and cannot be flattened to one. - **The fan-out** - the branching field that the two-element pole is too small to hold. A single capstone theorem bundles all of it: wall, floor, the collapse's irreversibility, the snap-limit that is both a limit and a bottom, and the fan-out - the whole shape on two points, a minimal chain, and a minimal branch. --- ## What the floor stands for The minimal core represents the floor as bare fixed-point existence. In the full framework that fixed point is a *self-referential* object - the **Quine atom** (CC-2; Quine; Aczel), a role: a point that steps to itself and to nothing else, which in set theory is a set that is its own only member, x = {x}. Three of its faces are *proved* to be the same element within a single carrier, with no axioms beyond what the carrier's `AFAStructure` instance already asserts - the Quine atom (set theory), the order-bottom `⊥`, and the algebraic identity element, shown to coincide by the framework's execution theorem (T-EXEC, the three-face form `t_exec_triple_iff`). The fourth, the Kleene quine (a program that prints itself, in computability), is compared with them through that role, never joined by an identity: no code is equated with ⊥; with codes stepping to the codes whose output a map assigns them, no single code occupies the role (`evalStepMotion_not_selfOnlyAt`), and for a computable map respecting equal output a class of codes up to equal output does (`codes_vs_classes`). **And that fourth face is the one to stop on** - it is where the whole thing starts to move. The other three faces are *static*: the order-bottom, the self-membered set, and the algebraic identity are timeless facts that simply hold, and nothing about them ever *happens*. The Kleene quine is the only one that *runs*. Anyone who writes software knows this in their hands: a program that is never run does nothing - it is inert text on disk; running it is the event, and execution is where the state changes, not the (often empty) output. The framework once read ⊥ as the machine in its ground state, which must run itself. That reading splits in two: its identity half, that ⊥ IS some machine or code, is retired; its running half splits again: that ⊥ actually runs is the occurrence commitment, and that, if it runs, nothing outside it runs it is DA-1's Path 1 reading, which rules out an external executor and not an inert ⊥. So committing that ⊥ of the lattice actually runs is committing that **time enters the framework, as a state change**. That is the hinge, and it is the easiest thing here to walk past. It is what makes the framework dynamic at all: nothing static occurs on its own, so without that commitment ⊥ would rest as a fixed point forever and the snap would never happen. Two honest halves, kept separate here as everywhere: the *structural* self-application fixed point is Lean-proved and axiom-free; the *literal* set-membership x = {x} is not asserted of the lattice's ⊥, since an equation between a lattice element and a set is ill-typed. In the die the Quine atom is a role, a point that steps to itself and to nothing else, and its occupancy is proved chart by chart: ⊥ of the lattice is the only occupant under a self-application map supplied by `AbstractSelfApp` (`selfApp_quine_role_iff`); in a `QuineAtomHost`, whose bottom is its own only member and the only such element, the host's own bottom is the only occupant with membership as the step (`quineAtomHost_quine_role_iff`); and no well-founded set occupies it (`zfset_quine_role_unoccupied`). A set equal to its own singleton needs a non-well-founded set theory, ZF+AFA, to host it, and adopting that host is the metatheoretic commitment. The minimal core shows the structural half; the set half is cited to its home, not rebuilt. ### Don't trust me - follow the reasoning Every step above is either something a machine already checked, or a commitment I am naming out loud as a commitment. Here is exactly which is which, so you can walk the argument yourself and disagree in the right place. Run `#print axioms ` on any of them. | The claim | What backs it | Status | |---|---|---| | Self-reference, once it closes, forces a fixed point - the engine | `lawvere` (Lawvere 1969 / Yanofsky 2003) | proved, no axioms | | Three faces are one element *within one carrier*: the self-containing element, the order-bottom, the join-identity | `t_exec_triple_iff` | proved, no axioms - but read the bracket: the self-containment is a *field* of the `AFAStructure` instance, so it is supplied, not derived. The literal x = {x} is refuted in Mathlib's `ZFSet` (the `example` after `no_quine_atom` in `ZeroParadox/Settheory/Wall.lean`); `zfset_selfOnlyAt_mem_iff` makes it the die's Quine-atom role, which no set occupies (`zfset_quine_role_unoccupied`) and which is occupied in the coalgebra chart (`cofix_quine_role_occupied`), a one-point chart whose occupancy restates its own fork | | The fourth face, the running program, does that same job - in time | the `KleeneStructure` typeclass | its identity reading is **retired**; that ⊥ runs is the occurrence commitment, not a theorem | | The machine's before- and after-states are distinct (that execution *is* the state change is part of the model, not this theorem) | `l_run` (`c₀ ≠ c₁`) | proved | **If you want to disagree, the place to do it is the commitment:** that the self-contained bottom and the self-executing program do the same job, one of them in time. Everything else above is either machine-checked or follows from it. The full claim-by-claim status, with every witness and its exact axiom footprint, is in the [Claims Ledger](CLAIMS.md). --- ## What this is - and is not - **It is the shape, not the whole project.** The framework's substance is its domain *instances* - set theory and AFA, the 2-adic numbers, proof theory, the categorical bridges, the full bottom-element family - which are this shape worn by real mathematics. The minimal core stands *alongside* them as the most compact statement of what they are all instances of. It does not contain them. - **The chain here is a shadow of the real thing.** The snap's true destination is the proof-theoretic ordinal ε₀; the minimal chain's top point is its smallest faithful shadow (a single fixed point where the real ε₀ has a whole hierarchy above it). The shape is faithful; the object is deliberately minimal. - **Nothing is claimed to be one object across fields.** That the domain instances are numerically identical is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). The only thing they share is the shape. - **The content is re-derived, not new.** The engine is Lawvere (1969) / Yanofsky (2003); the pieces exist across the framework's layers. The value here is the compression - the whole shape in one place, on the smallest witnesses, checkable in one command. --- ## Where to go next - **The formal index** - [README](README.md): the document table, the full Lean verification, and the claim-by-claim [Claims Ledger](CLAIMS.md). - **Plain language** - [Guide](GUIDE.md): illustrated companions and reading paths for every audience. - **The object itself** - [The Bottom Element (⊥)](BOTTOMELEMENT.md) and [The Binary Snap (⊥ → ε₀)](SNAP.md): dictionaries and maps, most characterizations carrying a machine-checked Lean witness.