# Zero Paradox Claims Ledger The Zero Paradox is not one claim — it is a set of individual, separately-stated claims, each carrying its own status: **proved** (and at what axiom cost), **argued**, **committed**, or **open**. This ledger is where every one of those claims lives in one place, with its Lean witness and the Lean kernel's exact axiom dependency, so the proved / argued / open boundary can be checked directly rather than reconstructed from the prose of the individual layers. Stating each claim's status individually and honestly — and making the boundary mechanically checkable — is a deliberate design value of the project: the framework is developed in public precisely so the line between what is proved and what is believed is never blurred. This ledger is a *view*, not a new source of truth. The authorities it consolidates are: - **Axiom profiles** — [ZeroParadox/AxiomProfile.lean](ZeroParadox/AxiomProfile.lean) (the checkable artifact; CI-built on every push). - **The Lean sources** — under [`ZeroParadox/`](ZeroParadox/) in this repository. - **The "argued, not proved" tier** — [Forced Metatheoretic Commitment](fmc.md) (definition, conditions, falsifiers). - **Versions and script hashes** — [Version Registry](register.md). If a Lean witness or file link below no longer resolves after the v3.0 source reorganization, the old→new map is in [`ssot.json`](ssot.json); report anything stale in [discussion #120](https://github.com/timbrigham/ZeroParadox/discussions/120). **How to verify the axiom column yourself.** Lean's kernel reports the complete axiom dependency of each theorem: ``` lake build ZeroParadox.AxiomProfile # compiles the curated artifact lake env lean ZeroParadox/AxiomProfile.lean # prints each #print axioms result ``` Notation: **(none)** = `'' does not depend on any axioms` (stronger than choice-free — not even `propext`). **[propext, Quot.sound]** = choice-free, uses only propositional extensionality and quotient soundness (both Lean 4 standard). **[propext, Classical.choice, Quot.sound]** = inherits `Classical.choice` from a Mathlib library; in this framework that occurs mostly in the analytic *realization* layers and never in a core claim (see Tier 3). It is not always inherited: in the category-theory face and in the die (`ZeroParadox/Die.lean`, the order-free motion and its premises, the order premises stated over partial orders with a least element), neither of them a core claim, the `classical` is the framework's own and essential on the premise stated in `ZeroParadox/Category/ChoiceCannotBe.lean` § IV (`ZeroParadox/Category/LawvereTaboo.lean` § III; `ZeroParadox/Die.lean`'s `botCovered_botIntervalTwo_classical`, `Motion.registeredDecidable_of_classical` and `Motion.selectedTotal_of_classical`, the last also calling `Classical.choose` directly). The die also inherits choice from Mathlib's computability layer: the statement of its computable-registration variant, `Motion.RegisteredComputable`, carries it (statement control, 2026-10-18; `ZeroParadox/AxiomProfile.md`). --- ## Tier 1 — Proved, Axiom-Free (Depends on No Axioms at All) The framework's load-bearing claims. The Lean kernel reports no axiom dependency whatsoever. | Claim | Readable name | Lean witness | Axioms | |-------|---------------|--------------|--------| | T-SNAP | The Binary Snap (⊥ → ε₀) — the central theorem. `t_snap_given` states two of its premises as hypotheses (start at ⊥, occurrence at the first step; in the occurrence commitment's slot chart both come from a tape that fired at least once, with `φ` sending `false` to ⊥ of `L` and `true` to a point other than ⊥ of `L`, `t_snap_of_fires_once`); `t_snap_derived` is its MachinePhase instance at a sequence chosen to move | `t_snap_derived`, `t_snap_given`, `t_snap_machine`, `t_snap_join`, `t_snap_irreversible` | (none) | | DA-1 (given DP-2) | Instantiation alignment, minimal path — *closed conditional on DP-2 (Tier 5)* | `da1_minimal_path` | (none) | | DP-2 (formalized) | Execution distinguishability lemma — *the proved lemma; the modeling commitment it encodes is Tier 5* | `dp2_execution_distinguishability` | (none) | | ⊥ = minimum | Lattice bottom is the least element (ZP-A) | `ZPSemilattice.bot_le` | (none) | | CC-1 (in ZP-A) | Given S₀ = ⊥, ⊥ ≼ Sₙ for every n. The hypothesis is unused: `bot_le` gives the bound for any sequence, so S₀ = ⊥ itself stays a modelling commitment | `ZPSemilattice.cc1` | (none) | | Quine atom = ⊥ | The self-containing bottom is executable self-reference (ZP-J) | `bot_is_quine_atom` | (none) | | CC-1 restated | In any AFAStructure lattice, a state sequence that starts at a Quine atom starts at ⊥, and conversely: the conditional is derived, and the two starting conditions are one. That renames the choice without forcing it: on a carrier with a second point a valid state sequence can start above ⊥, at a point that is not a Quine atom (the OntologicalStates `example` in `ZeroParadox/Settheory/OntBridge.lean`); on a one-point carrier the start is forced | `cc1_derived`, `t_exec_iff` | (none) | | T-EXEC | In the AFA face, any Quine atom of a `ZPSemilattice` carrying `AFAStructure` is ⊥ of that `ZPSemilattice` (the diagonal fixed point lands at its bottom). The *self-execution* reading is the framework's: no code is equated with ⊥, and that ⊥ executes is the occurrence commitment (ZP-K, `ZeroParadox/Computability/Kleene.lean` § II) | `t_exec` | (none) | | Quine atom unique | The fixed point is unique | `quine_atom_unique` | (none) | | J_self largest | Every set of self-containing elements lies in J_self (true of any predicate), and ⊥ is its only possible member. Shaped like Aczel's Theorem 6.5(2), not an instance of it: no set-continuous operator is defined, so it does not address Aczel's Dependent Choice question | `J_self_is_largest`, `prefixed_elems_eq_bot` | (none) | | T-IZ (limit step) | Anything playing the bottom role **is** the bottom — the *role* half. Statement: `(∀ x, join terminal x = x) → terminal = bot`; no chain, no limit, no novelty. Reading the limit as a **successor** ⊥ is a commitment (novelty is not expressible within one lattice) | `t_iz_limit_is_new_null` | (none) | | Diagonal family (wall + floor faces) | The self-reference arguments formalized here, by the μ/ν fork: the wall faces where self-reference cannot close, each the contrapositive of Lawvere's engine (Cantor, Russell, Turing, Tarski, Curry), and the axiom-free floor faces (Löb, Gödel 2nd), whose fixed point comes from a hypothesized Löb diagonal, not from the engine | `lawvere_fixedpoint`, `cantor_via_engine`, `russell_via_engine`, `no_self_decider`, `tarski_no_internal_truth`, `curry_no_bottom`, `loeb`, `godel_two` | (none) | ## Tier 2 — Proved, Choice-Free `[propext, Quot.sound]` No `Classical.choice`; at most propositional extensionality and quotient soundness. | Claim | Readable name | Lean witness | Axioms | |-------|---------------|--------------|--------| | Fixed-point-free ⇒ weak excluded middle | The keystone taboo reduction - the general principle is not constructively re-provable on the premise in `ZeroParadox/Category/ChoiceCannotBe.lean` § IV | `wem_of_fixedPointFree` | [propext, Quot.sound] | | Well-order comparability ⇒ excluded middle | The ordinal taboo reduction (prior art: Kraus-Nordvall Forsberg-Xu arXiv:2104.02549 Thm 38(d), there in the data form). ⚠ Its subject's choice is MATHLIB's (`InitialSeg.total`) - an INHERITED dependence that is essential on its premise (`ZeroParadox/Category/ChoiceCannotBe.lean` § IV) | `em_of_wellOrder_comparable` | [propext, Quot.sound] | | Power-set floor | Depth chart in the power-set model: a depth threshold above ∅, not the first-step order property (`ZeroParadox/Order/PowerSet.lean` T-PS6) | `ps_structural_floor` | [propext, Quot.sound] | | Wheel instance | Wheel of fractions is a wheel (Carlström Def 1.1) | `instWheel` | [propext, Quot.sound] | | ∞ ≠ ⊥ | The wheel's infinity is distinct from its bottom | `inf_ne_bot` | [propext, Quot.sound] | | Fixed-point fork | lfp/gfp collapse iff the operator has a unique fixed point | `fork_collapse_iff` (with `fork_le`, `collapse_of_unique`, `unique_of_collapse`) | [propext, Quot.sound]; `unique_of_collapse` [propext] | | Coalgebra fork (μ side) | `Fix` empty — choice-free | `fix_isEmpty` | [propext, Quot.sound] | | Quine-atom identity | The self-referential fixed points are exactly {⊥} (unique, and = ⊥) | `quine_self_members_eq_bot` | [propext, Quot.sound] | ## Tier 3 — Proved, Inherits `Classical.choice` From Mathlib (Analytic Realizations) These *realize* the snap floor inside standard analytic structures and inherit `Classical.choice` from Mathlib's classically-built topology / inner-product / category / probability / computability / ordinal libraries. **The dependence is in the realization, not in any core claim** (those are Tier 1–2). All report `[propext, Classical.choice, Quot.sound]`. **One row below is the exception: the fixed-point-free construction, whose `classical` is the framework's own and is not inherited.** | Claim | Realization | Lean witness | |-------|-------------|--------------| | Fixed-point-free construction (the framework's OWN choice, **not inherited**) | category theory - a bare `classical` in `ZeroParadox/Category/Lawvere.lean`, not a Mathlib library. Essential rather than incidental on the premise in `ZeroParadox/Category/ChoiceCannotBe.lean` § IV: `wem_of_fixedPointFree` reduces the general fixed-point-free principle to weak excluded middle. The cost is the *generality* over arbitrary types - it disappears under `[DecidableEq β]` (`decidable_route_unaffected`, `[propext]`) | `fixedPointFree_of_nontrivial` | | Snap irreversibility | p-adic topology (ℚ₂) | `c3_irreversible` | | Snap orthogonality | Hilbert space | `t4_snap_orthogonal` | | ⊥ as inverse limit (terminal there since it has one point, not initial) | TopCat | `fB_functor`, `floorConeIsLimit`, `padic_bottom_isTerminal`, `padic_bottom_not_initial` | | ⊥ as zero object (`Statement:` COINCIDENCE - initial and terminal at once) | ModuleCat ℂ | `fD_functor`, `hilbert_bottom_isZero` | | ⊥ as initial object, not terminal | KleisliCat PMF (`fC_no_return` = AX-G2 as theorem, for the stages `n > 0`) | `fC_functor`, `kleisli_bottom_not_terminal` | | ε₀ as exact snap threshold | ordinal tower, 2-adic convergence | `epsilon_zero_snap_canonical`, `snap_zp2_correspondence` | | ε₀ is min ≡ max (least fixed point ≡ tower supremum) | ordinal fixed-point theory; the snap ⊥ → ε₀ as one Kleene chain, seed ⊥ → closure ε₀ | `epsilon0_min_eq_max`, `epsilon0_eq_nfp_bot` | | Computational grounding | MachinePhase: ⊥ is the unique Quine atom. The code side enters as a `KleeneStructure` class field, not as a clause of the theorem, and no code is equated with ⊥ | `da1_closed_concrete` | | Rice face (diagonal family) | computability - a computable `f : Code → Code` has a fixed point up to `eval`, and membership in a nontrivial extensional set of codes is undecidable over all codes; the second conjunct does not mention `f` (`ZeroParadox/Computability/Rice.lean`) | `rice_face_has_bottom`, `quine_exists_yet_rice` | | Kleene–ordinal bridge | MachinePhase → ℤ₂: tower stages below ε₀, the snap value at ε₀, 2-adic convergence, and the embedding — no computational conjunct | `zpm_triangle` | | Quine ∧ ε₀ co-witnessed | both diagonalizations produce a fixed point in their own domain (a conjunction of two existentials, not an identity across them) | `both_fixed_points_exist` | | ℝ ≠ ℚ₂ (Ostrowski) | number-system instance of the fork | `real_not_equiv_padic`, `completions_exhaustive` | | No snap in ordered fields | ℝ, ℚ as counterexamples | `f_snap_impossible`, `r_snap_impossible` | | Snap-occurrence dichotomy | `Statement:` CARRIER - ℚ_p is totally disconnected, ℝ is not; Ostrowski: these are the only completions of ℚ, and they are mutually exclusive. The theorem is those four facts conjoined, and the word "snap" does not occur in it: this layer STIPULATES "snap occurs" to mean total disconnectedness. ⚠ Two senses, kept apart. Under the stipulated sense the theorem rules it out in ℝ, and what rules it out there is CONNECTEDNESS (`place_topological_signature`; `real_no_snap` states the consequence, not totally disconnected); it does not supply it in ℚ_p. Under the other sense - a FIRST STEP, a cover (`HasFirstStep`) - the obstruction is DENSITY (`axb1_fails_everywhere_iff_dense`, no topology in it). Mathlib supplies no order instance on ℚ₂ (`LT ℚ_[2]` does not synthesize, probed at p = 2); under the norm preorder ℚ₂'s 0 has no first step either, as in every nontrivially normed field (`ZeroParadox/BottomCannotBe.lean` § ROLE). What supplies a first step, on the state carrier, is AX-B1, a modelling commitment | `snap_dichotomy` (with `padic_snaps`, `real_no_snap`) | | Quine-atom dichotomy (structural) | μ/ν fork — the self-referential object exists on ν (non-well-founded), not μ; the "Quine atom ⟺ AFA" reading is metatheoretic (Tier 4), not this theorem | `quine_dichotomy` | | T-IZ (full conjunction) | the Inside-Zero steps taken together (a conjunction, not a chain — see the T-IZ row) — inherits choice from more than one place: its 2-adic convergence step (`t_iz_cauchy`, choice from Mathlib analysis) as well as its ZP-K/DA-1 step. The limit-step lemma alone is axiom-free (Tier 1) | `t_iz_complete` | *Whether this **inherited** dependence is structurally forced by the snap geometry or merely incidental to Mathlib's implementation is **open** (see Tier 6). The one layer classified so far (the `PadicTree` choice-probe) found it mostly incidental and routable. ⚠ The open question is scoped to the dependence NOT covered by a reduction, and to statements that do not themselves carry choice (where they do, STATEMENT-CARRIED, `ZeroParadox/Category/ChoiceCannotBe.md`, the question moves to a restatement on a choice-free carrier). The cases that `ZeroParadox/Category/ChoiceCannotBe.lean` § IV counts as settled, given its premise, are `wem_of_fixedPointFree`, `wem_of_botCovered_botIntervalTwo`, `Motion.em_of_registeredDecidable` and `Motion.em_of_selectedData` (whose subjects carry the framework's OWN `classical`) and `em_of_wellOrder_comparable` (whose subject spends MATHLIB's, in `InitialSeg.total`); § IV also lists `em_of_covBy_Icc_eq` beside them, uncounted, and says why. Each reduction is itself choice-free (at most `[propext, Quot.sound]`), which is the only shape that can establish a principle's necessity — and `em_of_wellOrder_comparable` shows an INHERITED dependence can be essential too.* ## Tier 4 — Argued, Not Proved (Forced Metatheoretic Commitments) Foundational choices the framework's internal structure rules out alternatives to *by argument, not proof*, and falsifiably. Each is metatheoretic — it lives in the ZFC⁻ + AFA framing, not the Lean kernel — and carries a named falsifier. See [Forced Metatheoretic Commitment](fmc.md). | Commitment | What is argued | Proved part (separate) | Named falsifier | |------------|----------------|------------------------|-----------------| | Host-theory requirements (R-AFA, ZP-E) | Adopting AFA is CC-2's commitment; the host requirements (`QuineAtomHost`) are its Lean abstraction: (Y') a Quine atom (CC-2), a host bottom that is its own only member, and (Z') its uniqueness among reflexive sets (x = {x}), which AFA meets (it allows at most one solution of x = {x}, Aczel 1988, p. 19). That these are the right abstraction of the commitment is argued | In Lean (`ZeroParadox/Settheory/QuineHost.lean`): `quineAtomHost_not_wellFounded` (axiom-free), a `QuineAtomHost` membership is not well-founded, so (X) Foundation-freeness is forced; `zfSet_no_singleton_bottom` (choice-free), no `ZFSet` is its own sole member. Cited, each with a finite toy: Boffa's BA₁ makes the reflexive sets a proper class, failing (Z') (Aczel 1988, Prop. 5.1, p. 57; `boffa_fails_reflexive_unique`); AFA meets (Y') and (Z') (Aczel 1988, p. 19; the toy in `QuineHost.lean` § VII, a model of the pattern, not of AFA). `QuineHost` (⊥ ∈ ⊥ and uniqueness among self-members) is incomparable with it, and AFA's membership fails it, since 0* = {∅, 0*} is self-membered (Aczel 1988, Example 1.5, p. 7) | A natural host-requirement set other than (Y') + (Z') - a different characterization of the bottom the framework has equal claim to - would overturn the framing (`quineAtomHost_not_wellFounded` runs one way, from (Y') to a membership that is not well-founded, so it does not test this falsifier) | | CC-2 set-membership reading | Not an identity: ⊥ of a `ZPSemilattice` is not asserted to be the set Q = {Q}, since an equation between the two would be ill-typed. What the set chart contributes is argued only through the host requirements in the row above | That every Quine atom (`IsQuineAtom`) of a `ZPSemilattice` with an `AFAStructure` is ⊥ (`t_exec`) is axiom-free; with the AFA-built host's membership as the step, being such a Quine atom is filling the die role (the `IsQuineAtom` `example` in `ZeroParadox/Settheory/QuineDichotomy.lean`). In the die the role is `Motion.SelfOnlyAt`, a point that steps to itself and to nothing else: ⊥ of a `ZPSemilattice` is its only occupant with the `AbstractSelfApp` map as the step (`selfApp_quine_role_iff`); a `QuineAtomHost`'s own `bot` is its only occupant with membership as the step (`quineAtomHost_quine_role_iff`), so ⊥ of the semilattice occupies it exactly when the host's `bot` is ⊥ (the host `example`s after it in `ZeroParadox/Settheory/QuineDichotomy.lean`); no `ZFSet` occupies it (`zfset_quine_role_unoccupied`). Every `ZPSemilattice` carries an `AbstractSelfApp` (`trivialSelfApp`) and every inhabited type a `QuineAtomHost` (`trivialQuineAtomHost`) | With membership as the step, a Foundation-respecting realization of the role is refuted by theorem: under any well-founded membership relation no point occupies it (the well-founded `example` in `ZeroParadox/Settheory/QuineDichotomy.lean`, from `wf_no_selfloop`), so that falsifier could never fire. With the `AbstractSelfApp` map as the step the role is occupied in every `ZPSemilattice` (`selfApp_quine_role_iff`, `trivialSelfApp`), Foundation or not, so this row's subject is the membership chart only. What stays falsifiable is the host-requirements choice, tested by the falsifier in the row above | ## Tier 5 — Modeling Commitments (Chosen, Not Derived; Not Open Questions) Explicit, motivated commitments. Listed so the open register holds only genuinely unresolved questions. | Commitment | Nature | Lean note | |------------|--------|-----------| | The diagonal fixed point (shared shape) | ⊥ plays one self-referential fixed-point role; each framework's face is that role in its own language - a chosen defining criterion of the family | Faces proved per framework (the lattice face as the Quine atom `t_exec`, Tier 1; the 2-adic face v₂(0)=∞ ZP-B and the categorical initial ZP-G, Tier 3); the Kleene face is carried as a requirement (ZP-K `KleeneStructure`), its witness `computability_face_fixedPoint` a Kleene code fixed up to eval by a computable map, a term of another type than ⊥ of the ZPSemilattice. That the proved faces carry the *same shape* is proved face-by-face; that they are *one object* is retired as ill-typed (MC-1, below). The Lawvere unification of the shape is conjectural (Tier 6). | | MC-1 - the bottom family | The four domain bottoms are one *family*, characterized by a shared list of criteria (the choice of criteria is the commitment) | Membership is proved per domain (the categorical criteria are a zero object (`Statement:` COINCIDENCE - initial and terminal at once) in `ModuleCat ℂ`, an initial object that is not terminal in `KleisliCat PMF` and, in `TopCat`, a floor that is terminal, since it has one point, and not initial, and separately the limit cone `floorConeIsLimit`; the three full positions are stated together in `floor_positions_full` (a zero object; initial and not terminal; terminal and not initial); `mc1_correspondence`, Tier 3, bundles the two `IsInitial` fields, the no-return field and the set equation `fB_bottom_is_limit`); the reading that they are numerically one object is retired as ill-typed: across distinct categories x = y and x ≠ y do not typecheck, and heterogeneous equality, which does, states nothing invariant for properties of a category: a property is invariant under equivalence exactly when it can be expressed without referring to equality of objects (Blanc's theorem, the equivalence principle); the framework extends this across categories. What separates the members is proved property by property: of the named bottoms only the Hilbert one is a zero object, and in a lattice with no top the ZP-A bottom is least but not greatest (`seam_unique_among_named` (`ZeroParadox/Category/SeamUniqueness.lean`)); more generally the bottom is not greatest on any carrier with a second element. Forgetting to underlying types, some are provably distinct. | | DP-2 (execution distinguishability) | The commitment DA-1 rests on; motivated by ZP-C D7, not freely chosen | *Listed in two tiers by design:* the formalized lemma is proved and axiom-free (`dp2_execution_distinguishability`, Tier 1); the modeling choice that lemma encodes is the commitment, recorded here | | BA-1 (temperature T) | A universe-contingent scale parameter; specific value irrelevant to structure | Not formalized - the framework's only bridge to physical units, via Landauer's `E = kT ln2` (referenced in ZP-C/E/H). The information-thermodynamics of the snap is an open direction, not a claim. | A commitment marked "not a novel commitment" in the layers means its content is formally grounded in prior layers and derivable there; it is stated as a local axiom only for the self-containment of that layer — the same pattern by which the snap's shape was stated as an axiom (AX-1) before being derived as T-SNAP. **AX-1 (Binary Snap Causality) is retired.** Its content was split in two: the shape of the snap is proved, as Theorem T-SNAP, and that the snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). `tsnap_holds_but_nothing_moves` shows T-SNAP does not carry it. T-SNAP is derived in ZP-E. A4, the standard bottom-element axiom of join-semilattice theory (∀ x, ⊥ ∨ x = x), gives the join; AX-B1 supplies the atom; `t_snap_given` takes the start at ⊥ and occurrence at the first step as hypotheses. The join part of AX-1 was redundant as an axiom — any join-semilattice with bottom already has the join property.
The bottom family (MC-1) — in full - click to expand The bottom elements across the layers - the algebraic ⊥, the 0 of Q₂, the Turing initial configuration c₀, and the categorical initial object - form one **family** (MC-1), each a member characterized by shared criteria it satisfies - and all sharing the self-referential (diagonal) fixed-point *shape*. Membership splits into a correspondence half, now formally realized in Lean, and a former identity half - that the four are numerically one object - which is **retired** as ill-typed rather than held as a commitment (object equality across categories does not typecheck and is not invariant under equivalence); what separates the members is proved property by property (`seam_unique_among_named` (`ZeroParadox/Category/SeamUniqueness.lean`), for the named bottoms, in a lattice with no top). Its faces are the Quine-atom role (CC-2; in set theory a set x = {x}), the point v₂(0) = ∞ in valuation, and the initial object in category theory, each proved in its own domain; the Kleene face in computation is carried as a requirement (ZP-K `KleeneStructure`), its witness `computability_face_fixedPoint` a Kleene code fixed up to eval by a computable map, a term of another type than ⊥ of the ZPSemilattice. This identification is substantially grounded rather than stipulated: each domain locates its own bottom through its own logic first, and the cross-layer agreement is then enforced formally (the ZP-E typeclass instance ties ZP-A ⊥ to ZP-C c₀; AX-G1 grounds the categorical initial in ZP-A ⊥; ZP-H T-H3 proves snap consistency across all four functors). The categorical correspondence is now realized in the standard domain categories of Mathlib: the snap floor is terminal in `TopCat`, since it has one point (`padic_bottom_isTerminal`), and not initial (`padic_bottom_not_initial`), and separately the inverse limit of the ball tower there (`floorConeIsLimit`); it is the zero object (`Statement:` COINCIDENCE - initial and terminal at once) in `ModuleCat ℂ`, and an initial object that is not terminal in the Kleisli category of the probability monad `KleisliCat PMF` - with no morphism into it from any later stage of the functor in the stochastic case (`fC_no_return`). The three full positions are stated together in `floor_positions_full` (a zero object; initial and not terminal; terminal and not initial); the bundled witness is `mc1_correspondence`. What is retired is the interpretive move to call these *one object*: `x = y` across distinct categories is not a well-formed proposition in the typed language, so it was never a claim to hold. For the equivalence principle see Ahrens & North, "Univalent foundations and the equivalence principle", arXiv:2202.01892, § 2 (Blanc's theorem as stated there: a property of categories is invariant under equivalence if and only if it can be expressed in the typed language without referring to equality of objects). (An earlier framing tried to salvage it - recasting "are the bottoms one object?" as a descent / gerbe-triviality question in the manner of Giraud, over the domains - but classical descent needs a single base site and these domains share no canonical common index, so it was a proposed frame, never an instance of a theorem; retiring the identity as ill-typed supersedes it.) What survives is the family: membership proved per domain, what separates the members proved property by property (`seam_unique_among_named` (`ZeroParadox/Category/SeamUniqueness.lean`), for the named bottoms, in a lattice with no top), and the shared diagonal-fixed-point *shape* in the apophatic register - never a formal cross-category identity.
The metatheoretic stance — the host-theory requirements (and where AFA fits) - click to expand This framework is stated over ZFC⁻ + AFA (Zermelo-Fraenkel set theory with Choice, with the Anti-Foundation Axiom in place of Foundation: Aczel 1988, p. xviii; Barwise & Moss 1996, p. 72, whose ZFC⁻ on p. 28 also has urelements), not standard ZFC, and AFA permits self-containing sets (x = {x}). This affects only one commitment, the Quine atom (CC-2); the remaining results do not depend on non-well-founded sets. Choice is kept; which results use it is measured result by result (`#print axioms`, `ZeroParadox/AxiomProfile.lean`); the located cases where it is needed, given a stated premise, are collected in `ZeroParadox/Category/ChoiceCannotBe.lean` § IV; most footprints are unclassified. T-SNAP depends on no axioms (`t_snap_derived`). Adopting AFA is CC-2's commitment; the host requirements AFA satisfies (Tier 4, `QuineAtomHost`) are its Lean abstraction, and that any such host gives up Foundation is forced (`quineAtomHost_not_wellFounded`). What "forced" means here, and the discipline every such claim must meet, is defined in [Forced Metatheoretic Commitment](fmc.md). The framework's set-theoretic *commitment* (CC-2) is adopting the Anti-Foundation Axiom (AFA's "every graph has a unique decoration"); what the Lean abstracts of it is the *fragment* that supplies a **unique Quine atom**, a host bottom b = {b}: b's only member is b, and no other set is its own only member. That fragment is made checkable as `QuineAtomHost` (`ZeroParadox/Settheory/QuineHost.lean`): the host must supply **(Y')** b = {b} for its bottom b (`bot_mem_iff`) and **(Z')** uniqueness among reflexive elements, x = {x} (`reflexive_unique`). That is AFA's own profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19), while for every set a it decorates a* = {a, a*}, so self-membership alone is not unique under AFA (Examples 1.5–1.6, pp. 7–8). The third property, **(X)** Foundation-freeness, is not assumed — it is *forced* by (Y') (`quineAtomHost_not_wellFounded`, axiom-free: b ∈ b is a self-loop, and no well-founded relation admits one). The rival theories then sort out — one as a machine-checked theorem, two by toy models: **ZFC + Foundation fails (Y')** in-kernel about Mathlib's real `ZFSet` (`zfSet_no_singleton_bottom`, choice-free, via `no_quine_atom`); **Boffa's BA₁ makes the reflexive sets a proper class** (Aczel 1988, Prop. 5.1, p. 57), so it fails (Z') — witnessed by a toy model in which every element is its own only member (`boffa_fails_reflexive_unique`), not an in-kernel result about Boffa's axiom; and **AFA's pattern meets (Y') and (Z')** in a finite toy with real membership, Ω ∈ Ω, 0* ∈ 0*, ∅ ∈ 0* (`QuineHost.lean` § VII), a model of the pattern, not of AFA. The framework's lattice-level encoding meets the class too (`afaStructure_isQuineAtomHost`: ⊥ ∈ ⊥ from `bot_self_mem`, uniqueness from `quine_unique`); every inhabited carrier meets it (`trivialQuineAtomHost`), so realizability alone is uninformative. The older class `QuineHost` (a self-membered bottom, and uniqueness among self-members) is a different requirement, incomparable with this one, and AFA's membership fails it. Adopting AFA is CC-2's commitment, not a theorem (AFA is not forced); the host requirements are its Lean abstraction, and that any such host gives up Foundation is forced (`quineAtomHost_not_wellFounded`). (Where AFA-specific content is used elsewhere — e.g. decoration uniqueness, `APG.lean` — it is proved on its own terms, not assumed from full AFA.) (The "why AFA specifically" argument is ZP-E Remark R-AFA; the requirements are the Lean abstraction of what it argues for. It remains an argument, not a derivation in the formal system — see Tier 4 and its named falsifier.)
The supporting commitments (label, type, statement) - click to expand | Label | Type | Statement | |-------|------|-----------| | **AX-B1** | Modeling Commitment (the substantive one) | A state either exists or it does not - existence is **discrete/Boolean**, not a continuum of partial existence. This is the framework's one substantive modeling commitment. AX-B1 holds at every state with anything above it: each has a first distinct state above it, with nothing strictly between. A state with nothing above it owes no step. The `decide` proof (`ax_b1_distinct`) verifies the two states are distinct *given* the two-element type; the choice of a discrete alphabet over a continuum is the commitment itself, not what `decide` checks. The ZP-C forcing lemmas discharge the *no-half-state* worry - leaving ⊥ needs a genuine second outcome ([`pmf_subsingleton_isPure`](ZeroParadox/Information/Surprisal.lean); [`binaryState_exhaustive`](ZeroParadox/Information/Surprisal.lean) is axiom-free) - but they force only the ≥2-outcome *lower bound*: the residual substantive commitment is that the outcome space is **discrete**, not a continuum, which those lemmas do not eliminate and which is exactly what the reals lack (the snap provably fails there, [`f_snap_impossible`](ZeroParadox/Reals/OrderedField.lean)). | | **AX-G1** | Axiom | An initial object exists in the category C, and C has no terminal object. The bottom element ⊥ is the universal origin of all structure: a unique object from which every object is reachable in exactly one way; that no morphism returns to it is AX-G2, below. The initial-object half is not a novel commitment - ⊥'s existence as the bottom element of the ZP-A semilattice already guarantees it. The no-terminal half is ZP-G's own commitment: in ZP-A it is the optional hypothesis `HasNoTop`, which the two-state carriers (`MachinePhase`, `OntologicalStates`) do not satisfy (the `example`s after `machinePhaseZPS` in `ZeroParadox/Order/Snap.lean` and after `instOntZPS` in `ZeroParadox/Settheory/OntBridge.lean`); on a carrier that does satisfy it, each element has something strictly above it (ZP-A's order is antisymmetric), so there is no terminal object (the last `example` of § I-b in `ZeroParadox/Category/Category.lean`), and a preorder with a top carries no ZPCategory (`no_zpcat_top`). ZP-G names both in categorical language. | | **AX-G2** | Axiom | Source asymmetry: hom(X, 0) = ∅ for X ≠ 0. Once something emerges, it cannot return to nothing. Not a novel commitment where it holds: in a category built from a partial order with a least element, such as ZP-A's semilattice order and the ℕ-indexed depth categories ZP-H's Lean functors land in, a morphism X → 0 means X ≤ 0, so X = 0 by antisymmetry (the two antisymmetry `example`s at the end of `ZeroParadox/Category/AxG2Reduce.lean`). ZP-B C3 (topological irreversibility: no continuous path in Q₂ returns to 0) is the domain fact behind the Q₂ stand-in, proved in its own layer. AX-G2 does not hold in every category: in `ModuleCat ℂ` the bottom is a zero object, every stage has a morphism into it (the zero map, `fD_has_return`, `ZeroParadox/Category/Heterogeneous.lean`) and stage 1 is not a zero object (`leaf_not_isZero`, `ZeroParadox/Category/SeamNotColimit.lean`), so AX-G2 fails there. At an initial object, AX-G2 in its isomorphism form (no morphism into 0 from an object not isomorphic to 0) is equivalent to strict initiality (`ax_g2_from_strict_initial` and the converse `example` after it). | | **MP-1** | Principle | The representational base is the minimum sufficient base for AX-B1. Derives p = 2. | | **RP-1** | Principle | The probabilistic representation of a state in the two-element state space is a point-mass distribution. | | **DP-1** | Design Commitment | Clopen separation in Q₂ is represented by orthogonality in H. |
## Tier 6 — Open | Item | Status | |------|--------| | `Classical.choice` necessity (analytic layers and the die) | **Core is choice-free (verified); necessity is settled in the cases listed in `ZeroParadox/Category/ChoiceCannotBe.lean` § IV, given its premise, several analytic-layer statements are STATEMENT-CARRIED by measurement (`ZeroParadox/Category/ChoiceCannotBe.md`; for those the open question is a restatement on a carrier whose statements are choice-free; for the ε₀ results of `ZeroParadox/Ordinal/Epsilon0MinMax.lean` and `ZeroParadox/Ordinal/SnapNucleus.lean` it has a defined reading in Lean on `E0Note` and a derived one not located as of 2026-10-13, `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint), and the rest is open.** The central results carry no `Classical.choice` — T-SNAP depends on no axioms at all, and the lattice (ZP-A), the Quine-atom self-reference (ZP-J), and the structural floor are choice-free. Elsewhere it appears mostly where the framework builds on Mathlib's classically-built topology / analysis / ordinal / computability libraries (Tier 3). Two axes, and they are independent: **provenance** (whose declaration spends the choice) and **necessity** (whether any proof could avoid it). Each essential case rests on a choice-free taboo reduction — a reduction that spent choice would establish nothing — and the cases sit on both sides of the provenance axis. `fixedPointFree_of_nontrivial` (`ZeroParadox/Category/Lawvere.lean`) and `botCovered_botIntervalTwo_classical`, `Motion.registeredDecidable_of_classical` and `Motion.selectedTotal_of_classical` (`ZeroParadox/Die.lean`) carry a bare `classical` written in framework source (the last also calls `Classical.choose` directly), so those are **the framework's own**; well-order comparability spends Mathlib's choice in `InitialSeg.total`, so that one is **inherited** — and is essential on its premise (§ IV). **An inherited dependence can be essential**, which is why "inherited" never meant "removable". For everything outside those cases and the statement-carried statements, whether the dependence is forced or merely incidental remains **open**; the one layer classified so far (`PadicTree`, the choice-probe) found it mostly incidental and routable. For the ordinal results, ZP-N restates the ascent choice-free on ONote; the state of the restatement question is in `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint. | | OQ-E2: cardinality ↔ semilattice correspondence | **Partially closed — ZP-I T-IZ.** Ordinal indexing Ω = ω forced by the countable binary substrate (ZP-C D4, Q₂ separability, binary alphabet); internal/external perspective relativity is ordinal, not set-theoretically free. The formal connection between specific semilattice structures and specific CH instances remains open. | | DA-3: perspective-relative cardinality | Closed (definitional, via D7 exhaustiveness) / Candidate (DA-3-C1); formal cardinality derivation deferred to OQ-E2. | | Lawvere unification of the diagonal fixed point | **Conjecture / connection, not proved.** That the shared self-referential-fixed-point attribute (Tier 5) is an instance of Lawvere's fixed-point theorem (Lawvere 1969) is a connection, not a ZP result. Yanofsky (2003) restated that theorem in plain set/function terms and unified Cantor, Russell, Gödel, Tarski, Turing, and the recursion theorem (quine) as one scheme - those faces are prior art, cited not claimed. ZP's contribution relative to this literature: candidate faces outside their scope (the 2-adic valuation v₂(0)=∞, ε₀, the wheel), the machine-checked axiom/choice footprint of each face, and the location claim (the Gödel inversion: the Quine-atom and v₂(0)=∞ faces each have their fixed point at their carrier's bottom: the Quine atom is ⊥ of a ZP-A lattice carrying `AFAStructure` (`t_exec`), and 0, the unique fixed point of doubling on ℚ₂ (`q2_unique_fp`), is the least element of ℚ₂ ordered by the 2-adic norm, and the greatest when ℚ₂ is ordered by valuation, where v₂(0)=∞; the ε₀ role never sits at a floor: it is the first landing (a fixed point of the closure) strictly above one. The value `Ordinal.epsilon 0`, lifted as `↑ε₀`, fills the ε₀ role, the first landing strictly above a floor: in `WithBot Ordinal`, above the boundary model's floor placed at the bottom (`phase_epsilon0_isLeast_landing_above_floor`), and in `WithTop Ordinal`, where that floor is placed at the top, the first landing strictly above that order's least element, the snap `↑0` (`phaseTop_epsilon0_isLeast_landing_above_snap`; both `ZeroParadox/Multihomed/BoundaryOrder.lean`). In `Ordinal` that value differs from the bottom role's occupant 0 (`epsilon0_ne_bot`, `epsilon0_ne_zero`)) - a framing, not a theorem. The numerical "one object" identity is retired as ill-typed; MC-1 names the resulting family (Tier 5), strictly weaker than any cross-face unification and well within the "same scheme" Lawvere/Yanofsky establish. See the Convergence section below. **Update (Lawvere):** the Set face is machine-checked - in Set no face carries a Lawvere witness, a point-surjection onto a function space (Cantor obstruction, `no_witness_of_nontrivial`), and run in the other direction the Set-level wall faces (Cantor, Russell, Turing, Tarski, Curry) are instances of the engine by its contrapositive - and Lean proves Rogers' fixed-point theorem classically (`computability_face_fixedPoint`, wrapping Mathlib's recursion theorem). That the computability face is a genuine Lawvere instance, in its multi-valued form (Bauer Thm 5.2), is cited, not proved here: the effective-topos / Turing-category setting, Hyland 1982 and Cockett–Hofstra 2008, is cited at `ZeroParadox/Category/DiagonalWitness.lean`, and the ZP-J Keystone Addendum's Section II box cites the Lawvere-form derivation (Bauer 2017); the cross-face unification into one object is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence); MC-1 is the family. | | The well-foundedness boundary (full Taylor coalgebraic; "Rung C") | **Best-effort done; full version open.** The snap as a ν→μ (non-well-founded → well-founded) crossing is formalized at the relation level (`Boundary`: `floor_not_wellFounded` axiom-free, `snap_crossing`) and bundled with ZP-P's categorical μ/ν fork (`BoundaryBridge`: `snap_boundary_two_registers`). The single-carrier "snap is one crossing" picture introduces no *new* commitment - it rests on reading its endpoints as ZP's own ⊥ (the lattice chart's ⊥) and ε₀ respectively, a role assignment the framework already carries (for the ⊥ endpoint, MC-1 family membership; for the ε₀ endpoint, theorems about the model itself in both of its extreme orderings, floor below as `WithBot Ordinal` (`phase_epsilon0_isLeast_landing_above_floor`) and floor above as `WithTop Ordinal` (`phaseTop_epsilon0_isLeast_landing_above_snap`) (`ZeroParadox/Multihomed/BoundaryOrder.lean`), so no cross-type identity is involved), with the endpoints (the floor non-well-founded via the lattice chart's ⊥, axiom-free; the ascent well-founded) independently proved. In the carrier `Ordinal` the bottom role is filled by 0. The value `Ordinal.epsilon 0`, lifted as `↑ε₀`, fills the ε₀ role, the first landing strictly above a floor: in `WithBot Ordinal`, above the boundary model's floor placed at the bottom (`phase_epsilon0_isLeast_landing_above_floor`), and in `WithTop Ordinal`, where that floor is placed at the top, the first landing strictly above that order's least element, the snap `↑0` (`phaseTop_epsilon0_isLeast_landing_above_snap`; both `ZeroParadox/Multihomed/BoundaryOrder.lean`). In `Ordinal` that value differs from the bottom role's occupant 0 (`epsilon0_ne_bot`, `epsilon0_ne_zero`). The full Taylor coalgebraic statement - well-founded coalgebras, the General Recursion Theorem (AMM Thm 7.2 p. 27, the FORWARD direction only) and its converse (their § 8, under further hypotheses; Cor 8.2 for the equivalence) - is not formalized. Neither Pataraia's fixed-point theorem nor a recursion theorem for well-founded coalgebras was located in the pinned Mathlib as of 2026-08-12, searched by declaration name and type. This project proves Pataraia's theorem and the induction Taylor derives from it, his Thm 118 and Cor. 119, with no axioms: `pataraia_least_prefixedPoint`, `pataraia_induction_constructive`, `ZeroParadox/Order/PataraiaChoiceFree.lean` (an independent Lean rendering of the argument as formalized in TypeTopology's Agda modules `Various.Pataraia`, Escardó's, for the `γ` step, and `Various.Pataraia-Taylor`, Escardó and de Jong's, for Taylor's condition `TC`). The first full published proof is Escardó, *Joins in the frame of nuclei*, Applied Categorical Structures 11 (2003) 117–124: Pataraia's theorem is his Cor 2.1, and the induction is the second clause of his Thm 2.2, stated there for sets of inflationary maps. A classical route through Mathlib's Bourbaki–Witt theorem is also kept. For the least fixed point it is Markowsky's (Algebra Universalis 6 (1976), Thm 9(i), proved there without choice), and the same adapter gives the induction; these Lean proofs carry `Classical.choice` in their footprint (`dcpo_exists_least_fixedPoint` and `pataraia_induction`, `ZeroParadox/Order/PataraiaFromBourbakiWitt.lean`); prior art: `ZeroParadox/Order/PataraiaFromBourbakiWitt.md`. The next-time operator is built at `ZeroParadox/Category/NextTimeCategorical.lean` (not upstreamed). Cited to Taylor / Adámek-Milius-Moss; flagged as an open contribution point. | | Second-prover cross-check | A Rocq (or other) independent re-verification is **not yet done**. | Open questions are also discussed publicly in the [GitHub Discussions Open Questions category](https://github.com/timbrigham/ZeroParadox/discussions/categories/open-questions).
Resolved questions (closed) - click to expand | Item | Status | |------|--------| | OQ-A1: Increment selection | OQ-A1b CLOSED by A1–A4; OQ-A1a: no reason to restrict to join-irreducibles (well-founded carriers); placement in the ordinal tower, for a monotone map sending the tower's stages to c₀, conditional on the alignment hypothesis hε₀ (ε₀ sent to c₁). ZP-E T5 (DA-1 insert § VI): no step is guaranteed, and on an arbitrary lattice no step is selected | | OQ-B1: p = 2 justification | Closed - ZP-B T0 (derived from AX-B1 + MP-1) | | S1: Distribution stipulation | Closed - ZP-C T1 (derived from AX-B1 + RP-1) | | OQ-C1: Non-conservatism of DF | Closed - ZP-C T2 (rebuilt within extended D6) | | R-BRIDGE: valuation-complexity bridge (the K-ratio route) | **Refuted** - counterexample Sₙ = 2ⁿ (ZP-I § II.B; ZP-C Remark R-BRIDGE); T-IZ never depended on it. The chain Sₙ = 2ⁿ is the valuation half, in Lean as [`scaleChain_isDepthChain`](ZeroParadox/Valuation/ScaleDepthWitness.lean); the complexity half is outside Lean. | | CC-1 (S₀ = ⊥) derivability | **Restated, not forced - ZP-J cc1_derived with t_exec_iff (axiom-free, Lean)**: in any AFAStructure lattice, starting at a Quine atom and starting at ⊥ are the same condition. The conditional is derived; the starting-point choice remains a ZP-A Conditional Claim, expressed through the Quine-atom role. The equivalence does not remove it: on a carrier with a second point a valid state sequence can start above ⊥ (`ZeroParadox/Settheory/OntBridge.lean`) | | CC-2 (the Quine atom, a role) as commitment | **Role occupant proved - ZP-J T-EXEC** (axiom-free): every Quine atom (`IsQuineAtom`) of a `ZPSemilattice` with an `AFAStructure` is ⊥, given the field `bot_self_mem`. In AFA set theory Q = {Q} is a theorem of that theory. That ⊥ of a `ZPSemilattice` is that set is not stated, since an equation across the two would be ill-typed; stated in the die, the Quine atom is the role `Motion.SelfOnlyAt`, with ⊥ of the semilattice the only occupant under the `AbstractSelfApp` map (`selfApp_quine_role_iff`), a `QuineAtomHost`'s own `bot` the only occupant under membership (`quineAtomHost_quine_role_iff`), and no `ZFSet` occupant (`zfset_quine_role_unoccupied`). What stays a Forced Metatheoretic Commitment (Tier 4) is the host: Foundation-freeness is forced (`quineAtomHost_not_wellFounded`), and the requirements and the adoption of AFA are argued, not a freestanding modelling choice | | AX-1: Binary Snap Causality | **Retired - shape proved as ZP-E T-SNAP (derived theorem); that the snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2)** (`tsnap_holds_but_nothing_moves` shows T-SNAP does not carry it, `ZeroParadox/Order/Snap.lean`). `Reading:` CARRIER — the occurrence commitment, in two charts: execution chart, instantiation occurs (Sense B, a running configuration); slot chart, the realized run has fired at least once, the hypothesis `hw` of `t_snap_of_fires_once` (`ZeroParadox/Information/CrossingTrials.lean` § VIII), which, with `φ` sending `false` to ⊥ of `L` and `true` to a point other than ⊥ of `L`, gives `t_snap_given`'s `hcc1` and `hocc`. If `0 < p ≤ 1` firing has probability one (`trials_fires_once`), and a particular tape need not fire (the all-`false` tape). Occurrence there is once: the sequence steps at index 1 and stays, so it is not an `IsStrictStateSequence`. `Reading:` CARRIER — the two charts correspond; a firing is not proved to be an execution event (`ZeroParadox/Order/SnapCannotBe.lean` § II) | | OQ-E1: Sequence vs. tree structure | **Closed given the occurrence commitment and C-DA2 - ZP-E DA-2.** The structure is a directed instantiation tree rather than a linear sequence. DA-2 with C-DA2 supplies the **succession**: DA-2 proves the role half only (a state playing the ⊥ role for the next instantiation IS that lattice's ⊥), and that the return is to a NEW ⊥ is the commitment C-DA2 (see the DA-2 row below; the proved `c_da2_novelty` in `ZeroParadox/Order/Snap.lean` carries the same handle and is only the role fact's contrapositive inside one semilattice, not a novelty witness); the **branching** comes from CC-2's undifferentiated ⊥ - with no internal differentiation, no direction is privileged, so every first differentiation is an equally valid outcome. Both then need instantiation to happen at all. T-SNAP does not establish that the snap occurs - `tsnap_holds_but_nothing_moves` (`ZeroParadox/Order/Snap.lean`) proves T-SNAP holds in a model where nothing moves. That the snap occurs follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2); that each return is to a new ⊥ is C-DA2. So the closure is conditional on the occurrence commitment for the snap and on C-DA2 for the succession, in the same sense DA-1 is "closed given DP-2" above. The question itself presupposes that instantiation happens; given that, DA-2 with C-DA2 settles the succession and CC-2 the branching, and the two together make the shape a tree. | | DA-2: Instantiation succession | **Closed for the ROLE-RECOGNITION; occupancy (that the terminal state of I_n fills the ⊥ role of I_n+1) and distinctness are commitments.** ZP-E DA-2 gives that ANY state satisfying the ⊥ role for I_n+1 IS that lattice's ⊥; that the terminal state of I_n is such a state is assumed, not derived. C-DA2 does **not** derive that each instantiation produces a provably distinct ⊥ — it **commits** to it. Its published proof was circular (the separateness of the spaces is assumed, not obtained from C3), and it is retracted from Corollary to Conditional Claim; the handle C-DA2 is unchanged. In the 2-adic realization the arc returns to the *same* 0 (`snap_arc_z2_loop`). Consistent with the T-IZ and Null-balance rows below, which this row previously contradicted. | | DA-1: Instantiation alignment | **Closed given DP-2 - ZP-E / ZP-K.** da1_minimal_path proved axiom-free; it takes no hypothesis, and given DA-1's precondition (the configuration reaching P₀ is a running machine's current configuration, Sense B) the step c₀ → c₁ is D7's. That precondition is what the occurrence commitment asserts; DA-1 consumes it and does not supply it, and Paths 1 to 3 argue for it with none deriving it. Path 1's Lean counterpart is da1_closed_concrete (ZP-K), which proves IsQuineAtom (⊥ : MachinePhase) and nothing computational; Path 1 rules out an external executor, not an inert ⊥. Path 3's Lean counterpart is the machinePhaseKleene instance's botCode_is_quine field - a KleeneStructure requirement that constant codes also meet, not a witness of execution and not a second independent proof; Path 3 does not derive executing from incompressibility. The two are carried together by da1_paths_unified as a conjunction; that they name one structural fact is the framework's reading. Path 2 (informational, L-INF): the step from unbounded surprisal to executing is a bridge principle of its own, which the framework does not adopt, which is not the occurrence commitment, and which is not a premise of the Snap. | | OQ-G1: Native categorical surprisal | Closed - ZP-G D7' and I-KC (Kolmogorov import; BA-G1 demoted to compatibility remark R-BA) | | OQ-G2: Left adjoint verification | Closed - ZP-H T-H1 (initial-object universal property verified for all four domain instantiations) | | OQ-G3: Functor construction | **Closed - ZP-H functor files.** F_A (NatSLat) plus sorry-free functors into standard Mathlib categories (TopCat, ModuleCat ℂ, KleisliCat PMF); bundled as `mc1_correspondence`. The cross-category numerical identity is retired as ill-typed; MC-1 is the bottom family, membership proved via these functors (Tier 5). | | OQ-G4: Singularity reconciliation | Closed - ZP-H T-H2 (categorical and ZP-C characterizations shown to hold together, a conjunction; neither is derived from the other, `th2_singularity_compatibility`) | | T-IZ: Inside Zero Theorem | **A CONJUNCTION derived in Lean, not a chain; occupancy takes a choice of join; the successor reading is a commitment.** `t_iz_complete` carries all four steps (Cauchy convergence, DA-2 bottom-role recognition, the Lean counterpart of DA-1's Path 1 in a KleeneStructure (`da1_computational`), T-SNAP) side by side. Note what the steps do and do not link: the convergence step is about `0 : Q₂`, while the bottom-role step is about a `terminal : L'` and takes the role property as a **hypothesis** (`h_role`), not as a result. The theorem does not identify those two objects. That the resulting bottom is a *new* one — the next instantiation — is the framework's reading: within one lattice `bot` is unique, and the 2-adic realization reapproaches the same 0 (`snap_arc_z2_loop`). | | Null balance | **Closed for the ROLE-RECOGNITION; occupancy takes a choice of join; the successor reading is a commitment.** Every branch starts at ⊥, ascends ω state changes (T3), and at the ordinal limit converges to 0 in Q₂. Reading that limit as an occupant of the bottom role takes a choice of join on Q₂ (then the role half is a theorem, `t_iz_limit_is_new_null`), and on that reading DA-2 identifies the occupant **with** ⊥, the same bottom of the same lattice (T-IZ + T-SNAP + DA-2). That the bottom reached is a **new** one is a commitment, not a theorem: `t_iz_limit_is_new_null` proves the role half only, and in the 2-adic realization the arc reapproaches the *same* 0 (`snap_arc_z2_loop`). Consistent with the T-IZ row above, which this row previously contradicted. | | ε₀ / proof-theoretic ordinal (type-level identity) | **Framework role closed; the type-level identity is ill-typed, not open.** ε₀ is chosen deliberately as PA's proof-theoretic ordinal — a cited classical fact ZP invokes, not a ZP proof obligation, and it takes more than one result: transfinite induction up to ε₀ suffices to prove PA consistent (Gentzen, Math. Annalen 112 (1936) 493-565, and a second proof reusing its transfinite-induction step, "Neue Fassung des Widerspruchsfreiheitsbeweises für die reine Zahlentheorie", Forschungen zur Logik und zur Grundlegung der exakten Wissenschaften, neue Folge, Heft 4 (1938) 19-44, translated in M. E. Szabo (ed.), The Collected Papers of Gerhard Gentzen (1969) 252-286); that induction is not itself provable in PA, which follows indirectly from Gödel's theorem together with the 1936 result and which Gentzen proved directly in Math. Annalen 119 (1943) 140-161; and transfinite induction up to any ordinal strictly below ε₀ is provable in PA, which Gentzen reports as already known, crediting Hilbert-Bernays (Gentzen 1943, p. 140 and its footnote 3; from this together with Gödel's theorem Gentzen argued, with hedges and for his own assignment of ordinals to derivations, that no single ordinal smaller than ε₀ bounds the ordinals of all his derivations: 1938, § 4.4, pp. 284-285 of the Szabo translation). What pins the value to exactly ε₀ is the last two of those together, and they run in opposite directions: PA proves transfinite induction at every ordinal strictly below ε₀, and does not prove it at ε₀ itself. Neither half alone locates the boundary. Its role as the exact snap threshold is machine-verified (`snap_exactly_at_epsilon_zero`, `snap_zp2_correspondence`), and the alignment with Gentzen is recorded as theorem-aligned in the Convergence section below (ZP-L Remark R-L.1). The type-level identity across types (MachinePhase vs Ordinal) is not an open piece: an identity between a MachinePhase state and an ordinal is not a well-formed statement, the same category error as an identity across Ordinal and ℤ₂, which fails to elaborate (`cnf_bridge_type_boundary` in `ZeroParadox/Ordinal/CnfBridge.lean` co-witnesses ε₀'s least-fixed-point face with the images' limit 0 in ℤ_[2] instead; its statement line is in `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § V), and the formal link runs through maps (the threshold map `α ↦ if α < ε₀ then c₀ else c₁`, the witness of `c1_epsilon_zero_identification`, order-non-decreasing by `snap_map_mono`; `snapEmbed`). |
--- ## Convergence With Established Work The Zero Paradox rests on a choice-free, machine-checked core, and much of what is built on it is now proved rather than inferred - the cross-domain *correspondence*, for one, is Lean-realized (`mc1_correspondence`). What remains inferential is bounded: the metatheoretic commitments (Tier 4). The numerical *identity* that would make the faces one object is retired as ill-typed - MC-1 names the resulting family (membership proved; the identity retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence); what separates the members is proved property by property (`seam_unique_among_named` (`ZeroParadox/Category/SeamUniqueness.lean`), for the named bottoms, in a lattice with no top)), not an inferential residue. The strongest non-proof support for that remaining part is that **independent traditions - set theory, number theory, proof theory, computability, category theory - each arrive near the same structure at zero.** This section maps that convergence honestly. Three things to read it correctly: 1. **This is convergence evidence, not proof.** It raises the prior that there is a real object at the floor; on its own it closes nothing. Each row's *link status* says exactly how tight the connection is. 2. **The direction of credit points outward.** In every row the established result is the prior work; ZP is an *instance joining* that program, never a frame that subsumes it. ZP does not claim the faces are literally one object - that reading is retired as ill-typed; it claims one family (MC-1), membership proved and what separates the members proved property by property (`seam_unique_among_named` (`ZeroParadox/Category/SeamUniqueness.lean`), for the named bottoms, in a lattice with no top), offered to these communities, not imposed on them. 3. **Not all of these are independent of each other.** Lawvere, the coalgebra line, and the categorical face are one tradition, not three; counted honestly, the genuinely separate roads are set theory, valuation / number theory, proof theory, computability, and category theory. **Named falsifier.** If a framework's bottom were shown *not* to carry the fixed-point / snap structure, or if a listed face turned out structurally dissimilar under scrutiny, the convergence weakens accordingly. **Prior-art search is ongoing.** This map is certainly incomplete. We treat finding additional prior work as a standing obligation, not a finished task - and corrections, especially "you have missed X," are welcome and will be added here with attribution. | Established result (prior work, cited) | ZP face | Link status | How ZP reached it | |---|---|---|---| | **Lawvere (1969)**, *Diagonal Arguments and Cartesian Closed Categories*; **Yanofsky (2003)** - the diagonal fixed point unifies Cantor, Russell, Gödel, Tarski, Turing, the recursion theorem | ⊥ as the self-referential (diagonal) fixed point - the keystone | **Conjectured unification; the faces formalized here are machine-checked** (ZP-R Diagonal Family Addendum), the self-application fixed point a role filled per face: the wall faces where self-reference cannot close, each the contrapositive of Lawvere's engine (`lawvere_fixedpoint`) - Cantor (`cantor_via_engine`), Russell (`russell_via_engine`), Turing (`no_self_decider`), Tarski (`tarski_no_internal_truth`), Curry (`curry_no_bottom`) - are axiom-free, as are the floor faces Löb / Gödel 2nd (`loeb`, `godel_two`); the fork / AFA face's fixed point is ⊥ of the ZPSemilattice by the class fields `fixed_bot` / `unique_fp` (`selfApp_pinnable`), not engine output; the computability floor face is a recursion-theorem instance, a Kleene code fixed up to eval (`computability_face_fixedPoint`, `computable_fixedpoint_up_to_eval`), whose reading as a Lawvere instance, in Rogers' general form over every computable self-map on codes, is cited, not checked in Lean; the narrower case of computable `eval`-respecting maps is checked in Lean (`hasWitnessRel_evalClass` with `fixedPoint_of_witnessRel`); Rice's face carries `Classical.choice` (`rice_face_has_bottom`). Gödel's first incompleteness, named in the unification, is not formalized here. No Set-level face carries a Lawvere witness, a point-surjection onto a function space (Cantor obstruction - `no_witness_of_nontrivial`, `reflexive_object_refuted`); run in the other direction, the wall faces are instances of the engine by its contrapositive; the one-object unification is retired as ill-typed (MC-1 names the resulting family) | Connected retrospectively - the keystone framing predated the citation | | **Taylor** *Well-founded coalgebras and recursion* (well-founded ⇒ recursive, Thm 36 p. 15; the converse **in a topos**, Prop 111 p. 6); **Adámek-Milius-Moss (2020)** (arXiv:1910.09401v2) - forward at Thm 7.2 p. 27; converse under further hypotheses, the endofunctor preserving inverse images plus one of several routes (Thm 8.1 / Thm 8.6 / Thm 8.12 - not two, and the smooth-mono and subobject-classifier conditions are the CATEGORY's, not the functor's); equivalence at Cor 8.2 under Thm 8.1's assumptions; the μ/ν divide | The snap as the well-foundedness boundary crossing: ⊥ the non-well-founded floor (self-loop), the ε₀ ascent well-founded (Boundary, BoundaryBridge) | **Best-effort formalized + cited for depth** - relation-level boundary + QPF μ/ν bridge proved (`snap_crossing`, `snap_boundary_two_registers`); the depth result cited, not re-proved — forward is AMM Thm 7.2 / Taylor Thm 36, and the ⟺ is AMM Cor 8.2 under Thm 8.1's assumptions, NOT Prop 111 (which is the ⇐ half alone, in a topos) (full coalgebraic version awaits Mathlib tooling - Tier 6) | Connected via the back-edge insight - the keystone's structural home (ZP-P already adjacent via Adámek-Rutten) | | **Forti-Honsell (1983)** axiom X₁ - the axiom itself; **Aczel (1988)** *Non-Well-Founded Sets* - named it AFA, gave the decoration form (ch. 1, p. 6: "Every graph has a unique decoration") and the Special Final Coalgebra Theorem (ch. 7); **Rutten-Turi (1993)** §3.2 - the coalgebraic characterization; **Barwise-Moss (1991)**; **Paulson** | the Quine atom (CC-2), a set x={x}; the ZFC/AFA contact point | **Theorem-grounded + commitment**: that every Quine atom (`IsQuineAtom`) of a `ZPSemilattice` with an `AFAStructure` is ⊥ (`t_exec`) is axiom-free Lean; no identity of ⊥ with a set is stated (it would be ill-typed), and the role's occupancy is proved chart by chart (`selfApp_quine_role_iff`, `quineAtomHost_quine_role_iff`, `zfset_quine_role_unoccupied`). **The commitment is sharper than "we adopt AFA" (verified against source, July 2026):** Rutten-Turi p. 497 record that a function α with (V, α) a final P-coalgebra can be shown to exist, and that what cannot be proved (their statement; cited, not claimed) is "that the identity function is one such α which makes V final, which is in fact the content of the anti-foundation axiom as formulated above" (the existence direction goes through the Final Coalgebra Theorem of Aczel-Mendler 1989, cited here via Rutten-Turi Thm 3.9, p. 497, which states it for set-based functors on Class; AM89 itself not retrieved). So the modelling content is **that the structure map is the identity**, not merely that a final coalgebra exists. *Open, and not claimed here:* Aczel p. 86 states "any final coalgebra for pow is a model of the anti-foundation axiom", and reconciling that with the existence direction (plausibly via Lambek - the structure map of a final coalgebra is an isomorphism, so it models AFA internally while the ambient theory keeps Foundation) has **not** been verified against Aczel's theorem 3.8. The identity-as-structure-map reading does not depend on that reconciliation; the flat claim "a final coalgebra exists without AFA" does, so it is not asserted. Aczel himself credits the axiom to Forti-Honsell. Two ZP observations are prior art, cited not claimed: the collapse of the nested-singleton tower to a point is **Barwise-Moss (1991), p. 37** ("any apg in which every node has a child is a picture of Ω"), and the identity-vs-structure-map distinction is Rutten-Turi's. Class-sized: the functor is powerset on **Class**; on Set there is no final coalgebra (Cantor/Lambek) | Independent → later converged (the ⊥ question reached x={x}; matched to AFA after; the identity-as-structure-map reading reached independently in July 2026 and found to be published) | | **Ostrowski's theorem** - every nontrivial absolute value on ℚ is the real or a p-adic one (the complete dichotomy) | ZP-B / ZP-F: the snap fails in ℝ, holds in ℚ₂; v₂(0)=∞ | **Theorem used** - Ostrowski is a classification theorem ZP directly invokes (Mathlib) | Independent → later converged (Riemann-sphere 0/∞ intuition → ℚ₂; Ostrowski recognized as the backing after) | | **ε₀ as the proof-theoretic ordinal of PA**: unprovability of transfinite induction up to ε₀ (**Gentzen (1943)**, the direct proof); provability below ε₀, which Gentzen reports as already known, crediting Hilbert-Bernays (Gentzen 1943, p. 140 and its footnote 3) | ZP-L / ZP-M: ε₀ as the exact snap threshold | **Theorem-aligned** - structural alignment documented (ZP-L Remark R-L.1); the type-level identity is ill-typed, not open (see the ε₀ row under Resolved questions) | Built on the cited work - ε₀ chosen deliberately as PA's ordinal | | **Kleene's recursion theorem** (program fixed points, up to evaluation) | ZP-K: the Kleene quine, a code fixed by self-application up to evaluation (`IsComputationalQuine`); the periodicity fixed-point construction | **Theorem + external novelty signal** - the quine face is standard; the periodicity construction was flagged novel by a computability specialist | Built on the cited work; the periodicity construction is the new piece | | **Lambek (1968)**; **Rutten (2000)** (*Universal Coalgebra*, §14); **Adámek-Milius-Moss** (*The Theory of Fixed Points of Functors*) - the initial-algebra / final-coalgebra (μ/ν) theory; **Ahrens-Capriotti-Spadotti (2015)** - the polynomial case is constructible choice-free; **Veltri (2021)** - the CONTRAST case, the non-polynomial finite powerset, where choice principles are ASSUMED per PRESENTATION (full AC for the set-quotient; countable choice + LLPO for Worrell's limit) - not by the functor: his own preferred coinductive construction needs neither | ZP-P: the lfp/gfp fork spine (`fork_collapse_iff`); the strict instance (`categorical_fork_strict`) | **Theorem + cited boundary** - the fork spine `fork_collapse_iff` is choice-free Lean `[propext, Quot.sound]`; the strict μ-empty/ν-inhabited instance carries `Classical.choice` on the coalgebra side, inherited from Mathlib. **Measured 2026-08-03:** that choice sits in `QPF.Cofix` **itself**, so it is not removable by any proof of a `Cofix`-mentioning statement; it is nevertheless a **quotient-layer artifact**, because `PFunctor.M`'s former and constructors are axiom-free (its DESTRUCTOR is not) and `strict_cofix_nonempty` proves the same ν-inhabitation over that M-type with no axioms at all. Ahrens-Capriotti-Spadotti agree from the other side (a polynomial final coalgebra is constructible choice-free as an ω-limit, no quotient layer). Escaping the footprint means changing the carrier, not cleaning the proof | Built on the cited work - the fork is the categorical parent; both choice-boundary sources connected retrospectively | | **Carboni-Lack-Walters (1993)** strict initial objects; **Fritz (2020)** Markov categories (Kleisli of the Giry monad) | ZP-G / ZP-H: ⊥ characterized per domain category, differently in each - in KleisliCat PMF an initial object that no later stage maps back into (`fC_no_return`, scoped to the functor's image); in ModuleCat ℂ a zero object (`Statement:` COINCIDENCE - initial and terminal at once, `hilbert_bottom_isZero`), so every stage maps back into it (`fD_has_return`) and it is not a strict initial object (the `example` after `hilbert_bottom_isZero` in `ZeroParadox/Category/TreeSeam.lean`); in TopCat terminal, since it has one point (`padic_bottom_isTerminal`), and not initial (`padic_bottom_not_initial`), and separately the inverse limit of the ball tower (`floorConeIsLimit`); strict initiality is AX-G2 at an initial object (`ax_g2_from_strict_initial`, and its converse `example` in `ZeroParadox/Category/AxG2Reduce.lean`); `mc1_correspondence` | **Theorem-grounded + commitment** - each domain floor is characterized in its own real Mathlib category, at a different position in each: a zero object in ModuleCat ℂ, initial and not terminal in KleisliCat PMF, terminal and not initial in TopCat, where it is separately the limit of the ball tower (the three full positions are stated together in `floor_positions_full`: a zero object; initial and not terminal; terminal and not initial; the limit `floorConeIsLimit`); the cross-category "one object" identity is retired as ill-typed - MC-1 is the bottom family, membership proved | Built on the cited work - standard categorical structure, assembled across the ZP domains | | **Grothendieck fibrations / indexed categories** (Grothendieck, SGA 1; Vistoli's notes); **descent & stacks**; **Giraud (1971) gerbes** - a coherent global object over a base exists iff a descent / (gerbe-)triviality obstruction vanishes; the **field-of-moduli vs field-of-definition** instance (Dèbes-Douai) | the retired one-object identity - an earlier attempt to recast "are the bottoms one object?" in descent terms | **Superseded frame (the identity it addressed is retired).** The categorical machinery for "do per-fibre objects glue into one global object, and what obstructs it" is standard and old; it gave the now-retired one-object question a named form - a descent / (gerbe-)triviality question - in place of a bare one-or-many. **Honest delta:** classical descent is formulated over a *single base site*, whereas ZP's domains are categories with no canonical common index, so this was an analogy / proposed frame, **not** an instance of the theorem; and with the identity now retired as ill-typed, the frame is superseded - recorded here as the earlier attempt, not a live commitment | Connected retrospectively - a recasting of the identity, now superseded by retiring it as ill-typed | | **Kozyrev (2002)** p-adic wavelet basis of L²(ℚ_p), one orthonormal basis of functions supported on p-adic balls, the analog of the Haar basis; contrast the **van der Put basis** (indicator functions of p-adic balls, in which every continuous ℚ_p-valued function on ℤ_p has a series expansion; orthonormal in the non-Archimedean sense, as a basis of the Banach space of continuous functions ℤ_p → ℚ_p under the supremum norm (Schikhof, *Ultrametric Calculus* (1984), Thm 62.2, p. 190; see Bolivar-Barbosa, León-Cardenal and Rodríguez-Vega (2022), Thm 2.1); its balls nest, so it is not an orthonormal system in L²) | ZP-D: `T : Q₂ → H` assigns the cells of the level-k partition of Q₂ (the 2^k balls of ℤ₂ and the one cell Q₂ \ ℤ₂) to orthonormal vectors (clopen separation ↦ orthogonality, DP-1) | **Standard construction, applied** - in L² of the Haar measure, two disjoint balls of one level have orthogonal indicators of equal length (the disjoint-ball `example` in `ZeroParadox/Valuation/PadicVladimirov.lean` § VIII, at any level n and any centre outside the level-n ball around 0), while two consecutive nested balls around 0 have non-orthogonal indicators (the control `example` after `inner_shellIndicatorL2_ballIndicatorL2`); `T` follows that pattern on the balls of ℤ₂, and Kozyrev's wavelets are one orthonormal basis built on p-adic balls; ZP-D's own contribution is the snap-into-state-layer reading (DP-1), not the embedding | Connected retrospectively - `T` was built in-house, recognized as the standard construction afterward | | **Carlström** - wheels (consistent division by zero) | ZP-J: the wheel of fractions (`WheelFrac`) | **Theorem** - faithful to Carlström's Def 1.1, choice-free; under specialist review | Built on the cited work - developed with Carlström in hand | | **Chaitin** - algorithmic information theory / incompressibility | ZP-C: unbounded surprisal at ⊥ (both charts in the ZP-C Information Theory row below) / no external description | **Analogy / referenced** - lighter; Yanofsky also notes AIT fits the scheme | Parallel - not a load-bearing identity | | **Escardó** - `not-finite-is-∞'` (TypeTopology, `GenericConvergentSequence`); ℕ∞ as the final coalgebra of `𝟙 + (−)` | `notEL_unique` (`ZeroParadox/Computability/GroundZero.lean`): the behaviour that never reaches a leaf is uniquely `natInfinity` | **Prior - and purer.** Escardó proves it `--safe --without-K` from function extensionality alone; ours carries `Classical.choice` via Mathlib's QPF quotient | Identical result. Live purity lead: their route is choice-free | | **Rutten (2000)**, *Universal Coalgebra*, TCS 249 - p. 16 ("∞ only takes a step to itself and hence never terminates"); Ex. 10.2(4) p. 44; §12 pp. 51-52 | same - the classical home, and the same bisimulation on the same carrier | **Prior** - cited, not claimed | Jacobs Ex. 2.4.1 p. 66 supports the OBJECT (ℕ ∪ {∞} as final coalgebra), not the uniqueness lemma | | **Mathlib `CovBy`** (Mathlib: `Order/Defs/PartialOrder.lean` for `a ⋖ b`; `Order/Cover.lean` for `CovBy.unique_right`, `not_covBy`, `denselyOrdered_iff_forall_not_covBy`) | AX-B1 / `HasFirstStep` (`ZeroParadox/Reals/OrderedField.lean`): a first step above the bottom | **Duplicate - now adopted.** AX-B1 at a state a with anything above it is HasFirstStep a, that is ∃ b, a ⋖ b; a cover of a is an atom of the up-set Ici a (covBy_iff_atom_Ici); a `[ZP-CUSTOM]` entry claiming no Mathlib analog was FALSE and has been removed | Mathlib's biconditional (dense ⟺ nothing covers anything) is **stronger** than the framework's own claim | | **Winskel (1987)**, *Event structures*, Advances in Petri Nets 1986 Part II, LNCS 255, pp. 325-392 - the covering relation as one event's occurrence in a domain of configurations (p. 336, credited there to its references [NPW] and [W]); two events enabled at ∅ are concurrency, a "little square", when consistent (Example 1.1.6 p. 328) and conflict, "branching", when not (Example 1.1.5 p. 327); each strict inclusion of configurations passes through a cover (Lemma 1.1.11 p. 329) | `t_snap_given_cover` (`ZeroParadox/Order/Snap.lean`): the first step as a cover of the least state (`hcov`); the `Set Bool` control in `ZeroParadox/Order/SnapCannotBe.lean`, where ∅ has two covers with a join, Example 1.1.6's shape; the `IsLUB` example beside it gives every pair of states a join, so Example 1.1.5's conflict does not arise in the class | **Prior** - cited, not claimed. **Honest delta:** in a configuration domain a cover is exactly a one-event extension (p. 336), and Lemma 1.1.11 supplies one inside every strict inclusion. In ZP that analogue depends on the carrier (on ℕ each x < y passes through x ⋖ x + 1; on a densely ordered carrier such as ℚ≥0 under `max` nothing covers 0, `axb1_fails_everywhere_iff_dense` in `ZeroParadox/Reals/OrderedField.lean`), and where it holds it gives a cover below the step, not that the step is one (the ℕ run 0, 2), so ZP takes the cover as a hypothesis | Connected retrospectively - the step-as-cover reading was built in-house and Winskel's covering relation located after | | **Baier & Katoen (2008)**, *Principles of Model Checking* - trap state + totalization p. 157; absorbing state Notation 10.6 p. 753 | `LoopsInPlace` / `loop_is_a_trap`; `flipPoles` dead→live half (`ZeroParadox/Computability/Occurrence.lean`) | **Prior / standard** - the objects already have names | The `flipPoles` involution as such: searched, none found | | **Baeten & Weijland (1990)**, *Process Algebra* - ACP's deadlock (δ) vs successful termination (ε) | `TriStep` (`ZeroParadox/Computability/GroundZero.lean` § IV), the three-valued counter-model | **Prior / standard** - process algebra calls the third value *deadlock*; the framework read it as *unstarted* | Same object, opposite valence. Standard term should lead | | **Buckingham (1914)** π-theorem; **Hardtke**, arXiv:1912.08744 Thm 3.2 p. 10; **Castro & de Boer (2020)**, *PLoS Comput Biol* 16(11):e1008248 pp. 3-4 | ZP-B's real-valued threshold `2^(−v)` (`eps0 (-v)`, contingent through the chosen rung `v`) + BA-1 (temperature): only the ratio is physical | **Prior / standard.** The π-group count is literally `k = 3 − 2 = 1`; the scale-invariance argument is a published method. Standard term: ε₀'s magnitude is **structurally unidentifiable** | Reframing, not a result: "what is ε₀ in energy units?" is a category error, not an open problem. **Scope corrected 2026-07-30 (ZP-B v1.14):** the dimensional-analysis reading applies to ZP-B's real-valued threshold `2^(−v)` (`eps0 (-v)`), whose contingency is the CHOSEN finest accessible rung `v` — a normalisation. It does NOT apply to ε₀ of ℚ₂ itself, a point named only by its rung `v` (ZP-B D5), which carries no unit, exactly as ℚ₂'s 0 carries none. ZP-B v1.12's "restates the contingency as dimensional" was retracted at v1.14; do not read this row as making ε₀ dimensionful | | **Krapivsky, Redner & Ben-Naim (2010)**, *A Kinetic View of Statistical Physics* §7.2 p. 123 (both temperature limits; critical slowing down), p. 121; **Hajek (1988)**, *Math. Oper. Res.* 13(2) abstract | private physics branch: Glauber at the one-bit scale | **Prior - one textbook sentence.** "Determinism is the obstruction, temperature removes it" is the founding premise of the simulated-annealing literature | Branch-local, never published. Recorded so it is not re-derived | | **Levin, Peres & Wilmer**, *Markov Chains and Mixing Times* - Remark 1.2 p. 4 (two-state eigenvalue `1 − 2p`); Ex. 12.8(b) p. 178 (Glauber eigenvalues non-negative); Ex. 12.1(b) p. 177 (aperiodicity ⟺ no eigenvalue at −1) | `Order/MarkovContractionDual.lean`, `Valuation/NuRateMatch.lean` (both already carry `1 − 2a`) | **Prior** - and LPW's Glauber statement is strictly stronger (no temperature hypothesis) | Already cited in the corpus; noted here because it was re-derived anyway | --- ## Verification by Document (Lean 4) Machine-checked proofs of the formal documents using Lean 4 + Mathlib. Source lives under [`ZeroParadox/`](ZeroParadox/); the full theorem-by-theorem detail is in each source file. The reproducibility commands are in the [README](README.md#reproducing-the-verification). | Document | Lean Source | Verifies | Build | |----------|-------------|----------|-------| | ZP-A Lattice Algebra | [Lattice.lean](ZeroParadox/Order/Lattice.lean) | Partial order, ⊥ as the minimum, monotonicity of state change | Clean - April 2026 | | ZP-B p-Adic Topology | [Padic.lean](ZeroParadox/Valuation/Padic.lean) | p = 2 forced; Q₂ ultrametric, clopen balls, total disconnectedness, snap irreversibility | Clean - April 2026 | | ZP-C Information Theory | [Surprisal.lean](ZeroParadox/Information/Surprisal.lean) | Distinct state distributions, 1-bit divergence, execution as a state change off ⊥ of `MachinePhase`, unbounded surprisal at ⊥, in two charts with no identity between them: the depth chart, finite at every depth and unbounded across depths (l_inf: for every bound M some natural number n has surprisal n > M; reading n as a 2-adic ball depth is a design identification, stated at surprisal_eq_binary_info), and the point chart, complexity ⊤ at the floor 0 of Q₂ (infinitude_forces_infinite_complexity at q2InfinitudeFloor, [InfinitudeFloor.lean](ZeroParadox/Valuation/InfinitudeFloor.lean)), to which ⊥ of `MachinePhase` corresponds as a reading, beside the second reading of ⊥ in the information setting, the zero-information point mass (README, Information row; on a type with at most one outcome every distribution is the point mass, pmf_subsingleton_isPure) | Clean - April 2026 | | ZP-D State Layer | [StateSpace.lean](ZeroParadox/State/StateSpace.lean) | Transition operator into Hilbert space: existence, uniqueness up to unitary, orthogonality under the snap | Clean - April 2026 | | ZP-E Bridge Document | [Snap.lean](ZeroParadox/Order/Snap.lean) | The snap as a derived theorem (T-SNAP); instantiation succession; axiom-free minimal path | Clean - April 2026 | | ZP-F The Counterexamples | [OrderedField.lean](ZeroParadox/Reals/OrderedField.lean) | The snap cannot occur in any ordered field (ℝ, ℚ as instances) | Clean - May 2026 | | ZP-G Category Theory | [Category.lean](ZeroParadox/Category/Category.lean) | Initial object and its universal property; forward-only structure; the informational singularity | Clean - April 2026 | | ZP-H Categorical Bridge | [CategoricalBridge.lean](ZeroParadox/Multihomed/CategoricalBridge.lean) | The snap under all four domain functors; singularity reconciliation | Clean - April 2026 | | ZP-H Native Categories | [TopFunctor.lean](ZeroParadox/Valuation/TopFunctor.lean), [HilbFunctor.lean](ZeroParadox/State/HilbFunctor.lean), [InfoFunctor.lean](ZeroParadox/Multihomed/InfoFunctor.lean), [MC1Bridge.lean](ZeroParadox/Multihomed/MC1Bridge.lean) | The snap floor realized in real Mathlib categories: in TopCat the floor is terminal since it has one point (padic_bottom_isTerminal), not initial, and separately the inverse limit of the ball tower (floorConeIsLimit); zero object (initial and terminal) in ModuleCat ℂ; initial and not terminal in KleisliCat PMF; the three full positions stated together in floor_positions_full (a zero object; initial and not terminal; terminal and not initial); mc1_correspondence bundle | Clean - June 2026 | | ZP-I Inside Zero | [SemilatticeInstance.lean](ZeroParadox/Valuation/SemilatticeInstance.lean) | A sequence S in Q₂ with ‖Sₙ‖ ≤ (1/2)ⁿ for every n converges to 0 in Q₂ (t_iz_cauchy); that bound follows from a strict state sequence of depths given that S is nowhere zero and the IsDepthChain bridge, a modelling commitment that binds no ZPSemilattice (t_iz_h_bound_from_depth_chain); reading that limit as an *occupant* of the ⊥ role takes a choice of join on Q₂ (then the role half is a theorem, t_iz_limit_is_new_null), and reading the occupant as a *successor* ⊥ is a commitment (C-DA2) (Inside Zero) | Clean - April 2026 | | ZP-J Self-Reference (Core) | [SetTheoryAFA.lean](ZeroParadox/Settheory/SetTheoryAFA.lean) | The Quine atom is ⊥ (executable self-reference); CC-1 restated as an equivalence (cc1_derived, t_exec_iff), not forced | Clean - April 2026 | | ZP-J AFA Derivation Chain | [AczelConn.lean](ZeroParadox/Settheory/AczelConn.lean), [SelfApp.lean](ZeroParadox/Computability/SelfApp.lean), [Scale.lean](ZeroParadox/Valuation/Scale.lean), [OntBridge.lean](ZeroParadox/Settheory/OntBridge.lean), [Model.lean](ZeroParadox/Settheory/Model.lean), [ScaleBridge.lean](ZeroParadox/Valuation/ScaleBridge.lean) | ValuationStructure → AbstractSelfApp → AFAStructure (each arrow yields the next; the first is strict, since a ValuationStructure on a carrier with a point other than ⊥ forces that carrier to be infinite (`valuationStructure_forces_infinite`), while every ZPSemilattice carries the other two); the self-containing set identified as {⊥}, choice-free at the AFAStructure and AbstractSelfApp levels (restated under ValuationStructure it carries Classical.choice), which does not address Aczel's Dependent Choice question; ValBridge common ancestor unifying the lattice track and ℤ₂; concrete ℤ₂ and ℕ∞ instances | Clean - June 2026 | | ZP-J Host-Theory Requirements | [QuineHost.lean](ZeroParadox/Settheory/QuineHost.lean) | The AFA-*fragment* the framework needs, as a citable typeclass (`QuineAtomHost`): (Y') a host bottom b = {b} + (Z') uniqueness among reflexive elements; (X) Foundation-freeness *forced* (`quineAtomHost_not_wellFounded`); Foundation fails (Y') (`zfSet_no_singleton_bottom`) and a Boffa-shaped toy fails (Z') (`boffa_fails_reflexive_unique`); AFA's pattern meets both in a finite toy. `QuineHost` (a self-membered bottom + uniqueness among self-members) is incomparable with it, and AFA's membership fails it | Clean - July 2026 | | ZP-J APG Decoration Uniqueness and Existence | [APG.lean](ZeroParadox/Settheory/APG.lean) | Decoration uniqueness for finite accessible pointed graphs, by induction on reachable size, and for every quiver, by induction on valuation; decoration existence for every quiver (`existsUnique_decoration`) | Clean - May 2026 | | ZP-J Wheel of Fractions | [Wheel.lean](ZeroParadox/Algebra/Wheel.lean), [WheelFrac.lean](ZeroParadox/Algebra/WheelFrac.lean) | The wheel of fractions is a wheel (Carlström Def 1.1), choice-free; ∞ ≠ ⊥ | Clean - June 2026 | | ZP-K Computational Grounding | [Kleene.lean](ZeroParadox/Computability/Kleene.lean) | DA-1 is closed given DP-2 (`da1_minimal_path`); ZP-K witnesses its Path 1 (`da1_closed_concrete`: ⊥ is the unique Quine atom of MachinePhase) | Clean - April 2026 | | ZP-L Incomputability Convergence | [Gentzen.lean](ZeroParadox/Ordinal/Gentzen.lean) | ε₀ as the exact snap threshold; the ordinal tower converges 2-adically to 0 | Clean - May 2026 | | ZP-M Kleene-Ordinal Bridge | [Incompleteness.lean](ZeroParadox/Ordinal/Incompleteness.lean) | Type bridge MachinePhase → ℤ₂; Kleene quine and ε₀ fixed point co-witnessed | Clean - May 2026 | | ZP-P The Fixed-Point Fork | [FixedPointFork.lean](ZeroParadox/Settheory/FixedPointFork.lean), [Ostrowski.lean](ZeroParadox/Valuation/Ostrowski.lean), [Coalgebra.lean](ZeroParadox/Settheory/Coalgebra.lean) | The least/greatest fixed-point fork collapses iff the operator has a unique fixed point (choice-free); number-system instance ℝ vs ℚ₂ via Ostrowski; categorical-parent instance (Fix empty / Cofix inhabited) via QPF | Clean - June 2026 | | Keystone probes (Lawvere / boundary) | [Lawvere.lean](ZeroParadox/Category/Lawvere.lean), [Boundary.lean](ZeroParadox/Multihomed/Boundary.lean), [BoundaryBridge.lean](ZeroParadox/Multihomed/BoundaryBridge.lean) | Face-relative Lawvere verdict (no Set-level face an instance, computability face genuine; its Lawvere form is cited, Bauer 2017, in multi-valued form, not claimed); the snap as a well-foundedness boundary crossing (relation level + QPF μ/ν bridge); best-effort, full Taylor coalgebraic version open (Tier 6) | Clean - June 2026 | | ZP-R Cross-Category Fixed Point | [RequirementsGap.lean](ZeroParadox/Settheory/RequirementsGap.lean), [MetaFork.lean](ZeroParadox/Settheory/MetaFork.lean), [LawvereBridge.lean](ZeroParadox/Settheory/LawvereBridge.lean), [ComputableCrossing.lean](ZeroParadox/Computability/ComputableCrossing.lean) | The self-application fixed point is a role filled per face; ZP-R locates where it is filled by a Lawvere fixed point across three faces: refuted in Set on every carrier except a one-element one (Cantor - `reflexive_object_refuted`), free of a monotone obstruction on complete lattices (Knaster–Tarski) with no reflexive object built here and no map from the two-element chain onto its monotone self-maps (the last example of `LawvereBridge.lean` § VII; the first finite stage of Soto-Andrade & Varela's two-element example, 1984, § 2.5, pp. 15–16; the case Y = 2 of Trimble's Cantor theorem for posets; Bergman, arXiv:0801.0751, Cor. 7 (Cor. 3.2 in the journal); all three stated there for order-preserving maps, while the Lean example allows any map, by counting two points against three monotone self-maps), and genuinely realized in the computability face (`eval_point_surjective`, `selfref_fixedpoint_exists_computable` - the crossing; that Rogers' general form is a Lawvere instance is cited; the narrower case of computable `eval`-respecting maps is checked in Lean, `hasWitnessRel_evalClass` with `fixedPoint_of_witnessRel`). What is measured is stated per face (F1): in the fork / AFA face ⊥ of the ZPSemilattice is the unique fixed point of `selfApp` by the class fields `fixed_bot` / `unique_fp` (`selfApp_pinnable`), a commitment of the class, not output of Lawvere's engine; in the computability face the occupant is a Kleene code, with fixed points up to eval (Rogers' form, `computable_fixedpoint_up_to_eval`), infinitely many for each partial computable F (`fixed_points_infinite`); how the faces formalized here relate to Lawvere's theorem is collected in ZP-R Section III, in the box "Lawvere's theorem, face by face", and ZP-R conjectures nothing global; no occupant is identified with another (a one-object reading is ill-typed, MC-1) | Clean - July 2026 | | ZP-R Diagonal Family Addendum | [Wall.lean](ZeroParadox/Settheory/Wall.lean), [Tarski.lean](ZeroParadox/Settheory/Tarski.lean), [Curry.lean](ZeroParadox/Settheory/Curry.lean), [Loeb.lean](ZeroParadox/Settheory/Loeb.lean), [Rice.lean](ZeroParadox/Computability/Rice.lean) | The faces formalized here of the self-referential relationship, by the μ/ν fork; the self-application fixed point is a role filled per face. Wall faces where self-reference cannot close, each the contrapositive of Lawvere's engine (`lawvere_fixedpoint`, `negation_no_fixedpoint`, axiom-free) - Cantor (`cantor_via_engine`), Russell (`russell_via_engine`), Turing (`no_self_decider`), Tarski (`tarski_no_internal_truth`), Curry (`curry_no_bottom`) - all axiom-free; floor faces where it does, each fixed point supplied per face rather than by the engine - Quine atom (`t_exec`; ⊥ of the ZPSemilattice by the class fields `fixed_bot` / `unique_fp`, `selfApp_pinnable`), Löb / Gödel 2nd (`loeb`, `godel_two`, axiom-free, from a hypothesized Löb diagonal), Rice (`rice_face_has_bottom`, `Classical.choice`); the Kleene face is carried as a requirement, its witness `computability_face_fixedPoint` (Rogers' fixed-point theorem for a total computable transformation, Mathlib `fixed_point`; inter-derivable with Kleene's second recursion theorem, `fixed_point₂`) a Kleene code fixed up to eval (`computable_fixedpoint_up_to_eval`; infinitely many for each partial computable F, `fixed_points_infinite`), a term of another type than ⊥ of the ZPSemilattice; that Rogers' general form is a Lawvere instance is cited, not checked in Lean; the narrower case of computable `eval`-respecting maps is checked in Lean (`hasWitnessRel_evalClass` with `fixedPoint_of_witnessRel`). Gödel's first incompleteness sits between the columns and is not formalized here. Supersedes the private "Zero as a Wall" draft; unification credited to Lawvere (1969) / Yanofsky (2003) | Clean - July 2026 |
Per-file axiom footprint - click to expand All proofs are machine-checked. The classical axioms that appear (`Classical.choice`) come mostly from Mathlib's computability, analysis, and ordinal libraries, where they are infrastructure dependencies rather than Zero Paradox commitments. **Some are the framework's own** — the bare `classical` in `ZeroParadox/Category/Lawvere.lean`, one in `ZeroParadox/Category/ExcludedMiddleBridge.lean` whose own docstring calls it *classical by construction*, and those in `ZeroParadox/Die.lean` (`botCovered_botIntervalTwo_classical`, `Motion.registeredDecidable_of_classical`, `Motion.selectedTotal_of_classical`, the last also calling `Classical.choose` directly) — and **the principles that the cases of `ZeroParadox/Category/ChoiceCannotBe.lean` § IV reduce to taboos are essential given the premise stated there** (the reductions: `wem_of_fixedPointFree`, `em_of_wellOrder_comparable`, `wem_of_botCovered_botIntervalTwo`, `Motion.em_of_registeredDecidable`, `Motion.em_of_selectedData`), so neither "inherited" nor "infrastructure" should be read as "removable". `Classical.choice` in Lean is a choice operator on types, not the set-theoretic Axiom of Choice as stated in ZFC, and it yields that axiom's type-theoretic form (`Classical.axiomOfChoice`, below). ZP-H, ZP-I, ZP-J (extension files), ZP-K, ZP-L, and ZP-M use `Classical.choice` via Mathlib computability, analysis, and ordinal infrastructure (Kleene's theorem, Rogers' fixed-point theorem, metric space completion, ordinal arithmetic, and p-adic valuation). `Classical.choice` is the Lean axiom that grounds classical excluded middle (`Classical.em`), and it does supply non-constructive selection over arbitrary families: Lean core derives a choice function for any family of nonempty types from it alone (`Classical.axiomOfChoice`, whose `#print axioms` is `[Classical.choice]`, measured 2026-10-08). The `#print axioms` check reports `[propext, Classical.choice, Quot.sound]` on many declarations in ZP-I, ZP-K, ZP-L, ZP-M, and the ZP-J extension files (Scale, Model, APG), and not on all of them: in ZP-K, `encodeCode_self` and `IsKleeneFixedPoint` report no axioms, and so do Mathlib's `Nat.Partrec.Code` and `Nat.Partrec.Code.eval` (`#print axioms` in the PurityCheck section of `ZeroParadox/Computability/Kleene.lean`). At the Mathlib version this repository pins, as of 2026-10-09, ZP-K statements reach `Classical.choice` by more than one route, among them the global instance `Nat.Partrec.Code.instDenumerable` and `Primcodable.prod`; `ZeroParadox/Computability/Kleene.md` § VIII records routes into the statements of Mathlib's two recursion theorems, `Nat.Partrec.Code.fixed_point₂` and `Nat.Partrec.Code.fixed_point`. ZP-H, ZP-L and ZP-M also carry `Classical.choice` in statements about Mathlib's `Code`: ZP-H in `quine_encodings_approach_bot`, ZP-L in Rogers' fixed-point theorem (`roger_fixed_point_stability`, Mathlib `Nat.Partrec.Code.fixed_point`), ZP-M in `both_fixed_points_exist`; the ZP-H statement also carries it through `ℝ`, which it quantifies over, among other routes (its ℤ_[2]-norm part is not separately recorded here), and the ZP-M statement through its ordinal conjunct (each measured on the statement and on each part alone, 2026-10-09; the theorems' own `#print axioms` lines are in `ZeroParadox/Multihomed/PadicBridge.lean`, `ZeroParadox/Ordinal/Gentzen.lean` and `ZeroParadox/Ordinal/Incompleteness.lean`). In the other files the classical axioms come with analysis machinery, ordinal fixed-point theory, and p-adic library infrastructure, not through the ZPSemilattice or AFAStructure fields. The ZP-J core file (SetTheoryAFA.lean) and AczelConn, OntBridge, and WheelFrac are `Classical.choice`-free. **SelfApp.lean is SPLIT, and the split is the core/realization boundary rather than a defect**: its abstract results are choice-free (`toAFAStructure`, `derived_bot_self_mem`, `derived_quine_unique` depend on no axioms at all; `selfMem_eq_singleton_bot` is `[propext, Quot.sound]`), while the concrete 2-adic realization carries `Classical.choice` — `q2_zero_is_fixed`, `q2_unique_fp` and `q2_selfMem_singleton` are each `[propext, Classical.choice, Quot.sound]`, inherited because Mathlib builds ℚ_[2] as a classical completion (`#print axioms` in the PurityCheck section of `ZeroParadox/Computability/SelfApp.lean`). ZP-P is mixed: the fork core (FixedPointFork.lean — `fork_collapse_iff`, `fix_isEmpty`) is choice-free `[propext, Quot.sound]`, while the Ostrowski number-system instance (Ostrowski.lean — `real_not_equiv_padic`, `completions_exhaustive`) and the greatest-fixed-point side of the coalgebra instance (Coalgebra.lean — `cofix_nonempty`) carry `Classical.choice`. ZP-A through ZP-G are `Classical.choice`-free except where standard Mathlib theorems require it. The keystone probe files are mixed: Lawvere's `fixedPoint_of_witness` / `no_witness_of_fixedPointFree` and Boundary's `floor_not_wellFounded` are **fully axiom-free** (`#print axioms` reports no dependencies at all); the remaining results (`computability_face_fixedPoint`, the ordinal-ascent and carrier theorems, and `snap_boundary_two_registers`) carry `Classical.choice` via Mathlib's ordinal, recursion-theorem, and QPF machinery. **The Lawvere face negatives are the exception and are listed separately in Tier 3**: their choice is the framework's own bare `classical`, not Mathlib's. The **ZP-R diagonal-family** files are mostly axiom-free: `Wall.lean` (the engine, Cantor, Russell, Turing, no-self-loop), `Tarski.lean`, `Curry.lean`, and `Loeb.lean` (Löb, Gödel 2nd) report **no axiom dependency at all** (the two `ZFSet` wall results, `no_quine_atom` / `no_membership_cycle`, use `[propext, Quot.sound]`); only `Rice.lean` (the exists-but-undecidable face) carries `Classical.choice` via Mathlib's recursion theory, as does the computability crossing in `ComputableCrossing.lean`.
--- *This ledger is maintained alongside `AxiomProfile.lean`, `fmc.md`, and `register.md`. On any change to a claim's status or axiom profile, update those sources first, then this view.*