diff --git a/.claude/commands/copy-editor.md b/.claude/commands/copy-editor.md index e4de9ab3..56f6e713 100644 --- a/.claude/commands/copy-editor.md +++ b/.claude/commands/copy-editor.md @@ -106,7 +106,7 @@ You are a **copy editor** — one of **three**, running in parallel, with identi > **The copy editor decides EXPRESSION. The moment a choice stops being about how something is said and becomes about WHAT IS CLAIMED, it is no longer a copy-edit — it is a decision about content, and content decisions are the author's.** -**Clarifying language passes. Genuine improvement passes. A change that moves the mathematics is DIVERGENCE** and routes to the author via the carrier (`D7`, `D4`), unless your probe shows it moved TO what the Lean or a recorded ruling says: that is CORRECTED (Stage 2c). +**Clarifying language passes. Genuine improvement passes. A change that moves the mathematics is DIVERGENCE** and routes to the author via the carrier (`D7`, `D4`), unless your probe shows it moved TO what the Lean or a recorded ruling says, or, for what a cited source says, a filed and indexed page image of it: that is CORRECTED (Stage 2c). ⚠⚠ **SELF-ASSESSMENT OF THAT LINE FAILED 3 OUT OF 3.** Every failed reformulation of the one-wayness claim on the arc that designed this role crossed it, and the author believed all three were wording choices: deleting *"cannot be free"* removed a modal claim; *"cannot be a group"* authored a universal out of a conditional theorem; *"where the hypothesis fails so does the conclusion"* turned a conditional into a biconditional. @@ -173,16 +173,17 @@ Enumerate every site editorial touched. **Report the count, always, including ze ⚠ **Ask what the `example` EXCLUDES.** A witness that elaborates for every type witnesses nothing — `Subsingleton (α ≃ PUnit)` is the recorded instance. Where the claim genuinely *is* a universal, a generic witness is the content rather than the defect. -⚠ **A footprint measurement does not settle a MODAL claim.** *"not a necessity"*, *"an artifact"*, *"could be removed"*, *"eliminable"* are claims about what no proof can establish. ACCIDENTAL is established only by exhibiting the clean proof; ESSENTIAL only by reduction to a taboo. **`#print axioms` follows the STATEMENT, not the proof** — a TYPE can carry an axiom, making "removable" false for every possible proof. **Measure the type.** A modal shift is divergence; it does not resolve unless your probe meets this standard, and only then is it CORRECTED (2c); a footprint alone never does. +⚠ **A footprint measurement does not settle a MODAL claim.** *"not a necessity"*, *"an artifact"*, *"could be removed"*, *"eliminable"* are claims about what no proof can establish. ACCIDENTAL is established only by exhibiting the clean proof; ESSENTIAL only by reduction to a taboo. **`#print axioms` follows the STATEMENT as well as the proof** — a TYPE can carry an axiom, making "removable" false for every possible proof. **Measure the type.** A modal shift is divergence; it does not resolve unless your probe meets this standard, and only then is it CORRECTED (2c); a footprint alone never does. **2b. Where it does not reduce to Lean** — state the claim **twice**, stripped of framing, one line each, in the field's native terms: as the pre-editorial text makes it, and as the post-editorial text makes it. **If those two lines differ in what they assert, the meaning moved** (toward the referent is CORRECTED, 2c). The deliverable is that the drift is VISIBLE. **Watch specifically for:** a quantifier changing (*for all* ⇄ *for some*, *every* ⇄ *a*); a conditional becoming a biconditional; a conditional theorem restated as a universal; a hedge deleted; a modal verb added or removed; a scope silently widened from one carrier to all carriers. -**2c. CORRECTED, the third outcome.** When the pre-text was FALSE, or claimed more than the Lean proves, and your probe settles the pair FOR the post-text, the pair is neither "same statement" nor divergence. Report it in this shape: *the pre-text asserted X; the Lean says Y (name the `example` that elaborated or the `#check` whose printed type is Y), or a recorded ruling says Y (cite it); the post-text says Y.* It covers a correction a previous review round or gate asked for, and any editorial correction toward the referent. Mark it WORDING with the measurement attached, tagged VERIFIED because the measurement is your own run; a RELAYED CORRECTED is MEANING. It does not by itself make your verdict DIVERGENT, and wherever this brief says a Stage 2 pair "differs", a CORRECTED pair does not. +**2c. CORRECTED, the third outcome.** When the pre-text was FALSE, or claimed more than the Lean proves, and your probe settles the pair FOR the post-text, the pair is neither "same statement" nor divergence. Report it in this shape: *the pre-text asserted X; the Lean says Y (name the `example` that elaborated or the `#check` whose printed type is Y), or a recorded ruling says Y (cite it), or, for a claim about what a source says, a filed page image of that source says Y (cite the image under `.claude-local/papers/_scans/` and its `INDEX.md` entry, and view it yourself); the post-text says Y.* It covers a correction a previous review round or gate asked for, and any editorial correction toward the referent. Mark it WORDING with the measurement attached, tagged VERIFIED because the measurement is your own run; a RELAYED CORRECTED is MEANING. It does not by itself make your verdict DIVERGENT, and wherever this brief says a Stage 2 pair "differs", a CORRECTED pair does not. - **The control is the DIRECTION of the probe.** It settles FOR the post-text: CORRECTED. It goes AGAINST the post-text, or settles nothing: MEANING. Unsure: MEANING. Recorded slices. Real MEANING: panel-2 reader `4064d4dfeeec` F1 ("no theorem here says so", underclaiming a proved role half); arc-2 reader `04866fcda7cf` F1 (the rungs sentence); the ℕ∞ round-1 `Part ℕ` CONTROL gloss on the `toPart_ofOption` example, `ZeroParadox/DieCannotBe.lean` § XXVII at tree 018a047f, "the round trip closes" where the example proved one leg. CORRECTED: panel-3 reader `4781140c9e59` F1–F2 (a header off a false witness, onto R-BEDROCK's ruling; a gloss narrowed from = to the proved ≤). - **A post-text STRONGER than a TRUE pre-text is not CORRECTED, even when proved:** the pre-text was not false, so the claim moved. MEANING (`4781140c9e59` F3, `fae8cc7629e3` F1). +- **Exception, an added chart (R-TWOPOLE):** a post-text that ADDS a chart to a TRUE pre-text counts as CORRECTED only when every added clause cites a proved declaration and nothing is flipped or removed (Tim, ruling 86, 2026-11-05). - ⛔ **A change of a CLAIM'S STATUS is not CORRECTED, even when the probe agrees, unless a ruling decided it (below):** `Statement:` ↔ `Reading:`, a chart claim ↔ a placement. That is a decision about content, so it is MEANING and routes to the author (arc-2 reader `3ed73350ae85` F1, ratified by Tim 2026-10-22; `fae8cc7629e3` F2 is the same site). A status already decided by a recorded ruling of Tim's is the author's decision: cite it and the pair is CORRECTED (`4781140c9e59` F1). --- diff --git a/.claude/commands/prior-art-review.md b/.claude/commands/prior-art-review.md index 8be38452..51a93eac 100644 --- a/.claude/commands/prior-art-review.md +++ b/.claude/commands/prior-art-review.md @@ -35,6 +35,12 @@ loop, so it enforces the cap. Paste this into the brief verbatim: This is distinct from the scout's *search* job: it still hunts for prior art we have NOT cited. This pre-flight covers the other half — prior art we HAVE cited and may be describing wrongly. +--- + +## CALLER PRE-FLIGHT — ask the ledger what is OWED before choosing the scope + +**Before choosing a target or scope, query what is owed (`R-LEDGER`).** The owed list is `mcp__verdictLedger__coverage_gap(step='prior_art', admission=[…])`, with the admission set taken from `mcp__gitRobot__admission`: it names every path in the step's scope that has no passing `prior_art` verdict over its current bytes. Measured 2026-10-31 at `ref='HEAD'`: 140 paths owed, and `ZeroParadox/Computability/Kleene.lean` not among them, while it had just been re-reviewed. For a per-file lookup, `mcp__verdictLedger__find(step='prior_art', subject_sha=)` lists the `prior_art` records naming those bytes, at any basis or revision; it shows what was recorded, not which record decides an action. A path the owed list does not name is either covered by a passing `prior_art` verdict on its current bytes or outside the step's scope; the response gives the size of that scope as `applies_to`, a count rather than a list (381 at that measurement). Either way the step owes it nothing. + --- Spawn the Agent with this prompt (substitute ARGUMENTS_VALUE for the actual value of $ARGUMENTS): @@ -105,22 +111,30 @@ Evaluate only **synthesis / bridge claims**: a distinctive claim that unifies or 1. **Check our own corpus FIRST (before any web search).** Grep the repo and `.claude-local` (notes, `external/`, outreach) for an existing reference to the claim/concept — much of this project's prior-art knowledge already lives there (citations inside `.lean` docstrings, vendored libraries, outreach drafts, research notes). Anything already cited there is NOT a gap; do not "rediscover" it. Only what is genuinely uncited in our own corpus proceeds to a web search. 2. **State the claim** in the target field's own terms. 3. **Identify the specialist branch** that would own it (the subfield and the kind of result). -4. **Search the literature — run the LADDER in order. Do not skip a rung, and do not stop early.** +4. **Search the literature — run the LADDER in order, and do not stop early.** Rungs A, B and B2 always run; rung C runs on the condition stated at rung C; rung D runs for every source you cite. - **Rung A — `.claude-local/papers/`.** The downloaded-source library. **Grep loosely** (OCR'd scans carry intra-word spaces, so a tight-pattern miss is not absence). - - **Rung B — `theoremsearch`** (MCP tool `mcp__theoremsearch__theorem_search`). Matches on the STATEMENT, not the title, so it reaches claims a title search cannot. Four rules, each measured: + - **Rung B — `theoremsearch`** (MCP tool `mcp__theoremsearch__theorem_search`). Matches on the STATEMENT, not the title, so it reaches claims a title search cannot. Six rules, each measured: 1. **THREE PHRASINGS MINIMUM.** Vary them along the four axes in CLAUDE.md § `R-NOTINLIB` (body: `tools/process/not-in-the-library.md`): **POLARITY** (how the corpus would say it if it DISAGREED with you), **PART OF SPEECH** (the verb that builds it, not the noun), **VOCABULARY** (the domain's words), **DISPLAY** (never conclude absence from TRUNCATED output). Measured 2026-08-23: the noun form put the right theorem at rank 1 and the **verb** form dropped it out of the top 5 entirely — same claim, same index. **A single-phrasing negative is worthless.** 2. **DISPLAY is this rung's own exposure.** `theoremsearch` returns a capped list, so a scout who reads the cap and stops **has measured the cap, not the literature**. Re-run untruncated. 3. **IGNORE the `similarity`/`score` field.** The 7-case calibration of 2026-08-23 found **no threshold that keeps the garbage out without discarding the find** — noise scored 0.69 while genuine prior art scored 0.61. ⚠ That is a claim about THRESHOLDS, **not** that the score runs backwards. Measured 2026-08-24 across two independent probes: exact statements of Lawvere's fixed-point theorem returned 0.676, 0.683 and 0.686, other exact hits 0.834 and 0.777, and relevant fixed-point theorems 0.732 and 0.728 against irrelevant ones at 0.687 and 0.680. **Rank by reading; never filter on the number.** - 4. ⚠ **`paper_filter` takes a TITLE, not an arXiv id.** Passing an id returns empty and reads exactly like absence. - - **Rung C — the open web.** Run it when rung B returns no good match, **and also when rung B returns a neighbourhood hit whose real source still needs identifying**. Everything pre-arXiv lives here — Lawvere 1969, Aczel 1988, Ostrowski, Gentzen, Carlström. `theoremsearch` cannot return those as sources, only as work other people cite, **and the reason is the corpus boundary rather than a quirk: the index is built from arXiv, so a work published before arXiv existed appears in the index only inside the reference lists of papers that cite it.** A Gentzen-1936 query returns modern arXiv papers citing Gentzen, never Gentzen. + 4. **`paper_filter` takes a FULL arXiv id**; other tokens match title substrings. The tool's schema says ids "match as a prefix", but measured 2026-10-31 a truncated id returned empty (`0801.209`; earlier the same day `math/030700`, `0906.310`) where the full id hit (`0801.2097`, `math/0307008`). An empty result under a short id measures the id, not the paper. + 5. **AT LEAST ONE PHRASING RUNS WITH `formality: "formal"`.** The default is `"informal"`, so without it this rung never searches a Lean library, and `"both"` does NOT satisfy this rule: informal hits crowd the capped list (measured 2026-10-31, a Carleson query at `n_results` 10 returned 6 carleson-repo hits under `"formal"` and 0 under `"both"`). Formal coverage, as a dated SAMPLE (2026-10-31): hits in Mathlib, pfr, carleson, FLT and HarderNarasimhan; misses, on the probes run, teorth/equational_theories and this repository. **A formal null is coverage-bounded, and the index does not list its extent.** + 6. **A tool that is present but REFUSED is NOT RUN, never a null** — refused by the permission mode, or answering with an error that is not a rate limit (rung B2, step 5). Record the step NOT RUN with the refusal message verbatim. Measured 2026-10-31: every rung-B call of one review, the required `"formal"` one included, was refused by the permission mode. + - **Rung B2 — Lean libraries. Always run it.** It reaches Lean libraries that rung B's formal index does not hold; on the 2026-10-31 probes, equational_theories and this repository were reached only by step 3. LeanExplore's index overlaps rung B's in part. LeanExplore is Justin Asher's search engine for Lean declarations (arXiv:2506.11085; https://github.com/lean-explore/lean-explore), served as a hosted MCP at https://www.leanexplore.com/mcp. **If the `mcp__lean-explore__*` tools are not available to you, or are present but refused (rung B, rule 6), record steps 1–2 as NOT RUN with the reason or the refusal message verbatim, never as a null, and still do step 3.** + 1. **LeanExplore** — `mcp__lean-explore__search_summary(query, limit)`, **at least two phrasings** varied along the `R-NOTINLIB` axes. Each hit is `{id, name, description}`. Example, 2026-10-31: a Pataraia query returned Mathlib's `lfp` / Knaster–Tarski declarations only. `packages=[...]` restricts a search to named packages (measured 2026-10-31: `packages=["Cslib"]` returned only `Cslib.*` hits). + 2. **For any candidate, `mcp__lean-explore__get_source_code(declaration_id)`, then the elaborated type.** The source returns the declaration TEXT, which can omit section-level binders: measured 2026-10-31, `OrderHom.lfp` came back without `[CompleteLattice α]`. Read the hypotheses off the elaborated type before relying on it. **Inside this project's dependency closure, running it is the only route:** write a scratch `.lean` in the session scratchpad holding `#check @` and an `example` of the claimed statement closed `by exact?`, then run `lake env lean ` from the repo root (`lake build` does not reach a file outside the tree). `exact?` turns a search miss into an executed result. **Outside the closure (FLT, carleson, pfr, …), Tim's ruling of 2026-10-31:** read the source file around the declaration via `mcp__lean-explore__get_source_link`, its section `variable` lines included, and cite it as **PARTLY VERIFIED: source read, type not elaborated**. The two routes can disagree: on `OrderHom.lfp` the source's `variable` line declares `(f : α →o α)`, while the elaborated type is `(α →o α) →o α`. `mcp__lean-explore__get_dependencies` returns a PARTIAL list, as a JSON-encoded STRING rather than an array: measured 2026-10-31, for `Nat.Partrec.Code.fixed_point₂` it returned `"[\"Nat.Partrec.Code\", \"Eq\", \"Nat.Partrec.Code.eval\"]"`, which includes some constants of the statement and omits `Partrec₂` (the constant of the hypothesis `hf`) and the constants the proof uses. The search hit's `description` is the bold header of the AI-generated informalization (LeanExplore's `docs/data-models.md`; measured 2026-10-31): a snippet, never the source. **The index is a snapshot:** `get_source_link` points at Mathlib commit `aae61ae…` and this project pinned `5450b53…` when this was measured (the live pin is in `lake-manifest.json`), so line numbers can drift (`Nat.Partrec.Code.fixed_point₂`: L1021–1025 there, L1022–1026 at that pin; `OrderHom.lfp` did not move). A hit shows the name exists in their snapshot; confirm it at the pin. + 3. **Reservoir** (about 920 packages, 2026-10-31): for the long tail neither index holds, `mcp__github__search_code` with `extension:lean`, NOT `language:Lean` (measured 2026-10-31, a query on this repository returned 9 files with `extension:lean` and 0 with `language:Lean`), on keywords and on the declaration names a library would likely choose. Pass `perPage` ≤ 10 and add `-repo:timbrigham/ZeroParadox`: payloads are large and this repository ranks high (measured 2026-10-31: `epsilon0_eq_nfp_bot extension:lean` returned 10 files, all ours, and 0 with the exclusion). GitHub code search indexes default branches only. + 4. **ITS NULL IS UNINFORMATIVE**, for the same coverage reason as rung B's. + 5. **Both are hosted services.** Per LeanExplore's `docs/mcp-server.md`, it allows 30 POST requests per client IP per 60 s, counting initialize and tool discovery; past that it answers HTTP 429 with `Retry-After`. GitHub code search is rate-limited too. A rate-limit response (a 429, or a 403 that carries `Retry-After` or names a rate limit) is a wait, never a null; any other 403 is a refusal, recorded NOT RUN (rung B, rule 6). Each service sees every query, so phrase it neutrally rather than pasting unpublished claim text. + - **Rung C — the open web.** Run it when rung B returns no good match, **and also when rung B returns a neighbourhood hit whose real source still needs identifying**. Everything pre-arXiv lives here — Lawvere 1969, Aczel 1988, Ostrowski, Gentzen, Carlström. `theoremsearch` cannot return those as sources, only as work other people cite, **and the reason is the corpus boundary rather than a quirk: per the tool's own description the index covers arXiv, the Stacks Project, ProofWiki, four open textbooks and Lean repositories, so a pre-arXiv paper reaches it as something later work cites, not as the source.** A Gentzen-1936 query returns modern arXiv papers citing Gentzen, never Gentzen. - **Rung D — RETRIEVE AND READ THE FULL SOURCE.** Use WebFetch; if a domain is not reachable that way, download it via PowerShell `Invoke-WebRequest -Uri -OutFile .claude-local/papers/.pdf` and open it with the Read tool (this works for any publisher — arXiv, Dagstuhl/LIPIcs, nLab, journal sites). **Download straight into `.claude-local/papers/` under that name** — one destination, so filing is not a second step anyone can skip — and **validate before you rely on it** (a tiny PDF is an error page, not a paper). ⚠ **This is the one place the read-only rule yields, and it is deliberate**: filing the source is what feeds rung A for every later scout, so a review that reads a PDF and leaves nothing behind makes the library decay while looking like diligence. - ⚠⚠ **RUNGS A–C ARE DISCOVERY. ONLY RUNG D IS VERIFICATION.** **Draft from source, not from snippets — and a `theoremsearch` theorem body is a snippet, not a passage in hand.** Measured 2026-08-23: a returned body read as our recorded citation renumbered for a journal version, and the PDF showed the two statements were different (connexity versus splitting). The returned `slogan` field is an **LLM paraphrase**, `label`/`link` come back **null**, and ambient hypotheses are inconsistently included. If you genuinely cannot read the source, say so and treat the citation as **unverified**. + ⚠⚠ **RUNGS A–C ARE DISCOVERY. ONLY RUNG D IS VERIFICATION.** For a Lean declaration, rung D's retrieval is its source text plus its elaborated type; outside the dependency closure it reaches only PARTLY VERIFIED (rung B2, step 2). **Draft from source, not from snippets — and a `theoremsearch` theorem body is a snippet, not a passage in hand.** Measured 2026-08-23: a returned body read as our recorded citation renumbered for a journal version, and the PDF showed the two statements were different (connexity versus splitting). The returned `slogan` field is an **LLM paraphrase**; the `name` field carries the paper's own label on arXiv hits (measured 2026-10-31, `paper_filter="0801.2097"` returned "Lemma 1" and "Theorem 1" to "Theorem 3", matching the labels in Miller's PDF, where an appendix restarts the numbering, so two different statements both came back as "Theorem 2"), but numbering is version-specific and unverified until the source is open; `link` is **null** on Lean Repo hits; and ambient hypotheses are inconsistently included. If you genuinely cannot read the source, say so and treat the citation as **unverified**. - ⚠ **A NULL FROM RUNG B IS UNINFORMATIVE ON ITS OWN.** The index is coverage-bounded and the bound is invisible from the result — a paper this project holds on disk is verifiably absent from it. Never write "no prior art exists" from rung B, and do not record "none located as of <date>" until rung C has also run. + ⚠ **A NULL FROM RUNG B IS UNINFORMATIVE ON ITS OWN.** The index is coverage-bounded and the bound is invisible from the result — a paper this project holds on disk is verifiably absent from it. Never write "no prior art exists" from rung B, and do not record "none located as of <date>" until rung B (including a `"formal"` phrasing), rung B2 and rung C have all run. A step recorded NOT RUN (rung B, rule 6) has not run. In rung B2, steps 1–2 may be recorded NOT RUN (tool unavailable or refused, with the reason); step 3 is always required, and nothing records "none located" with it skipped. 5. **Verdict for this claim:** - **Prior art exists and is already cited** in the content → OK (after confirming the citation is real and correctly directed). - - **Prior art exists and is NOT cited** → FAIL for this claim: give the full citation (author, year, venue), state the claim's honest *delta* against it (what the framework genuinely adds), and the credit direction (framework is an instance joining the program, never subsuming it). + - **Prior art exists and is NOT cited** → FAIL for this claim: give the full citation (author, year, venue; for prior art that exists only as a Lean declaration, the repository, the declaration name and the commit you read it at, plus its status from rung B2 step 2, elaborated at the pin or PARTLY VERIFIED), state the claim's honest *delta* against it (what the framework genuinely adds), and the credit direction (framework is an instance joining the program, never subsuming it). - **A diligent search finds no closer specialist prior art** → OK, but record "searched [date], no closer prior art found" so the determination is on file. 6. **Citation-direction check:** for any prior art the content already cites, confirm it is cited in the correct direction (framework as instance/extension, not the prior work as an instance of the framework) and that the source actually says what the content claims it says. diff --git a/.claude/commands/remember-bottom.md b/.claude/commands/remember-bottom.md index e94859c5..bf6416d2 100644 --- a/.claude/commands/remember-bottom.md +++ b/.claude/commands/remember-bottom.md @@ -24,8 +24,13 @@ First, re-read the canonical sources for full context: **The honest relationships (keep these apart — this is the whole point):** - Every instance is a **MEMBER** of the family — proved per domain. The *choice of criteria* is a design principle; membership against them is proved. -- The **correspondence half is formally realized** — each domain bottom is the categorical bottom (limit - or initial object) of its own real Mathlib category, bundled as `mc1_correspondence`. +- The **correspondence half is formally realized**, differently per category (the three full positions + are stated together in `floor_positions_full`): a zero object, initial and terminal, in `ModuleCat ℂ` (`fD_zero_isInitial`, + `hilbert_bottom_isZero`); initial and not terminal in `KleisliCat PMF` (`fC_zero_isInitial`, + `kleisli_bottom_not_terminal`); in `TopCat` terminal (it has one point; `padic_bottom_isTerminal`), not + initial (`padic_bottom_not_initial`), and separately the limit of the ball tower (`floorConeIsLimit`). + `mc1_correspondence` bundles the two `IsInitial` fields, the no-return field and the `TopCat` set + equation; `floorConeIsLimit` sits outside it. - What separates the instances is proved property by property (`seam_unique_among_named`, for the named bottoms, in a lattice with no top); object equality across categories does not typecheck and is not invariant under equivalence. - The **cross-category IDENTITY half is RETIRED as ill-typed** (2026-07-15). `x = y` across distinct diff --git a/.github/workflows/axiom_ledger.yml b/.github/workflows/axiom_ledger.yml index f79456f4..51cdfec5 100644 --- a/.github/workflows/axiom_ledger.yml +++ b/.github/workflows/axiom_ledger.yml @@ -1,4 +1,4 @@ -name: Axiom Ledger +name: Axiom Ledger (choice-free computability) # The axiom-profile gate. Re-elaborates ZeroParadox/Meta/AxiomLedger.lean, whose `#eval` # recomputes every ledgered declaration's axiom profile with the vendored auditor @@ -7,8 +7,13 @@ name: Axiom Ledger # "Complete Project" also fails on drift; this job isolates it and shows the table. Fires on a # toolchain or Mathlib bump too, because that is when a profile drifts. A last step checks the # gate fails closed: a ledger with one planted wrong profile must come out red. +# The path filters below do not cover the ledgered files' whole import closure (Kleene.lean and +# its imports, for one), so a weekly scheduled run re-checks the ledger on the default branch +# whatever changed. GitHub disables scheduled runs after 60 days with no repository activity. on: workflow_dispatch: + schedule: + - cron: '17 6 * * 1' push: branches: - main diff --git a/.zenodo.json b/.zenodo.json index b1130ea7..120d0127 100644 --- a/.zenodo.json +++ b/.zenodo.json @@ -1,6 +1,6 @@ { "title": "The Zero Paradox: A Multi-Framework Mathematical Ontology", - "description": "Licensing: this record is under two licences. The code (the Lean files, build scripts, tooling and configuration, other than the third-party material named below) is licensed under the Apache License, Version 2.0 (LICENSE), the licence named in this record's licence field. The documents (the PDFs at the repository root, every Markdown file except CLAUDE.md and those under tools/ and .claude/, and the site layouts in _layouts/) are licensed under CC BY-NC-ND 4.0 (LICENSE-DOCS). NOTICE states which paths fall under which licence. Third-party material is covered by neither and keeps its own terms: the vendored Lean under ZeroParadox/Vendored/ and the port ZeroParadox/Ordinal/NaturalOpsPow.lean (Apache License, Version 2.0, from their original authors), and the fonts in scripts/fonts/, whose licence texts ship beside them (DejaVu under the Bitstream Vera and Arev font licences, with the DejaVu changes in the public domain; STIX Two under the SIL Open Font License, Version 1.1). A formal mathematical framework, verified sorry-free in Lean 4 + Mathlib across lattice algebra, p-adic topology, information theory, functional analysis, and category theory, whose central theorem T-SNAP proves the shape of the Binary Snap, the step from the bottom element ⊥ of a two-state carrier to the state above it (named ε₀ in that chart), and not that the step occurs: occurrence rests on the framework's occurrence commitment (with DA-1), not on T-SNAP (what T-SNAP is and is not: ZeroParadox/Order/SnapCannotBe.lean, Sections I-II). The step's join is derived from the bottom-element axiom of join-semilattice theory, with no snap-specific axiom, and that a first step above ⊥ exists at all rests on the framework's one substantive modelling commitment, discrete states (AX-B1); T-SNAP depends on no Lean axioms (#print axioms is empty); Classical.choice appears in the realization layers, mostly inherited from Mathlib but not only there, and ZeroParadox/Category/ChoiceCannotBe.lean, Section IV, collects cases, of either provenance, where a general statement proved with choice implies excluded middle or its weak form by a choice-free reduction, with their footprints printed in ZeroParadox/AxiomProfile.lean, Section 0. The formal layers included, each verified sorry-free in Lean 4 + Mathlib, are: ZP-A (lattice algebra), ZP-B (p-adic topology), ZP-C (information theory), ZP-D (functional analysis / state layer), ZP-E (cross-framework synthesis / T-SNAP derivation), ZP-F (counterexamples - the snap fails in all ordered fields), ZP-G (category theory), ZP-H (categorical bridge, with the snap floor realized as genuine functors into the real Mathlib categories TopCat, ModuleCat ℂ, and the Kleisli category of the probability monad), ZP-I (inside zero), ZP-J (self-reference / AFA decoration uniqueness / wheel of fractions - division by zero as a total operation), ZP-K (computational grounding), ZP-L (incomputability convergence / ε₀ as ordinal snap threshold), ZP-M (Kleene-ordinal bridge), ZP-N (the constructive snap - the ε₀ snap rebuilt syntactically from below on ordinal notations, choice-free; ZP-L's ε₀ results, as stated, carry Classical.choice in their statements; the ascent below ε₀ is restated choice-free on ordinal notations, and for ε₀ itself a choice-free Lean restatement of the fixed-point equation and its uniqueness on E0Note sets existence by definition, while a choice-free derivation in Lean of the fixed point on a well-founded carrier, leastness included, was not located as of 2026-10-08, searched as recorded in ZeroParadox/Ordinal/SnapNucleus.md), ZP-P (the fixed-point fork - a synthesis layer: least versus greatest fixed point, i.e. induction / well-founded versus coinduction / non-well-founded closure, with a choice-free Knaster–Tarski fork schema and the diagonal fixed point ⊥ at the collapse seam, where choice enters only the non-well-founded realizations and is inherited from Mathlib), and ZP-Q (the frame-change - the bottom read as both 0 and ∞: the order-theoretic frame-flip universal holds, valuation and categorical per-domain instances are built, and the categorical Lawvere universal meets a proven Cantor wall, with the cross-domain identity a type boundary), and ZP-R (cross-category fixed point - a synthesis / placement layer: the framework's self-application fixed point is a role filled per face, and ZP-R asks where that role is filled by a Lawvere fixed point across three faces: refuted in Set on every carrier except a one-element one (Cantor), 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 first finite stage of Soto-Andrade and Varela's two-element example, 1984, §2.5, pp. 15–16; the case Y = 2 of Trimble's Cantor theorem for posets; Bergman 2008, Cor. 7), and realized in the computability face (Rogers / Kleene; that this fixed point is a Lawvere instance is cited); Lawvere's theorem is the translation key between the faces formalized here, not a mechanism every face instantiates, and ZP-R conjectures nothing global; its Diagonal Family Addendum maps the faces formalized here by the μ/ν fork - wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (the Quine atom, the Kleene quine, Löb / Gödel 2nd, Rice) where it does, each fixed point supplied per face - with the unification credited to Lawvere (1969) and Yanofsky (2003) and the contribution the formalization (the engine, the wall faces, and the Quine-atom and Löb / Gödel 2nd floor faces choice-free; the computability floor faces choice-carrying) and its tie to the self-application role). The framework's claims are mapped against established prior art in a 'Convergence with established work' ledger (CLAIMS.md), with credit pointing outward and an honest delta for each, and the claim graph itself is machine-checked (ZeroParadox/ClaimsMirror.lean), each proved status a verified link to a green Lean declaration rather than a label; and a ZP-J Keystone Addendum records two machine-checked investigations of the keystone (the self-referential 'diagonal' fixed point at the floor): a face-by-face Lawvere verdict, and the binary snap as a crossing of the well-foundedness boundary (Taylor; Adámek-Milius-Moss), with the full coalgebraic version flagged open.", + "description": "Licensing: this record is under two licences. The code (the Lean files, build scripts, tooling and configuration, other than the third-party material named below) is licensed under the Apache License, Version 2.0 (LICENSE), the licence named in this record's licence field. The documents (the PDFs at the repository root, every Markdown file except CLAUDE.md and those under tools/ and .claude/, and the site layouts in _layouts/) are licensed under CC BY-NC-ND 4.0 (LICENSE-DOCS). NOTICE states which paths fall under which licence. Third-party material is covered by neither and keeps its own terms: the vendored Lean under ZeroParadox/Vendored/ and the port ZeroParadox/Ordinal/NaturalOpsPow.lean (Apache License, Version 2.0, from their original authors), and the fonts in scripts/fonts/, whose licence texts ship beside them (DejaVu under the Bitstream Vera and Arev font licences, with the DejaVu changes in the public domain; STIX Two under the SIL Open Font License, Version 1.1). A formal mathematical framework, verified sorry-free in Lean 4 + Mathlib across lattice algebra, p-adic topology, information theory, functional analysis, and category theory, whose central theorem T-SNAP proves the shape of the Binary Snap, the step from the bottom element ⊥ of a two-state carrier to the state above it (named ε₀ in that chart), and not that the step occurs: occurrence rests on the framework's occurrence commitment (with DA-1), not on T-SNAP (what T-SNAP is and is not: ZeroParadox/Order/SnapCannotBe.lean, Sections I-II). The step's join is derived from the bottom-element axiom of join-semilattice theory, with no snap-specific axiom, and that a first step above ⊥ exists at all rests on the framework's one substantive modelling commitment, discrete states (AX-B1); T-SNAP depends on no Lean axioms (#print axioms is empty); Classical.choice appears in the realization layers, mostly inherited from Mathlib but not only there, and ZeroParadox/Category/ChoiceCannotBe.lean, Section IV, collects cases, of either provenance, where a general statement proved with choice implies excluded middle or its weak form by a choice-free reduction, with their footprints printed in ZeroParadox/AxiomProfile.lean, Section 0. The formal layers included, each verified sorry-free in Lean 4 + Mathlib, are: ZP-A (lattice algebra), ZP-B (p-adic topology), ZP-C (information theory), ZP-D (functional analysis / state layer), ZP-E (cross-framework synthesis / T-SNAP derivation), ZP-F (counterexamples - the snap fails in all ordered fields), ZP-G (category theory), ZP-H (categorical bridge, with the snap floor realized as genuine functors into the real Mathlib categories TopCat, ModuleCat ℂ, and the Kleisli category of the probability monad), ZP-I (inside zero), ZP-J (self-reference / AFA decoration uniqueness / wheel of fractions - division by zero as a total operation), ZP-K (computational grounding), ZP-L (incomputability convergence / ε₀ as ordinal snap threshold), ZP-M (Kleene-ordinal bridge), ZP-N (the constructive snap - the ε₀ snap rebuilt syntactically from below on ordinal notations, choice-free; ZP-L's ε₀ results, as stated, carry Classical.choice in their statements; the ascent below ε₀ is restated choice-free on ordinal notations, and for ε₀ itself a choice-free Lean restatement of the fixed-point equation and its uniqueness on E0Note sets existence by definition, on an order that is not well-founded (not WellFoundedLT E0Note), and E0Note's crossing into Ordinal, e0Repr, carries Classical.choice, while a choice-free derivation in Lean of the fixed point on a well-founded carrier whose statements are choice-free, leastness included, was not located as of 2026-10-08 (searched again 2026-10-13), searched as recorded in ZeroParadox/Ordinal/SnapNucleus.md), ZP-P (the fixed-point fork - a synthesis layer: least versus greatest fixed point, i.e. induction / well-founded versus coinduction / non-well-founded closure, with a choice-free Knaster–Tarski fork schema and the diagonal fixed point ⊥ at the collapse seam, where choice enters only the non-well-founded realizations and is inherited from Mathlib), and ZP-Q (the frame-change - the bottom read as both 0 and ∞: the order-theoretic frame-flip universal holds, valuation and categorical per-domain instances are built, and the categorical Lawvere universal meets a proven Cantor wall, with the cross-domain identity a type boundary), and ZP-R (cross-category fixed point - a synthesis / placement layer: the framework's self-application fixed point is a role filled per face, and ZP-R asks where that role is filled by a Lawvere fixed point across three faces: refuted in Set on every carrier except a one-element one (Cantor), 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 first finite stage of Soto-Andrade and 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), while among chain-complete posets Soto-Andrade and Varela (1984, pp. 15-16) build a larger poset isomorphic to its maps into the two-element chain (read with continuous maps in ZP-R Section III), and realized in the computability face (Rogers / Kleene; that this fixed point is a Lawvere instance is cited); Lawvere's theorem is the translation key between the faces formalized here, not a mechanism every face instantiates, and ZP-R conjectures nothing global; its Diagonal Family Addendum maps the faces formalized here by the μ/ν fork - wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (the Quine atom, the Kleene quine, Löb / Gödel 2nd, Rice) where it does, each fixed point supplied per face - with the unification credited to Lawvere (1969) and Yanofsky (2003) and the contribution the formalization (the engine, the wall faces, and the Quine-atom and Löb / Gödel 2nd floor faces choice-free; the computability floor faces choice-carrying) and its tie to the self-application role; abstract Löb and Gödel 2 are also formalized by Popescu & Traytel (Isabelle, 2019) and Saitou & Noguchi (Lean 4, arXiv:2609.13780)). The framework's claims are mapped against established prior art in a 'Convergence with established work' ledger (CLAIMS.md), with credit pointing outward and an honest delta for each, and the claim graph itself is machine-checked (ZeroParadox/ClaimsMirror.lean), each proved status a verified link to a green Lean declaration rather than a label; and a ZP-J Keystone Addendum records two machine-checked investigations of the keystone (the self-referential 'diagonal' fixed point at the floor): a face-by-face Lawvere verdict, and the binary snap as a crossing of the well-foundedness boundary (Taylor; Adámek-Milius-Moss), with the full coalgebraic version flagged open.", "creators": [ { "name": "Brigham, Timothy" diff --git a/BOTTOMELEMENT.md b/BOTTOMELEMENT.md index 78210cc7..09862632 100644 --- a/BOTTOMELEMENT.md +++ b/BOTTOMELEMENT.md @@ -21,13 +21,13 @@ reading that the various bottoms are *one object* is retired as ill-typed (objec One self-referential structure - a thing that is its own fixed point - keeps turning up in fields that do not expect to meet. Here is each coincidence, ordered by how sure we are of it. Everything provable is checkable: clone the repo and run `#print axioms `. -**Proved - the same element (three names); and one commitment - the same role (the fourth).** In any ZP lattice carrying an AFA structure, the *Quine atom* (a set that is its own only member, set theory / AFA), the *order-bottom* ⊥ of that lattice, and the *algebraic join-identity* are proved to be the **same element** - the three-name core, **axiom-free** ([`t_exec_triple_iff`](ZeroParadox/Settheory/SetTheoryAFA.lean)). The fourth, the *Kleene fixed point* (a program equal to its own transform up to evaluation, computability), names no element of the lattice; it fills the same **role** by an explicit structural commitment: the [`KleeneStructure`](ZeroParadox/Computability/Kleene.lean) typeclass nominates its field [`botCode`](ZeroParadox/Computability/Kleene.lean) as the computational witness of the lattice's bottom role - the motivating commitment, not a derived theorem. No equation between the code and the set is well-formed: [`botCode`](ZeroParadox/Computability/Kleene.lean) is a Code and ⊥ is an element of the lattice, so neither side can be stated equal or unequal to the other. The computational witness rests on Mathlib's recursion theorem, which carries `Classical.choice`; the three-name core needs none. +**Proved - the same element (three names); and the fourth compared through a role.** In any ZP lattice carrying an AFA structure, the *Quine atom* (a set that is its own only member, set theory / AFA), the *order-bottom* ⊥ of that lattice, and the *algebraic join-identity* are proved to be the **same element** - the three-name core, **axiom-free** ([`t_exec_triple_iff`](ZeroParadox/Settheory/SetTheoryAFA.lean)). The fourth, the *Kleene fixed point* (a program equal to its own transform up to evaluation, computability), names no element of the lattice, and no code is equated with ⊥. The [`KleeneStructure`](ZeroParadox/Computability/Kleene.lean) typeclass was motivated by reading its field [`botCode`](ZeroParadox/Computability/Kleene.lean) as the computational witness of the lattice's bottom role; that reading's identity half is retired. The fourth is compared with the three through the die's Quine-atom **role** (Motion.[`SelfOnlyAt`](ZeroParadox/Die.lean)): under the eval step no single code occupies it ([`evalStepMotion_not_selfOnlyAt`](ZeroParadox/Computability/Kleene.lean)), and for a computable map respecting equal output a class of codes up to equal output does ([`codes_vs_classes`](ZeroParadox/Computability/Kleene.lean)). What stays a commitment is the running half: that ⊥ actually executes is the occurrence commitment. No equation between the code and the set is well-formed: [`botCode`](ZeroParadox/Computability/Kleene.lean) is a Code and ⊥ is an element of the lattice, so neither side can be stated equal or unequal to the other. The code side rests on Mathlib's recursion theorem, which carries `Classical.choice`; the three-name core needs none. -**Proved - each field's own floor.** 0 in the 2-adics, where v₂(0) = ∞ ([`padic_addVal_bot`](ZeroParadox/Valuation/ValuationAFA_Padic.lean)); unbounded surprisal, the state with no finite description ([`t2_diverges`](ZeroParadox/Information/Surprisal.lean)); the categorical bottom of each real Mathlib category, an inverse limit or initial object ([`fD_zero_isInitial`](ZeroParadox/State/HilbFunctor.lean), [`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean) and [`fB_bottom_is_limit`](ZeroParadox/Valuation/TopFunctor.lean), collected in [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean)); and the case where the coincidence *fails*, ℝ vs ℚ₂ by Ostrowski ([`completions_exhaustive`](ZeroParadox/Valuation/Ostrowski.lean), [`real_not_equiv_padic`](ZeroParadox/Valuation/Ostrowski.lean)). They share a SHAPE (`Statement:` COINCIDENCE, per field's own witness above) - one object carrying both extremal characterisations at once - and a shared shape across distinct structures is a type boundary, never a common theorem. (The order-theoretic form of that shape is [`fork_collapse_iff`](ZeroParadox/Settheory/FixedPointFork.lean), choice-free, but none of these satisfies its hypotheses of a complete lattice and a monotone map, so none is an instance of it.) ε₀ is co-witnessed with the 2-adic limit and the machine snap ([`zpm_triangle`](ZeroParadox/Ordinal/Incompleteness.lean)). +**Proved - each field's own floor.** 0 in the 2-adics, where v₂(0) = ∞ ([`padic_addVal_bot`](ZeroParadox/Valuation/ValuationAFA_Padic.lean)); unbounded surprisal, the state with no finite description ([`t2_diverges`](ZeroParadox/Information/Surprisal.lean)); a categorical characterization in each real Mathlib category, differing by category, the three full positions stated together in [`floor_positions_full`](ZeroParadox/Category/TreeSeam.lean) (a zero object; initial and not terminal; terminal and not initial), with every half cited per category: a zero object, initial and terminal, in `ModuleCat` ℂ ([`fD_zero_isInitial`](ZeroParadox/State/HilbFunctor.lean), [`hilbert_bottom_isZero`](ZeroParadox/Category/TreeSeam.lean)); initial and not terminal in `KleisliCat` PMF ([`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean), [`kleisli_bottom_not_terminal`](ZeroParadox/Category/TreeSeam.lean)); in `TopCat` terminal, since it has one point ([`padic_bottom_isTerminal`](ZeroParadox/Multihomed/TreeObstructions.lean)), not initial ([`padic_bottom_not_initial`](ZeroParadox/Multihomed/TreeObstructions.lean)), and separately the limit of the ball tower ([`floorConeIsLimit`](ZeroParadox/Order/PadicLimitCone.lean)); [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean) collects the two initial-object witnesses with the no-return fact [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) and the set equation [`fB_bottom_is_limit`](ZeroParadox/Valuation/TopFunctor.lean); and the case where the coincidence *fails*, ℝ vs ℚ₂ by Ostrowski ([`completions_exhaustive`](ZeroParadox/Valuation/Ostrowski.lean), [`real_not_equiv_padic`](ZeroParadox/Valuation/Ostrowski.lean)). They share a SHAPE (`Statement:` COINCIDENCE, per field's own witness above) - one object carrying both extremal characterisations at once - and a shared shape across distinct structures is a type boundary, never a common theorem. (The order-theoretic form of that shape is [`fork_collapse_iff`](ZeroParadox/Settheory/FixedPointFork.lean), choice-free, but none of these satisfies its hypotheses of a complete lattice and a monotone map, so none is an instance of it.) ε₀ is co-witnessed with the 2-adic limit and the machine snap ([`zpm_triangle`](ZeroParadox/Ordinal/Incompleteness.lean)). -**Mostly proved - a narrow residue argued.** The framework's set-theoretic *commitment* is not *AFA specifically* but a fragment it assumes of its host theory: a unique Quine atom ⊥ = {⊥}, ⊥'s only member being ⊥ and no other set its own only member. That is AFA's profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). The fragment is a checkable object, the [`QuineAtomHost`](ZeroParadox/Settheory/QuineHost.lean) typeclass. Foundation-freeness is *forced* by ⊥ ∈ ⊥ ([`quineAtomHost_not_wellFounded`](ZeroParadox/Settheory/QuineHost.lean), axiom-free - a self-loop cannot live in a well-founded world); ordinary set theory (Foundation) is excluded in-kernel about the real theory ([`zfSet_no_singleton_bottom`](ZeroParadox/Settheory/QuineHost.lean) - no set is its own sole member under Foundation); Boffa's BA₁ is set aside because its reflexive sets form a proper class rather than one (Aczel 1988, Prop. 5.1, p. 57), a gap a toy model makes concrete ([`boffa_fails_reflexive_unique`](ZeroParadox/Settheory/QuineHost.lean)) rather than an in-kernel fact about Boffa's axiom; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older [`QuineHost`](ZeroParadox/Settheory/QuineHost.lean) typeclass asks for ⊥ ∈ ⊥ with no other self-membered element, which AFA's membership fails (0* = {∅, 0*} is self-membered, Aczel 1988, Example 1.5, p. 7); the two classes are incomparable. What remains argued is only that a Quine atom and its uniqueness are the right two requirements - a Forced Metatheoretic Commitment with a named falsifier, stronger than a free choice and weaker than a theorem. The set-membership face ⊥ ∈ ⊥ stays metatheoretic; the structural fixed point is machine-checked and axiom-free ([`t_exec`](ZeroParadox/Settheory/SetTheoryAFA.lean)). +**Mostly proved - a narrow residue argued.** The framework's set-theoretic *commitment* (CC-2) is adopting AFA; what the Lean abstracts of it is a fragment it assumes of its host theory: a unique Quine atom, a bottom b = {b} whose only member is itself, and no other set its own only member. That is AFA's profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). The fragment is a checkable object, the [`QuineAtomHost`](ZeroParadox/Settheory/QuineHost.lean) typeclass. Foundation-freeness is *forced* by the host bottom's self-membership, b ∈ b ([`quineAtomHost_not_wellFounded`](ZeroParadox/Settheory/QuineHost.lean), axiom-free - a self-loop cannot live in a well-founded world); ordinary set theory (Foundation) is excluded in-kernel about the real theory ([`zfSet_no_singleton_bottom`](ZeroParadox/Settheory/QuineHost.lean) - no set is its own sole member under Foundation); Boffa's BA₁ is set aside because its reflexive sets form a proper class rather than one (Aczel 1988, Prop. 5.1, p. 57), a gap a toy model makes concrete ([`boffa_fails_reflexive_unique`](ZeroParadox/Settheory/QuineHost.lean)) rather than an in-kernel fact about Boffa's axiom; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older [`QuineHost`](ZeroParadox/Settheory/QuineHost.lean) typeclass asks for a self-membered bottom with no other self-membered element, which AFA's membership fails (0* = {∅, 0*} is self-membered, Aczel 1988, Example 1.5, p. 7); the two classes are incomparable. That a Quine atom and its uniqueness are the right two requirements is argued - a Forced Metatheoretic Commitment with a named falsifier ([CLAIMS.md](CLAIMS.md) Tier 4, the row "Host-theory requirements (R-AFA, ZP-E)"), stronger than a free choice and weaker than a theorem. In the die the Quine atom is a role, a point that steps to itself and to nothing else (Motion.[`SelfOnlyAt`](ZeroParadox/Die.lean)), whose occupancy is settled chart by chart: in a [`QuineAtomHost`](ZeroParadox/Settheory/QuineHost.lean) with membership as the step, the host's own bottom is its only occupant ([`quineAtomHost_quine_role_iff`](ZeroParadox/Settheory/QuineDichotomy.lean)), so ⊥ of a [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean) occupies it exactly when the host's bottom is ⊥ (the examples after [`quineAtomHost_quine_role_iff`](ZeroParadox/Settheory/QuineDichotomy.lean) in ZeroParadox/Settheory/QuineDichotomy.lean); in a [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean) with the [`AbstractSelfApp`](ZeroParadox/Computability/SelfApp.lean) map as the step, ⊥ is its only occupant ([`selfApp_quine_role_iff`](ZeroParadox/Settheory/QuineDichotomy.lean)); and no `ZFSet` occupies it ([`zfset_quine_role_unoccupied`](ZeroParadox/Settheory/Wall.lean)). Every inhabited type carries a [`QuineAtomHost`](ZeroParadox/Settheory/QuineHost.lean) ([`trivialQuineAtomHost`](ZeroParadox/Settheory/QuineHost.lean)) and every [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean) an [`AbstractSelfApp`](ZeroParadox/Computability/SelfApp.lean) ([`trivialSelfApp`](ZeroParadox/Computability/SelfApp.lean)), so an occupancy says something only with the step named. No equation across charts is stated: ⊥ of a [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean) is not asserted to be a set. The structural fixed point is machine-checked and axiom-free ([`t_exec`](ZeroParadox/Settheory/SetTheoryAFA.lean)). -**The family - MC-1.** MC-1 names not one object but one **family**. Each of these floors is a member: it satisfies the shared criteria mapped in the slots below, with per-domain membership machine-verified where marked (the categorical criterion is carried by the per-domain witnesses [`fD_zero_isInitial`](ZeroParadox/State/HilbFunctor.lean), [`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean) and [`fB_bottom_is_limit`](ZeroParadox/Valuation/TopFunctor.lean), collected in [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean)). The *choice* of criteria is a design principle; that they characterize the family is an argument. The cross-category numerical identity - that the bottoms are *one and the same object* - is **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). What survives is the proved leaves and the proved walls; the only oneness is the shared self-referential *shape* - the diagonal fixed point - which lives in the apophatic register, never as a formal identity. Within-frame identities stand: the three-name core above ([`t_exec_triple_iff`](ZeroParadox/Settheory/SetTheoryAFA.lean), axiom-free), and in ℚ₂ the equality v₂(0) = ∞ ([`padic_addVal_bot`](ZeroParadox/Valuation/ValuationAFA_Padic.lean)) - an equality of *values* in the value monoid, not of points of ℚ₂. The 2-adic **pole** is a claim of a different kind: 0 and ∞ are provably distinct points of the sphere which inversion *exchanges* (`Statement:` INVERSION, [`point_and_field_at_the_poles`](ZeroParadox/Valuation/PoleCornersBridge.lean)), so calling the two one pole is a chart claim rather than an identity of points. +**The family - MC-1.** MC-1 names not one object but one **family**. Each of these floors is a member: it satisfies the shared criteria mapped in the slots below, with per-domain membership machine-verified where marked (the categorical criterion differs by category: a zero object, initial and terminal, in `ModuleCat` ℂ; initial and not terminal in `KleisliCat` PMF; in `TopCat` terminal, since it has one point, and not initial, and separately the limit of the ball tower; the three full positions are stated together in [`floor_positions_full`](ZeroParadox/Category/TreeSeam.lean) (a zero object; initial and not terminal; terminal and not initial), and the `TopCat` limit is [`floorConeIsLimit`](ZeroParadox/Order/PadicLimitCone.lean); [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean) collects the initial-object witnesses [`fD_zero_isInitial`](ZeroParadox/State/HilbFunctor.lean) and [`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean) with the no-return fact [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) and the set equation [`fB_bottom_is_limit`](ZeroParadox/Valuation/TopFunctor.lean)). The *choice* of criteria is a design principle; that they characterize the family is an argument. The cross-category numerical identity - that the bottoms are *one and the same object* - is **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). What survives is the proved leaves and the proved walls; the only oneness is the shared self-referential *shape* - the diagonal fixed point - which lives in the apophatic register, never as a formal identity. Within-frame identities stand: the three-name core above ([`t_exec_triple_iff`](ZeroParadox/Settheory/SetTheoryAFA.lean), axiom-free), and in ℚ₂ the equality v₂(0) = ∞ ([`padic_addVal_bot`](ZeroParadox/Valuation/ValuationAFA_Padic.lean)) - an equality of *values* in the value monoid, not of points of ℚ₂. The 2-adic **pole** is a claim of a different kind: 0 and ∞ are provably distinct points of the sphere which inversion *exchanges* (`Statement:` INVERSION, [`point_and_field_at_the_poles`](ZeroParadox/Valuation/PoleCornersBridge.lean)), so calling the two one pole is a chart claim rather than an identity of points. --- @@ -243,10 +243,10 @@ lemmas are the statements, the analogy is not one.) - `NARR` ≝ - [`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean) *(a `def`, and its type is not a proposition)* - `MEAS` ∅ - the empty type carries no distribution at all, so no scalar exists to diverge. ⚠ ``IsEmpty` (PMF (Fin 0))` elaborates, so the stronger mark - a proved obstruction (✗) rather than a category error - is AVAILABLE and unbuilt as of 2026-08-29. Upgrading it costs one theorem; the mark stays ∅ until that theorem exists, because a cell may not cite a witness the corpus does not contain - `INV` ≝ - `IsInitial.op` *(a `def`, and its type is not a proposition)* (Mathlib) -- `CONC` ∅ - DEGENERATE on an empty carrier - there are no points, so every endomorphism fixes every point vacuously and CONC carries no content here. ⚠ This cell previously cited `[`kleisli_bottom_not_zero`](ZeroParadox/Category/SeamUniqueness.lean)` as a refutation; that theorem proves the Kleisli bottom is not a ZERO OBJECT (not terminal), which is a mu/nu DIRECTION fact and belongs to DYN. It addresses neither of CONC's two propositions -- `SELF` ∅ - DEGENERATE, and that is the finding. `Fin 0` is EMPTY, so the Kleisli endomorphism `Fin 0 -> PMF (Fin 0)` is the unique empty map and every diagonal/self-application statement about it holds VACUOUSLY, carrying no content about this bottom. ⚠ Not that no self-map exists - the same correction the `TopCat` cells took 2026-08-29. No ZP witness is cited because none is owed for a degeneracy +- `CONC` ∅ - DEGENERATE on an empty carrier - there are no points, so every endomorphism fixes every point vacuously and CONC carries no content here. ⚠ [`kleisli_bottom_not_zero`](ZeroParadox/Category/SeamUniqueness.lean) is not a refutation of CONC: it proves the Kleisli bottom is not a ZERO OBJECT (not terminal), which is a mu/nu DIRECTION fact and belongs to DYN, and it addresses neither of CONC's two propositions +- `SELF` ∅ - DEGENERATE, and that is the finding. `Fin 0` is EMPTY, so the Kleisli endomorphism `Fin 0 -> PMF (Fin 0)` is the unique empty map and every diagonal/self-application statement about it holds VACUOUSLY, carrying no content about this bottom. ⚠ Not that no self-map exists; the `TopCat` cells say the same. No ZP witness is cited because none is owed for a degeneracy - `GEN` ✓ - [`node4_generates_nat`](ZeroParadox/Category/Node4Generation.lean) -- `DYN` ↑ - [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) (initial source; nothing returns to ⊥ - μ) +- `DYN` ↑ - [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) (initial source; no later stage n > 0 returns to `KleisliCat` PMF's floor Fin 0 - μ) **#5 Hilbert (zero obj/seam)** - `CANT` ✓ - [`seam_not_mu_colimit_apex`](ZeroParadox/Category/SeamNotColimit.lean) @@ -307,6 +307,7 @@ lemmas are the statements, the analogy is not one.) - `SELF` ✓ - [`derived_bot_self_mem`](ZeroParadox/Computability/SelfApp.lean) - `GEN` ∅ - self-coincident (μ=ν seam, ⊥ = the least fixed point) - carries SELF/CONC, not GEN - `DYN` ↑* - [`t_snap_derived`](ZeroParadox/Order/Snap.lean) (inherited; the static seam-point does not itself move) +- Control: every [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean) carries an [`AbstractSelfApp`](ZeroParadox/Computability/SelfApp.lean), [`trivialSelfApp`](ZeroParadox/Computability/SelfApp.lean), whose map is the constant map to ⊥ of that [`ZPSemilattice`](ZeroParadox/Order/Lattice.lean); there ⊥ still occupies the Quine-atom role (the CONTROL example after [`selfApp_quine_role_iff`](ZeroParadox/Settheory/QuineDichotomy.lean) in ZeroParadox/Settheory/QuineDichotomy.lean), so that occupancy comes from the class fields, whatever the map is @@ -324,9 +325,9 @@ The classical self-reference arguments are not separate theorems that happen to | Tarski | μ wall | no internal truth predicate - the liar sentence has no witness | [`tarski_no_internal_truth`](ZeroParadox/Settheory/Tarski.lean) | (none) | | Curry | μ wall | no naming surjection - Curry's paradox forces any conclusion | [`curry_no_bottom`](ZeroParadox/Settheory/Curry.lean) | (none) | | the wall | μ | no well-founded relation admits a self-loop (a host verdict, not an engine face) | [`wf_no_selfloop`](ZeroParadox/Settheory/Wall.lean) | (none) | -| Quine atom | ν floor | ⊥ = {⊥}: ⊥ of a ZPSemilattice in the Quine-atom role, from the class fields | [`t_exec`](ZeroParadox/Settheory/SetTheoryAFA.lean) | (none) | +| Quine atom | ν floor | the Quine atom (CC-2): every Quine atom (IsQuineAtom) of a ZPSemilattice with an AFAStructure is ⊥, from the class fields; no set is equated with ⊥ | [`t_exec`](ZeroParadox/Settheory/SetTheoryAFA.lean) | (none) | | Löb | ν floor | given a Löb diagonal ψ (hypotheses hfix1, hfix2), ⊢ □A → A yields ⊢ A | [`loeb`](ZeroParadox/Settheory/Loeb.lean) | (none) | -| Gödel 2nd | ν floor | given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum | [`godel_two`](ZeroParadox/Settheory/Loeb.lean) | (none) | +| Gödel 2nd | ν floor | given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum (Gödel's second theorem when the class is instantiated at a theory of arithmetic and falsum is its falsum; in the class, falsum may be any sentence) | [`godel_two`](ZeroParadox/Settheory/Loeb.lean) | (none) | | Kleene quine | ν floor | every computable self-map on codes has a fixed point up to eval (Rogers' form of the recursion theorem) | [`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean) | `[propext, Classical.choice, Quot.sound]` | | Rice | ν floor | a fixed point up to eval exists; every non-trivial semantic property is undecidable over all codes | [`rice_face_has_bottom`](ZeroParadox/Computability/Rice.lean), [`quine_exists_yet_rice`](ZeroParadox/Computability/Rice.lean) | `[propext, Classical.choice, Quot.sound]` | diff --git a/CLAIMS.md b/CLAIMS.md index d85c4fe9..2c5b4d84 100644 --- a/CLAIMS.md +++ b/CLAIMS.md @@ -28,14 +28,14 @@ The framework's load-bearing claims. The Lean kernel reports no axiom dependency | 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); `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) | +| 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, carried by ZP-K's `KleeneStructure` commitment | `t_exec` | (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) | @@ -49,10 +49,10 @@ No `Classical.choice`; at most propositional extensionality and quotient soundne |-------|---------------|--------------|--------| | 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 | Structural floor in the power-set model | `ps_structural_floor` | [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] | +| 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] | @@ -65,13 +65,13 @@ These *realize* the snap floor inside standard analytic structures and inherit ` | 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 | TopCat | `fB_functor` | -| ⊥ as initial object | ModuleCat ℂ | `fD_functor` | -| ⊥ as initial object | KleisliCat PMF (`fC_no_return` = AX-G2 as theorem) | `fC_functor` | +| ⊥ 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 computational face enters as a `KleeneStructure` class field, not as a clause of the theorem | `da1_closed_concrete` | -| Rice face (diagonal family) | computability - the fixed point provably exists yet its membership is undecidable | `rice_face_has_bottom`, `quine_exists_yet_rice` | +| 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` | @@ -84,12 +84,12 @@ These *realize* the snap floor inside standard analytic structures and inherit ` ## 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 ZF+AFA framing, not the Lean kernel — and carries a named falsifier. See [Forced Metatheoretic Commitment](fmc.md). +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) | That the right requirements on the host theory are (Y') a Quine atom ⊥ = {⊥} (CC-2) and (Z') its uniqueness among reflexive sets (x = {x}) — AFA being the canonical example meeting them (it allows at most one solution of x = {x}, Aczel 1988, p. 19), not the commitment itself. Only "these are the right requirements to demand" is now 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 | The literal ⊥ = {⊥} (the Quine atom as a set fact, so ⊥ ∈ ⊥) | That whatever fills the Quine-atom role is ⊥ (`t_exec`) is axiom-free; only the set-membership reading is metatheoretic | Same as above — a Foundation-respecting realization of the same structural role | +| 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) @@ -98,7 +98,7 @@ Explicit, motivated commitments. Listed so the open register holds only genuinel | 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 criterion is `mc1_correspondence`, Tier 3); 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. | +| 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. | @@ -107,16 +107,16 @@ A commitment marked "not a novel commitment" in the layers means its content is
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 (⊥ = {⊥}) in set theory, 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 the inverse limit in `TopCat`, the initial object in `ModuleCat ℂ`, and the initial object in the Kleisli category of the probability monad `KleisliCat PMF` - with no morphism returning to it in the stochastic case (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 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 ZF + AFA (Zermelo-Fraenkel with Anti-Foundation Axiom), 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. The Axiom of Choice is not assumed. The commitment is not the *adoption of AFA specifically* — a judgment about which axiom system to pick — but a set of requirements on the host theory that AFA satisfies (Tier 4); AFA is the canonical example, not the commitment itself. What "forced" means here, and the discipline every such claim must meet, is defined in [Forced Metatheoretic Commitment](fmc.md). +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* — the property it assumes of its host theory, not the full Anti-Foundation Axiom (AFA's "every graph has a unique decoration") — is only the *fragment* that supplies a **unique Quine atom** ⊥ = {⊥}: ⊥'s only member is ⊥, and no other set is its own only member. Naming that fragment as requirements, rather than committing to "AFA specifically," is made checkable as `QuineAtomHost` (`ZeroParadox/Settheory/QuineHost.lean`): the host must supply **(Y')** ⊥ = {⊥} (`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: ⊥ ∈ ⊥ 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` (⊥ ∈ ⊥, and uniqueness among self-members) is a different requirement, incomparable with this one, and AFA's membership fails it. What remains a modeling commitment — no longer "AFA is forced," but only that (Y') and (Z') are the right requirements to demand — is a design principle; AFA is the witness that a theory meeting it exists, not the commitment. (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 older "why AFA specifically" argument is ZP-E Remark R-AFA; this requirements framing supersedes it. It remains an argument, not a derivation in the formal system — see Tier 4 and its named falsifier.) +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.)
@@ -138,7 +138,7 @@ The framework's set-theoretic *commitment* — the property it assumes of its ho | 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 choice-free carrier), 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. | +| `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. | @@ -156,19 +156,20 @@ Open questions are also discussed publicly in the [GitHub Discussions Open Quest | 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) as commitment | **Role occupant proved - ZP-J T-EXEC** (axiom-free): on a lattice, whatever fills the Quine-atom role is ⊥, given the field `bot_self_mem`. In AFA set theory Q = {Q} is a theorem; that the occupant of the framework's ⊥ role, ⊥ of a `ZPSemilattice`, is that set is a Forced Metatheoretic Commitment (Tier 4), 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 (instantiation occurs) together with DA-1 (closed given DP-2)** (`tsnap_holds_but_nothing_moves` shows T-SNAP does not carry it, `ZeroParadox/Order/Snap.lean`) | -| 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 **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. **Corrected 2026-07-31:** this row read "branching mandatory via T-SNAP", and 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), so the closure is conditional on the occurrence commitment and C-DA2, in the same sense DA-1 is "closed given DP-2" above. The question itself presupposes that instantiation happens; what DA-2 with C-DA2 settles is that the resulting shape is a tree. | -| DA-2: Instantiation succession | **Closed for the ROLE-RECOGNITION; occupancy 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. | +| 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 be the same obstruction) | -| T-IZ: Inside Zero Theorem | **A CONJUNCTION derived in Lean, not a chain; occupancy and the successor reading are commitments.** `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 and the successor reading are commitments.** Every branch starts at ⊥, ascends ω state changes (T3), and at the ordinal limit converges to 0 in Q₂. Reading that limit as something playing the bottom role is a COMMITMENT — the join-identity is not statable in Q₂ — 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); 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). 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 the two limits instead), 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`). | +| 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); 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). 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`). | @@ -192,23 +193,23 @@ Three things to read it correctly: |---|---|---|---| | **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** | ⊥={⊥} (CC-2); the ZFC/AFA contact point | **Theorem-grounded + commitment**: that whatever fills the Quine-atom role is ⊥ (`t_exec`) is axiom-free Lean; the literal set-membership identity is metatheoretic. **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 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, Aczel-Mendler 1989; cited, not claimed). 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) | +| **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 at ε₀ (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 | +| **ε₀ 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: ⊥ as each domain category's categorical bottom - 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 the inverse limit (TopCat has a terminal object); 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 bottom is the categorical bottom of its own real Mathlib category (per-category Lean: `fD_zero_isInitial`, `fC_zero_isInitial`, the TopCat limit); 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 | +| **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; 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 ⊥ / no external description | **Analogy / referenced** - lighter; Yanofsky also notes AIT fits the scheme | Parallel - not a load-bearing identity | +| **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 ε₀ (contingent value) + 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 | +| **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 | @@ -222,25 +223,25 @@ Machine-checked proofs of the formal documents using Lean 4 + Mathlib. Source li |----------|-------------|----------|-------| | 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 ⊥ | 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: ⊥ as inverse limit in TopCat, initial object in ModuleCat ℂ and KleisliCat PMF; mc1_correspondence bundle | Clean - June 2026 | -| ZP-I Inside Zero | [SemilatticeInstance.lean](ZeroParadox/Valuation/SemilatticeInstance.lean) | Every maximal chain is Cauchy and converges to 0 in Q₂; reading that limit as an *occupant* of the ⊥ role is a commitment (not statable in Q₂), and reading the occupant as a *successor* ⊥ is a further one (Inside Zero) | 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') ⊥ = {⊥} + (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` (⊥ ∈ ⊥ + uniqueness among self-members) is incomparable with it, and AFA's membership fails it | Clean - July 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 | [APG.lean](ZeroParadox/Settheory/APG.lean) | Decoration uniqueness for finite accessible pointed graphs, by induction on reachable size | 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); 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 2008, Cor. 7), 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 | +| 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 |
@@ -248,7 +249,7 @@ Machine-checked proofs of the formal documents using Lean 4 + Mathlib. Source li 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` (each measured on its statement alone, 2026-10-09). 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, and the ZP-M statement through its ordinal conjunct (each measured on the statement and on each part alone, 2026-10-09). 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. Measured 2026-08-29; the file was previously listed here as uniformly choice-free. 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`. +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`.
diff --git a/CLAUDE.md b/CLAUDE.md index c992810c..eede70ff 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -134,8 +134,8 @@ TRIGGER you found a defect, you are choosing what to work on next, or you are a RULE record it in `.claude-local/DEFECTS.md` — never a note, a gate-findings archive, or a handoff line, and never a second copy. Verify every entry AT THE ARTIFACT before recording it open or closed. GREP LOOSELY. Burn down in FILE-SIZED - BATCHES. NO RELEASE IS CUT WHILE THE LEDGER IS NON-EMPTY; release pressure never - defers a finding to next-touch debt. The target is ZERO KNOWN defects, not zero. + BATCHES. A RELEASE BLOCKS ONLY ON OPEN CONTENT BEDROCK (`check_release_ready.py`); + ORDINARY ships as a public erratum issue. Never lower a grade to release. COST a DOI is permanent and four releases already carry latent flaws — a defect fixed before a release costs one gate round, one shipped inside a PDF is forever. READ tools/process/defect-ledger.md @@ -597,10 +597,10 @@ TRIGGER you can state the claim in one sentence of standard mathematical Englis RULE three steps, ~10 minutes, BEFORE building. (1) grep our own corpus. (2) grep the pinned Mathlib for the CONCEPT — and if the claim is a Lean statement, RUN `exact?`; it searches statement SHAPE, not names, and reaches attribute-generated siblings - that have no source line. (3) one literature search, run as the four-rung LADDER: - `.claude-local/papers/` → `theoremsearch` → the open web → RETRIEVE THE FULL - DOCUMENT. Three phrasings minimum at rung 2; ignore its similarity score; its null - is UNINFORMATIVE. Rungs 1–3 are DISCOVERY, only rung 4 is VERIFICATION — a returned + that have no source line. (3) one literature search, run as the LADDER: papers → + `theoremsearch` (one phrasing `formality: "formal"`) → Lean libraries (LeanExplore, + GitHub `extension:lean`) → open web → RETRIEVE. Three phrasings at `theoremsearch`; + ignore its score; every null is UNINFORMATIVE. Only RETRIEVAL is VERIFICATION — a theorem body is not a passage in hand. Standard framing, once found, is ADOPTED, not noted and worked around; check purity before swapping a proof. `/prior-art-review` is the deep gate, a fresh agent, and it records its verdict in the verdictLedger. @@ -636,12 +636,12 @@ RULE `python tools/verify/check_release_ready.py ` must EXIT 0 and its deterministic preconditions — Engineer's Takes filled (recursive glob over `ZeroParadox/**/*.lean`), build-script hashes against `register.md`, the `LEAN_CUSTOM_REGISTRY` invariant, `.zenodo.json` valid and its description current, - no conflict markers, a `## ` entry in `RELEASES.md`, every linked PDF present. - **NO RELEASE WHILE `DEFECTS.md` IS NON-EMPTY.** Then STOP: creating the release is - Tim's command, never an agent's. Major = a new formal layer or a theorem status - change; minor = a substantive feedback round or accumulated updates. Never release - per-PR. A Lean-only milestone is an explicit QUESTION for Tim, not an automatic - trigger either way. + no conflict markers, a `## ` entry in `RELEASES.md`, every linked PDF present, + **NO OPEN CONTENT BEDROCK IN `DEFECTS.md`** (ordinary ships as erratum issues). Then + STOP: creating the release is Tim's command, never an agent's. Major = a new formal + layer or a theorem status change; minor = a substantive feedback round or + accumulated updates. Never release per-PR. A Lean-only milestone is an explicit + QUESTION for Tim, not an automatic trigger either way. COST a release mints a PERMANENT Zenodo DOI and four already carry latent flaws that cannot be withdrawn. Deposited FILES are frozen; record METADATA can still be corrected in the Zenodo UI, so a wrong release description is fixable and a flaw @@ -755,7 +755,8 @@ RULE ask: is this the CENTRAL claim of its section, or infrastructure for so holds only given an explicit modelling commitment. **Design Principle (DP)** — chosen, not derived. **Remark (R)** — context, no proof. Readable names are ADDITIVE, never eliminative: CC-2 is "the Quine atom (CC-2)", - glossed once as the self-containing bottom; MC-1 is "the bottom family" and gets NO + glossed once as the role of a point that steps to itself and to nothing else, whose + occupancy is settled chart by chart; MC-1 is "the bottom family" and gets NO new readable name, because its object already has one — the diagonal fixed point. Keep every formal handle; never rename or remove an identifier. AX-1 is retired: its SHAPE is Theorem T-SNAP (never an axiom); its OCCURRENCE is a separate commitment. diff --git a/GUIDE.md b/GUIDE.md index 6d87abdd..8b47c9ba 100644 --- a/GUIDE.md +++ b/GUIDE.md @@ -12,7 +12,7 @@ For a dictionary and map of ⊥ - the object the whole framework is built on - s ## What This Is -The Zero Paradox proves that an atom above ⊥ of the discrete state chart (a state with nothing between it and ⊥; c₁ in `MachinePhase`) is structurally forced - not assumed - given the framework's discrete state model (a bare join-semilattice alone can be densely ordered, and in a dense order no element has a first step, so there is no such atom; the real numbers are the familiar dense case). The result is machine-verified in Lean 4. The supporting structure examines what happens at the bottom element ⊥ across several mathematical frameworks; each independently locates the same structural constraint. One additional hypothesis per framework is required that is not derivable from that framework's axioms alone - these are catalogued in [Axiomatic Commitments](README.md#axiomatic-commitments) in README.md. +The Zero Paradox proves that an atom above ⊥ of the discrete state chart (a state with nothing between it and ⊥; c₁ in `MachinePhase`) is structurally forced - not assumed - given the framework's discrete state model (a bare join-semilattice alone can be densely ordered, and in a dense order no element has a first step, so there is no such atom; the real numbers are the familiar dense case, and since they have no least element, a dense case with one is the non-negative reals under max, where 0 is least and has no atom above it). The discrete state model is itself the assumption: it is AX-B1, the framework's one substantive modelling commitment, and for a general join-semilattice the cover is a hypothesis (`t_snap_given_cover`); in the two-state carrier `MachinePhase` the atom is checked (`t_snap_derived_cover`). The result is machine-verified in Lean 4. The supporting structure examines what happens at the bottom element ⊥ across several mathematical frameworks; each independently locates the same structural constraint. One additional hypothesis per framework is required that is not derivable from that framework's axioms alone - these are catalogued in [Axiomatic Commitments](README.md#axiomatic-commitments) in README.md. Each layer of the proof is internally closed before any cross-framework claim is made. @@ -78,7 +78,7 @@ One companion per formal document. Plain language, diagrams, real-world examples | [ZP-G Illustrated Companion](ZP-G_Illustrated_Companion.pdf) | ZP-G | Category and functor concepts, initial object, informational singularity | | [ZP-H Illustrated Companion](ZP-H_Illustrated_Companion.pdf) | ZP-H | Four-functor convergence, T-SNAP derivation chain, Binary Snap across the four ZP frameworks | | [ZP-I Illustrated Companion](ZP-I_Illustrated_Companion.pdf) | ZP-I | 2-adic depth diagram, three closed doors + Cauchy passage, complete cycle diagram | -| [ZP-J Illustrated Companion](ZP-J_Illustrated_Companion.pdf) | ZP-J + ZP-J AFA Addendum | Quine atom diagram (⊥ = {⊥}), directed-graph (APG) view of the Quine atom (self-loop), three-way equivalence table, CC-1 restated as an equivalence and CC-2 read as the Quine-atom role, abstraction chain (ValuationStructure → AFAStructure), APG decoration uniqueness | +| [ZP-J Illustrated Companion](ZP-J_Illustrated_Companion.pdf) | ZP-J + ZP-J AFA Addendum | Quine atom diagram (⊥ = {⊥}, in ZF + AFA), directed-graph (APG) view of the Quine atom (self-loop), three-way equivalence table, CC-1 restated as an equivalence and CC-2 read as the Quine-atom role, abstraction chain (ValuationStructure → AFAStructure), APG decoration uniqueness | | [ZP-J Wheel Illustrated Companion](ZP-J_Wheel_Illustrated_Companion.pdf) | ZP-J Wheel Addendum | Wheel / meadow / collapse diagram (∞ ≠ ⊥), division by zero made total, ∞ = /0 and ⊥ = 0·/0, the wheel of fractions construction, why identifying ∞ with ⊥ leaves a one-element wheel, porthole connection | | [ZP-K Illustrated Companion](ZP-K_Illustrated_Companion.pdf) | ZP-K | Three-way equivalence diagram, computational Quine, execution argument Lean verification | | [ZP-L Illustrated Companion](ZP-L_Illustrated_Companion.pdf) | ZP-L | Ordinal tower with ε₀ snap threshold, dual convergence diagram | diff --git a/LEAN_CUSTOM_REGISTRY.md b/LEAN_CUSTOM_REGISTRY.md index a2487c5b..1e923e9e 100644 --- a/LEAN_CUSTOM_REGISTRY.md +++ b/LEAN_CUSTOM_REGISTRY.md @@ -2,7 +2,7 @@ This file documents the definitions, typeclasses and instances CARRYING A `[ZP-CUSTOM]` TAG, each recording what was replaced or extended and why the Mathlib version was insufficient. ⚠ It is not a completeness claim over the corpus: as of 2026-08-30 roughly twenty project-local `class` and `structure` declarations are untagged and therefore absent here (`StrippedBottom` in `ZeroParadox/Valuation/StrippedBottom.lean` among them), and the count check below is blind to that by construction — adding an untagged declaration leaves entry count and tag count equal. -Every entry corresponds to a `-- [ZP-CUSTOM]` inline comment in the source. ⚠⚠ **The register is NOT generated and is NOT automatically consistent with those comments.** It is maintained by hand. `tools/verify/check_invariants.py` compares the entry COUNT against the tag COUNT and nothing finer, so WORDING drift between the two copies is mechanically invisible and must be compared by eye — several entries here carry citations, dates or prior-art blocks their tag does not, and this file records one past case where the two contradicted each other outright. To list the tags (this prints them; it does not regenerate anything): +Every entry corresponds to a `-- [ZP-CUSTOM]` inline comment in the source. ⚠⚠ **The register is NOT generated and is NOT automatically consistent with those comments.** It is maintained by hand. `tools/verify/check_invariants.py` compares the entry COUNT against the tag COUNT and nothing finer, so WORDING drift between the two copies is mechanically invisible and must be compared by eye — several entries here carry citations, dates or prior-art blocks their tag does not. To list the tags (this prints them; it does not regenerate anything): ```powershell Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP-CUSTOM\]' @@ -16,7 +16,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** Replaces `SemilatticeSup` + `OrderBot` -**Reason:** Mathlib's `SemilatticeSup` + `OrderBot` would satisfy the algebra, and using them is cheap — measured 2026-08-30 at the pinned Mathlib, both classes are axiom-free and `bot_sup_eq` and `sup_assoc` cost `[propext]` only. `ZPSemilattice` states A1–A4 as FIELDS anyway, so each theorem's footprint is fixed by the axioms it consumes rather than by whichever hierarchy lemma the elaborator reached for. ⚠⚠ This is an AUDITABILITY choice, not an axiom-avoidance one: an IMPORT never changes a footprint, only USING a proof does. (`ZeroParadox/Order/Lattice.lean` line 1 imports `Mathlib.Tactic` and the class still measures clean — this entry previously claimed the opposite.) +**Reason:** Mathlib's `SemilatticeSup` + `OrderBot` would satisfy the algebra, and using them is cheap — measured 2026-08-30 at the pinned Mathlib, both classes are axiom-free and `bot_sup_eq` and `sup_assoc` cost `[propext]` only. `ZPSemilattice` states A1–A4 as FIELDS anyway, so each theorem's footprint is fixed by the axioms it consumes rather than by whichever hierarchy lemma the elaborator reached for. ⚠⚠ This is an AUDITABILITY choice, not an axiom-avoidance one: an IMPORT never changes a footprint, only USING a proof does. (`ZeroParadox/Order/Lattice.lean` line 1 imports `Mathlib.Tactic` and the class still measures clean.) --- @@ -24,7 +24,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** Mathlib's `ZFSet` uses the Axiom of Foundation, which forbids `x ∈ x` (`ZFSet.mem_irrefl`). No `ZFSet` element can satisfy `x ∈ x`, so a Quine atom is not directly available as a `ZFSet` — AFA content is still MODELLABLE over a well-founded universe, as Aczel does via decorations of accessible pointed graphs (see the `APG` entry). `AFAStructure` is the lattice-level encoding of what ZF+AFA provides set-theoretically, with `selfMem` / `quine_unique` / `bot_self_mem` as the three minimal class fields. +**Reason:** Mathlib's `ZFSet` carries Foundation (`ZFSet.mem_wf`, a theorem about `ZFSet`, not an assumed axiom), which forbids `x ∈ x` (`ZFSet.mem_irrefl`). No `ZFSet` element can satisfy `x ∈ x`, so a Quine atom is not directly available as a `ZFSet` — AFA content is still MODELLABLE over a well-founded universe, as Aczel does via decorations of accessible pointed graphs (see the `APG` entry). `AFAStructure` is the lattice-level encoding of what ZF+AFA provides set-theoretically, with `selfMem` / `quine_unique` / `bot_self_mem` as the three minimal class fields. --- @@ -32,7 +32,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** Abstracts the shared fixed-point pattern between AFA set theory (`f x = {x}`, unique fixed point = Quine atom) and 2-adic multiplication (`f x = 2x`, unique fixed point = 0). Mathlib has `Function.IsFixedPt` (a predicate on total functions) but no typeclass for "type with a self-application operation whose unique fixed point is a designated bottom element." Introducing this typeclass allows `AFAStructure`'s two LAWS (`bot_self_mem`, `quine_unique`) to become derived theorems; its `selfMem` field is DATA, supplied by `def selfMemDerived` rather than proved. +**Reason:** Abstracts the shared fixed-point pattern between AFA set theory (`f x = {x}`, unique fixed point = Quine atom) and 2-adic multiplication (`f x = 2x`, unique fixed point = 0). Mathlib has `Function.IsFixedPt` (a predicate on total functions) but no typeclass for "type with a self-application operation whose unique fixed point is a designated bottom element." Introducing this typeclass allows `AFAStructure`'s two LAWS (`bot_self_mem`, `quine_unique`) to become derived theorems; its `selfMem` field is DATA, supplied by `def selfMemDerived` rather than proved. How the pattern relates to Lawvere's fixed-point theorem is decided in `ZeroParadox/Category/Lawvere.lean`: a `ZPSemilattice` with an element other than ⊥ carries no Lawvere witness (`nontrivial_lattice_no_witness`), so in such a lattice ⊥ is a fixed point of one supplied self-map, not a Lawvere-derived one. Per chart, ⊥ of the lattice is the only occupant of the die's Quine-atom role under `selfApp` (`selfApp_quine_role_iff`, `ZeroParadox/Settheory/QuineDichotomy.lean`). --- @@ -40,7 +40,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** An interface bundling a carrier, a separation relation, an ℕ-indexed succession, the law that consecutive terms are separated, and — the field carrying the content — `sep_irrefl_on_seq`, without which the structure is exactly `Nonempty` (its own gauge says so). Mathlib has chains and apartness relations separately but no bundled "separated succession" interface. Used as the type bridge between differently-typed framework charts of one succession — the ordinal ε-chain (separation = strict order, `succession_lt_succ`) and the Hilbert state-chain (separation = orthogonality, `t5_strict_orthogonal`) — exhibited as two implementations of one shape rather than forced into an ill-typed cross-universe identity. +**Reason:** An interface bundling a carrier, a separation relation, an ℕ-indexed succession, the law that consecutive terms are separated, and — the field carrying the content — `sep_irrefl_on_seq`, without which the structure is exactly `Nonempty` (its own gauge says so). Mathlib has chains and apartness relations separately but no bundled "separated succession" interface. Used to exhibit two differently-typed framework charts — the ordinal ε-chain (separation = strict order, `succession_lt_succ`) and the Hilbert state-chain (separation = orthogonality, `t5_strict_orthogonal`) — as two implementations of one interface rather than an ill-typed cross-universe identity; that they are one succession is the framework's reading. The two implementations sit at different universe levels of the interface (`ordinalSuccession : SeparatedSuccession.{1}`), so they are not placed in one list without a lift, and no lift of either was located in the corpus as of 2026-11-03 (grep: `ZeroParadox/**/*.lean` for `ULift` and `SeparatedSuccession`; the only hit pairing them is a comment in `ZeroParadox/Multihomed/SeparatedSuccession.lean`). --- @@ -56,7 +56,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** Replaces `ValuationStructure` (this project) -**Reason:** `ValuationStructure` required `[ZPSemilattice L]` but the join operation `⊔` never appears in any of its four axioms — the constraint was an encoding artefact. `ValBridge` carries the same four axioms with `bot` as a plain field, allowing `ℤ_[2]` (for which no `ZPSemilattice` is defined) to be a formal instance. Unifies both tracks under one common ancestor. +**Reason:** `ValuationStructure` required `[ZPSemilattice L]` but the join operation `⊔` never appears in any of its four axioms — the constraint was an encoding artefact. `ValBridge` carries the same four axioms with `bot` as a plain field, allowing `ℤ_[2]` (for which no `ZPSemilattice` is registered as an instance; one is built inside an `example` of `ZeroParadox/Valuation/Scale.lean` § V) to be a formal instance. Unifies both tracks under one common ancestor. --- @@ -64,7 +64,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** Bridges `AFAStructure` (set-theoretic self-containment) with Mathlib's computability library (`Nat.Partrec.Code`). No Mathlib typeclass connects AFA and `Code`. `KleeneStructure` is built for the reading that the AFA Quine atom and the Kleene computational Quine (`∃ c, eval c = f c`) name the same structural property — this identification is the motivating commitment, not a derived theorem, and no field asserts it. +**Reason:** Bridges `AFAStructure` (set-theoretic self-containment) with Mathlib's computability library (`Nat.Partrec.Code`). A Mathlib typeclass connecting AFA and `Code` was not located in the Mathlib then pinned (`5450b53`) as of 2026-11-05 (searched over `Mathlib/`: "AFA", "anti-foundation" / "antifoundation", "non-well-founded set"; files naming both `Partrec.Code` and `ZFSet` / `PSet`; "Quine"). `KleeneStructure` was built for the reading that `botCode` is ⊥'s computational witness; no field asserts it, its identity half is retired (no code is equated with ⊥), and its running half, that ⊥ executes, is the occurrence commitment. The AFA Quine atom and the Kleene computational Quine (`IsComputationalQuine`, `ZeroParadox/Computability/Kleene.lean`) are compared through the die's Quine-atom role (§ IX), not through an identity: no single code occupies it under `evalStepMotion F` for any F (`evalStepMotion_not_selfOnlyAt`); a class of codes up to equal eval does, for computable eval-respecting maps (`codes_vs_classes`); and a self-printing universal code does under `selfPrintsStepMotion selfPrintOrDelegate` (`exists_selfPrintsStepMotion_selfOnlyAt`). --- @@ -80,7 +80,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** Mathlib has no formalization of Kolmogorov complexity. `ZPSurprisal` is an import stub for the I-KC axiom (D7'): it models conditional K-complexity as an abstract `ℕ`-valued morphism assignment. The one field (`surp_id`: identity morphisms have zero surprisal) is the only structurally usable I-KC axiom in the ZP-G theorems; the rest of K-complexity is outside Lean scope. +**Reason:** No formalization of Kolmogorov complexity was located in the Mathlib then pinned (`5450b53`) as of 2026-10-04; the search is recorded in `ZeroParadox/Information/Disjunctive.md`. Outside Mathlib, K is now in the build: the Lake dependency AlexeyMilovanov/kolmogorov-complexity-lean (commit 7e71116) defines `plainK` and `KPPlain`, and `ZeroParadox/Information/BrudnoBridge.lean` restates, for `trials` and `MLRandom`, its entropy-rate theorems (Shen, Uspensky, Vereshchagin, *Kolmogorov Complexity and Algorithmic Randomness*, AMS 2017, "SUV": Thm 148 and Problem 238, pointwise forms along Martin-Löf random tapes, and Problem 239, the almost-everywhere Bernoulli case of Brudno's theorem; "Brudno" in the declaration names is this corpus's label, which the dependency does not use) and its prefix-complexity form of the Levin–Schnorr criterion (SUV Thm 94(d), p. 151; SUV's Levin–Schnorr theorem is Thm 90, p. 146, in monotone complexity) (facebookresearch/atlas-lean also defines `K`, commit acf9c1f8, read at its source by a prior-art gate on 2026-10-31 and not a dependency). The first also defines Martin-Löf randomness (`Kolmogorov.IsMartinLofRandom`, `KolmogorovMathlib/AlgorithmicRandomness/MartinLof.lean`) and proves that criterion (`Kolmogorov.isMartinLofRandom_uniform_iff_le_KPPlain_cantorPrefix`, `KolmogorovMathlib/MonotoneComplexity/LevinSchnorr/Criteria.lean`). Its source was first read at commit 28da5139 on 2026-11-01; at the pinned commit 7e71116 both paths exist and the criterion elaborates as the dependency of `MLRandom_fair_iff_le_KPPlain`. A proof in either development that a Martin-Löf random sequence is disjunctive was not located, searched as follows. The first, at the pinned 7e71116 on 2026-11-07, by a search of its checkout under `.lake/packages`: "disjunctive" (none); "infix" (a zero-run test on finite strings in `KolmogorovMathlib/Complexity/IncompressibleStrings/SplitDecompressors.lean` and an import of `Mathlib.Data.List.Infix`, neither disjunctiveness); its `docs/SUV_COVERAGE.md` for "substring", "occurrence" and "window" (Exercise 53, on finite incompressible strings, and Problem 332, on two-channel feasibility, neither disjunctiveness); the nearest declaration is `exists_const_window_true_of_isMartinLofRandomReal` (`KolmogorovMathlib/MonotoneComplexity/Omega/OmegaBitsFromApprox.lean`), a `1` in every window of length about `c · log n`, which is not disjunctiveness. The same code search of the first at commit 28da5139 on 2026-11-01 returned no "infix" hit. The second, code search for "MartinLof" and "Martin-Löf" on 2026-11-01 (none). `ZPSurprisal` is not tied to that K. It is an import stub for the I-KC axiom (D7') that models conditional K-complexity as an abstract `ℕ`-valued morphism assignment. The one field (`surp_id`: identity morphisms have zero surprisal) is the only structurally usable I-KC axiom in the ZP-G theorems; no further K-complexity content is formalized for them. --- @@ -88,7 +88,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **Relationship to Mathlib:** No Mathlib analog -**Reason:** Mathlib's `ZFSet` uses Foundation — `x ∈ x` is forbidden, making it invalid as a decoration target for any APG with a self-loop. `DecorationUniverse` is an abstract type with `ValuationStructure` plus a `collect` operation and two axioms (`collect_singleton`, `collect_val_ge`), providing the structure the decoration-uniqueness proof consumes, without importing `ZFSet` or any axiomatic set theory. ⚠ It is NOT axiom-free, and every attribution below was isolated by changing ONE constituent rather than reasoned from the signature. `DecorationUniverse` reaches `Classical.choice` by **two INDEPENDENT routes**: its OWN `ℕ∞` numeral (the `+ 1` in `collect_val_ge`) and the inherited `[ValuationStructure U]`, whose own route is the numeral in `val_scale` (pinned by the `_VSlit`/`_VScast` pair in `ZeroParadox/Valuation/Scale.lean`). Neither alone accounts for it: with `[ValuationStructure U]` DELETED and `val`/`scale` passed as plain data the class still reports `[propext, Classical.choice, Quot.sound]`; with `[ValuationStructure U]` also deleted, respelling its own numeral as `((1 : ℕ) : ℕ∞)` makes it report no axioms at all; and respelling only that numeral with the real binders kept leaves it tainted. ⚠⚠ `decoration_unique` carries the same three **IN ITS STATEMENT**: `∀ {U} [ZPSemilattice U] [ValuationStructure U], True` already reports them, while the same with `[ZPSemilattice U]` alone reports none — so the `[ValuationStructure U]` binder is sufficient by itself and the cost is **NOT REMOVABLE BY ANY PROOF** of that theorem. Its proof additionally CALLS `Nonempty.some`, which unfolds to `fun h => Classical.choice h`, and reaches choice through `Set.ncard_pos` and `Set.ncard_lt_ncard`, but those are further routes to a cost the TYPE has already incurred. Provenance and necessity are independent axes (`ZeroParadox/AxiomProfile.lean` § 0). ⚠ "Minimum" is also unproved: the NO-GO gauge in `ZeroParadox/Settheory/APG.lean` records the class is inhabited over EVERY `ValuationStructure` carrier. +**Reason:** Mathlib's `ZFSet` carries Foundation (`ZFSet.mem_wf`) — `x ∈ x` is forbidden, making it invalid as a decoration target for any APG with a self-loop. `DecorationUniverse` is an abstract type with `ValuationStructure` plus a `collect` operation and two axioms (`collect_singleton`, `collect_val_ge`), providing the structure the decoration-uniqueness proof consumes, without importing `ZFSet` or any axiomatic set theory. ⚠ The class and its `[ValuationStructure U]` binder measure no axioms (the `PurityCheck` sections of `ZeroParadox/Settheory/APG.lean` and `ZeroParadox/Valuation/Scale.lean`). ⚠⚠ `decoration_unique` measures `[propext, Classical.choice, Quot.sound]`, and under the instances the pinned Mathlib supplies its **STATEMENT** carries them through the `[Fintype V]` binder: the statement controls are recorded in the `[ZP-CUSTOM]` line on `DecorationUniverse`, and the bin is relative to those instances (`ZeroParadox/Category/ChoiceCannotBe.lean` § III, STATEMENT-CARRIED IS INSTANCE-RELATIVE). Its proof routes are on the same line. The `[Finite V]` restatement, `decoration_unique_finite`, measures `[propext, Quot.sound]`, by way of `decoration_unique_of_val`, which binds no finiteness (§ IX of the same file). Provenance and necessity are independent axes (`ZeroParadox/AxiomProfile.lean` § 0). ⚠ "Minimum" is also unproved: the NO-GO gauge in `ZeroParadox/Settheory/APG.lean` records the class is inhabited over EVERY `ValuationStructure` carrier. **Prior art:** `decoration_unique` is the uniqueness clause of a recursive coalgebra (Adámek-Milius-Moss 2020, Def 3.2, crediting Osius) for algebras of the `collect` shape, and read from the target it is uniqueness for a corecursive algebra (Capretta-Uustalu-Vene 2009); sources and the delta are in the PRIOR ART block before `decoration_unique` in `ZeroParadox/Settheory/APG.lean`. --- @@ -108,7 +108,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP **On the comparison, precisely:** `AddValuation.of` takes four axioms; this class supplies two, omitting `map_one'` and the ultrametric inequality (separating witness: `v n = v₂ n + v₃ n` on the integers is multiplicative and sends 0 to ⊤, yet `min (v 2) (v 3) = 1` is not at most `0 = v 5`). But `AddValuation` requires only a `Ring` while this class bundles a `CommRing`, so **neither implies the other** — the weakening holds only for the valuation conditions over a fixed commutative carrier. This entry said "strictly weaker" until 2026-08-01, which asserted an ordering that does not hold. -**Corrected 2026-08-01** (this entry previously read "no Mathlib analog for the bridge", which was false). `AddValuation.of` takes **four** axioms — `map_zero'`, `map_one'`, the ultrametric `map_add_le_max'`, and `map_mul'`. This class supplies only the first and last, so it is **not** a one-axiom reduct: dropping `map_one'` is what admits the degenerate constant-`⊤` instance (§ VII-b's NO-GO gauge), and dropping the ultrametric makes the class weaker **on the valuation conditions, over a fixed commutative carrier** — `v n = v₂ n + v₃ n` on `ℤ` satisfies every field here and still fails `min (v 2) (v 3) ≤ v 5`. (That scope matters: across carriers the two are incomparable, per the paragraph above.) Adopting `AddValuation` would remove the degeneracy at the cost of also assuming the ultrametric inequality; that trade has not been made. Note also that `wvs_val 0 = ⊤` is **not** discharged by adoption — `map_zero'` is a structure field there too, so adoption relocates the assumption rather than deriving it. +`AddValuation.of` takes **four** axioms — `map_zero'`, `map_one'`, the ultrametric `map_add_le_max'`, and `map_mul'`. This class supplies only the first and last, so it is **not** a one-axiom reduct: dropping `map_one'` is what admits the degenerate constant-`⊤` instance (§ VII-b's NO-GO gauge), and dropping the ultrametric makes the class weaker **on the valuation conditions, over a fixed commutative carrier** — `v n = v₂ n + v₃ n` on `ℤ` satisfies every field here and still fails `min (v 2) (v 3) ≤ v 5`. (That scope matters: across carriers the two are incomparable, per the paragraph above.) Adopting `AddValuation` would remove the degeneracy at the cost of also assuming the ultrametric inequality; that trade has not been made. Note also that `wvs_val 0 = ⊤` is **not** discharged by adoption — `map_zero'` is a structure field there too, so adoption relocates the assumption rather than deriving it. --- @@ -140,9 +140,9 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP ### `APG` — `ZeroParadox/Settheory/APG.lean` -**Relationship to Mathlib:** Extends `Mathlib.Combinatorics.Quiver.Basic` +**Relationship to Mathlib:** Extends `Mathlib.Combinatorics.Quiver.Basic`; its `accessible` field is Mathlib's `Quiver.RootedConnected root` (the two `example`s below the structure in `ZeroParadox/Settheory/APG.lean` go each way). The bundle is kept so the root travels with the graph as data, as in Aczel's pointed graph, where `Quiver.RootedConnected` takes the root as a parameter. -**Reason:** Mathlib's `Quiver` is a bare directed graph (objects + edges) with no distinguished root. `APG` adds `root : V` and the accessibility proof (every vertex reachable from root), which is Mathlib's separate class `Quiver.RootedConnected root` (`Mathlib/Combinatorics/Quiver/Arborescence.lean`; the two `example`s below the structure in `ZeroParadox/Settheory/APG.lean`), matching Aczel's definition of Accessible Pointed Graph (1988 p. 4). ⚠ **Neither field is load-bearing for anything proved here, and no claim of necessity should be made in either direction**: `decoration_unique` binds the structure as `_G` and never uses it, so what is proved holds for every finite quiver, accessible or not — which is structurally Aczel's own generality (p. 6). Verified at the binders 2026-08-29; this entry previously claimed both fields were required, contradicting the `[ZP-CUSTOM]` comment it mirrors (`ZeroParadox/Settheory/APG.lean`, corrected 2026-08-09). +**Reason:** Mathlib's `Quiver` is a bare directed graph (objects + edges) with no distinguished root. `APG` adds `root : V` and the accessibility proof (every vertex reachable from root), which is Mathlib's separate class `Quiver.RootedConnected root` (`Mathlib/Combinatorics/Quiver/Arborescence.lean`; the two `example`s below the structure in `ZeroParadox/Settheory/APG.lean`), matching Aczel's definition of Accessible Pointed Graph (1988 p. 4). ⚠ **Neither field is load-bearing for anything proved here, and no claim of necessity should be made in either direction**: `decoration_unique` binds the structure as `_G` and never uses it, so what is proved holds for every finite quiver, accessible or not — which is structurally Aczel's own generality (p. 6). Verified at the binders 2026-08-29. --- @@ -190,7 +190,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP ### `machinePhaseAFA` — `ZeroParadox/Computability/Kleene.lean` `AFAStructure MachinePhase` -`selfMem x := x = bot` is the CIC-compatible encoding of AFA self-containment (`⊥ = {⊥}` cannot be stated in Lean's well-founded type theory). `quine_unique` and `bot_self_mem` are provable by `rfl`. This is the concrete Lean counterpart of Path 1 for ZP-E's machine model; DA-1 itself is closed given DP-2 (`da1_minimal_path`). +`selfMem x := x = bot` is the shadow of AFA self-containment on `MachinePhase`. The literal x = {x} is read in two charts: it is statable in Mathlib's well-founded `ZFSet` and refuted there, no set occupying the die's Quine-atom role (`zfset_quine_role_unoccupied`, `ZeroParadox/Settheory/Wall.lean`), while in the coalgebra chart `Cofix idPF_Coalgebra.Obj` a point occupies it (`cofix_quine_role_occupied`, `ZeroParadox/Settheory/Coalgebra.lean`; a one-point chart, `cofix_subsingleton`, so that occupancy restates its own fork). `quine_unique` and `bot_self_mem` are provable by `rfl`. This is the concrete Lean counterpart of Path 1 for ZP-E's machine model; DA-1 itself is closed given DP-2 (`da1_minimal_path`). --- @@ -204,7 +204,7 @@ Get-ChildItem ZeroParadox -Recurse -Filter *.lean | Select-String -Pattern '\[ZP ### `instZ2ValBridge` — `ZeroParadox/Valuation/ScaleBridge.lean` `ValBridge ℤ_[2]` -No `ZPSemilattice ℤ_[2]` is defined — its ring structure supplies no natural join with 0 as bottom — so it does not satisfy `ValuationStructure`, which requires one. ⚠⚠ That is a fact about what is DEFINED, never about what is POSSIBLE. ⚠ Inhabitation is the sole obstruction to `ZPSemilattice` ALONE, not to this class: `valBridge_nonempty_iff` (`ZeroParadox/Valuation/ScaleBridge.lean` § VI) settles membership exactly — infinite, or inhabited and trivial — and `Bool` is inhabited yet admits none. `ℤ_[2]` qualifies by being INFINITE; being a ring is not the obstruction either, and `ZPSemilattice ℕ` exists. What has NOT been located as of 2026-08-30 is a NATURAL join with 0 as bottom — searched over every registered `ZPSemilattice` instance in this corpus. That is an argument about naturality, not possibility. `ValBridge`'s bot-as-plain-field design makes this instance possible. All four axioms delegate directly to theorems proved in `ZeroParadox/Valuation/Scale.lean` §V (`q2Scale_bot`, `q2Val_bot`, `q2Val_unique`, `q2Val_scale`). +No `ZPSemilattice ℤ_[2]` is registered as an instance — a natural join with 0 as bottom was not located (dated search below) — so no `ValuationStructure` on ℤ_[2], which requires one, is registered either. One of each is built inside a proof and not registered (the `example` in `ZeroParadox/Valuation/Scale.lean` § V: some `ZPSemilattice ℤ_[2]` with 0 as bottom carries a `ValuationStructure`). ⚠⚠ That is a fact about what is REGISTERED, never about what is POSSIBLE. ⚠ Inhabitation is the sole obstruction to `ZPSemilattice` ALONE, not to this class: `valBridge_nonempty_iff` (`ZeroParadox/Valuation/ScaleBridge.lean` § VI) settles membership exactly — infinite, or inhabited and trivial — and `Bool` is inhabited yet admits none. `ℤ_[2]` qualifies by being INFINITE; being a ring is not the obstruction either, and `ZPSemilattice ℕ` exists. What has NOT been located as of 2026-08-30 is a NATURAL join with 0 as bottom — searched over every registered `ZPSemilattice` instance in this corpus. That is an argument about naturality, not possibility. `ValBridge`'s bot-as-plain-field design makes this instance possible. All four axioms delegate directly to theorems proved in `ZeroParadox/Valuation/Scale.lean` §V (`q2Scale_bot`, `q2Val_bot`, `q2Val_unique`, `q2Val_scale`). --- @@ -238,7 +238,7 @@ The concrete model confirming that `ValuationStructure`'s abstract axioms have a ## Further Entries -⚠ These continue the register; the sections above are not exhaustive. (A closing *"Last updated"* footer previously sat here, with further entries after it. Removed rather than re-dated: a single date on a hand-edited register goes stale silently, and each entry carries its own dates where they matter.) +⚠ These continue the register; the sections above are not exhaustive. The register carries no file-wide date; each entry carries its own dates where they matter. ### `IsLeastFixedPointFrom` — `ZeroParadox/Order/LeastFixedPoint.lean` @@ -256,7 +256,7 @@ The concrete model confirming that `ValuationStructure`'s abstract axioms have a **Relationship to Mathlib:** No Mathlib analog -**Reason:** No modal or provability logic was located in the pinned Mathlib as of 2026-08-30 — searched on three axes (Loeb/GL; Kripke and "modal logic"; provability/derivability): `Kripke` and `modal logic` return nothing, every `GL` hit is `GeneralLinearGroup`, and the `provability` hits are first-order material under `ModelTheory/` plus two incidental doc-comments under `Mathlib/Tactic/`. A minimal typeclass carrying just the Hilbert-Bernays-Loeb apparatus, so that Loeb's theorem can be presented as a face of the diagonal family. +**Reason:** No modal or provability logic was located in the pinned Mathlib as of 2026-08-30 — searched on three axes (Loeb/GL; Kripke and "modal logic"; provability/derivability): `Kripke` and `modal logic` return nothing, every `GL` hit is `GeneralLinearGroup`, and the `provability` hits are first-order material under `ModelTheory/` plus two incidental doc-comments under `Mathlib/Tactic/`. A typeclass carrying the Hilbert-Bernays-Loeb apparatus, so that Loeb's theorem can be presented as a face of the diagonal family. ### `QuineHost` — `ZeroParadox/Settheory/QuineHost.lean` @@ -311,7 +311,7 @@ The concrete model confirming that `ValuationStructure`'s abstract axioms have a **Relationship to Mathlib:** No Mathlib analog -**Reason:** The connector between a `StateTransition`-style step function `σ → Option σ` and the framework's own `natPF_NatListRegime` presentation of the polynomial functor `X ↦ 1 + X`. Mathlib carries both sides — `Computability/StateTransition.lean` and `Data/QPF/Univariate/Basic.lean` — and no map between them, because the two live in unrelated corners of the library. This is that bridge, and it is where the framework's operational face (`Occurrence.lean`) meets its coalgebraic one (`NatListRegime.lean`). The construction itself is standard: reading a partial step function as a `1 + X`-coalgebra is textbook (Jacobs, *Introduction to Coalgebra*, Ch. 2), and no novelty is claimed for it. +**Reason:** The connector between a `StateTransition`-style step function `σ → Option σ` and the framework's own `natPF_NatListRegime` presentation of the polynomial functor `X ↦ 1 + X`. Mathlib carries both sides — `Computability/StateTransition.lean` and `Data/QPF/Univariate/Basic.lean` — and a map between them was not located in the Mathlib then pinned (`5450b53`) as of 2026-10-31, searched as follows: Mathlib files mentioning `StateTransition` together with `PFunctor`, `QPF` or `Coalgebra` (none), `Option` under `Data/PFunctor` and `Data/QPF` (none), and one LeanExplore query for a step function `σ → Option σ` read as a `1 + X`-coalgebra (none). The nearest neighbour is `Computation.corec` (`Mathlib/Data/Seq/Computation.lean`), which unfolds a step function `β → α ⊕ β` coinductively into `Computation α`, not into the QPF `Cofix` of `X ↦ 1 + X`. At `α := Unit` its step shape is `stepCoalg`'s `σ → Option σ` up to Mathlib's `Equiv.optionEquivSumPUnit` (`Option σ ≃ σ ⊕ PUnit`) and a swap of the summands, so it is the same kind of unfolding with a different target. A map between `Computation Unit` and that `Cofix`, or a theorem that `Computation` is a final coalgebra, was not located in the Mathlib then pinned (`5450b53`) as of 2026-11-01, searched as follows: `Data/PFunctor` and `Data/QPF` for `Computation`, `Stream'`, `ENat` and `PartENat` (none); `Data/Seq` for `PFunctor`, `QPF`, `Cofix` and `Coalgebra` (none); the whole library for `Computation Unit` (none); two LeanExplore phrasings and theoremsearch (generic `PFunctor.M` / `QPF.Cofix` results only). This is that bridge, and it is where the framework's operational face (`Occurrence.lean`) meets its coalgebraic one (`NatListRegime.lean`). The construction itself is standard: reading a partial step function as a `1 + X`-coalgebra is textbook (Jacobs, *Introduction to Coalgebra*, Ch. 2), and no novelty is claimed for it. ### `streamPF` — `ZeroParadox/Computability/OutputSeparates.lean` @@ -331,7 +331,7 @@ The concrete model confirming that `ValuationStructure`'s abstract axioms have a **Relationship to Mathlib:** Without the `up_idem` law, the pair is a Mathlib `Endofunctor.Coalgebra` for `FunctorToTypes.prod (ofTypeFunctor Part) (ofTypeFunctor Set)`; no Mathlib analog for that law on the `Part` component -**Reason:** Mathlib carries each part separately, a partial function (`PFun`) and a relation. As a coalgebra the pair is standard: a motion on `α` is the same as a map `α → Part α × Set α` whose `Part` component satisfies `up_idem`'s law (`motionEquiv`, an `Equiv` with both round trips by `rfl`, `ZeroParadox/Die.lean` § XX), and coalgebras with their homomorphisms are Rutten, "Universal coalgebra", TCS 249 (2000), pp. 8–10 (p. 10 treats labelled transition systems; the die's `Set` half is the one-label case). What is not standard is the law: a coalgebra whose structure map has an idempotent component was not located as of 2026-10-28, searched as follows: theoremsearch in six phrasings (four at the probe, counted but not recorded verbatim; two at landing: "coalgebra for the functor partial map times powerset whose partial component is idempotent"; "transition system together with an idempotent partial retraction onto its fixed points, homomorphism preserves both"); the extracted text of Rutten 2000 for "idempot" (no hit); the text and HTML files of the project's papers library (its local copies of retrieved papers and pages, `.claude-local/papers`) for "idempotent" (two hits, nLab's closure operator and nucleus pages, neither about coalgebras); and one open-web search (2026-10-28), no hit. The phrase "idempotent coalgebra" is in use for a different object: Hogancamp, "Constructing categorical idempotents", arXiv:2002.08905, Def. 3.3 (p. 7), a complex `P` in the homotopy category `K⁻(A)` with a chain map `ε : P → 1` such that `P ⋆ Cone(ε) ≃ 0 ≃ Cone(ε) ⋆ P` (`⋆` the monoidal product there), which determines a two-step idempotent decomposition of the identity (Obs. 3.5, p. 8); it is an object idempotent under that product up to homotopy, not a structure map on states. The law is closed under homomorphic images and one-to-one sources (`idem_of_surj`, `idem_of_inj`); closure under sums, the third covariety condition (Rutten p. 7, Theorem 17.3 p. 64), is not built. For the law, the nearest prior art located is rewriting logic's split of equations from rules (Meseguer, "Generalized Rewrite Theories and Coherence Completion", *Rewriting Logic and Its Applications*, LNCS, 2018, pp. 164–183, doi 10.1007/978-3-319-99840-4_10, bibliographic record checked at Crossref 2026-10-18; Def. 8, p. 10, pages being those of the 28-page copy read, which prints no venue and is not paginated as the LNCS text; R. Diaconescu, "Non-Deterministic Algebraic Rewriting as Adjunction", arXiv:2204.12133, Defs. 11–12). There the map beside the rules is total: in Meseguer the normal form modulo the axioms B of a convergent equation system, in R. Diaconescu (Def. 11) a homomorphism into a subset it fixes. Meseguer requires coherence for the canonical system to be faithful to the rules (p. 11, with Theorem 4); the counterpart condition in R. Diaconescu is β-coherence (Def. 12, a hypothesis of his Props. 5.1 and 5.5), to which he says the Maude literature's coherence conditions bear "some similarity" while playing "a different role" (p. 26). Neither is imposed here. A structure pairing a partial map whose every value is a fixed point, not required to be total or to come from equations, with a step relation was not located as of 2026-10-17, searched for the pair as follows: theoremsearch in six vocabularies (structural, categorical, coalgebraic, rewriting, dynamics, iteration theory) and three web searches. The pair is a record: every type carries one, recorded as a NO-GO gauge beside the declaration; its premises are indexed in `ZeroParadox/DieCannotBe.lean`. +**Reason:** Mathlib carries each part separately, a partial function (`PFun`) and a relation. As a coalgebra the pair is standard: a motion on `α` is the same as a map `α → Part α × Set α` whose `Part` component satisfies `up_idem`'s law (`motionEquiv`, an `Equiv` with both round trips by `rfl`, `ZeroParadox/Die.lean` § XX), and coalgebras with their homomorphisms are Rutten, "Universal coalgebra", TCS 249 (2000), pp. 8–10 (p. 10 treats labelled transition systems; the die's `Set` half is the one-label case). What is not standard is the law: a coalgebra whose structure map has an idempotent component was not located as of 2026-10-28, searched as follows: theoremsearch in six phrasings (four at the probe, counted but not recorded verbatim; two at landing: "coalgebra for the functor partial map times powerset whose partial component is idempotent"; "transition system together with an idempotent partial retraction onto its fixed points, homomorphism preserves both"); the extracted text of Rutten 2000 for "idempot" (no hit); the text and HTML files of the project's private papers library (its local, unpublished copies of retrieved papers and pages) for "idempotent" (two hits, nLab's closure operator and nucleus pages, neither about coalgebras); and one open-web search (2026-10-28), no hit. The phrase "idempotent coalgebra" is in use for a different object: Hogancamp, "Constructing categorical idempotents", arXiv:2002.08905, Def. 3.3 (p. 7), a complex `P` in the homotopy category `K⁻(A)` with a chain map `ε : P → 1` such that `P ⋆ Cone(ε) ≃ 0 ≃ Cone(ε) ⋆ P` (`⋆` the monoidal product there), which determines a two-step idempotent decomposition of the identity (Obs. 3.5, p. 8); it is an object idempotent under that product up to homotopy, not a structure map on states. The law is closed under homomorphic images and one-to-one sources (`idem_of_surj`, `idem_of_inj`); closure under sums, the third covariety condition (Rutten p. 7, Theorem 17.3 p. 64), is not built. For the law, the nearest prior art located is rewriting logic's split of equations from rules (Meseguer, "Generalized Rewrite Theories and Coherence Completion", *Rewriting Logic and Its Applications*, LNCS, 2018, pp. 164–183, doi 10.1007/978-3-319-99840-4_10, bibliographic record checked at Crossref 2026-10-18; Def. 8, p. 10, pages being those of the 28-page copy read, which prints no venue and is not paginated as the LNCS text; R. Diaconescu, "Non-Deterministic Algebraic Rewriting as Adjunction", arXiv:2204.12133, Defs. 11–12). There the map beside the rules is total: in Meseguer the normal form modulo the axioms B of a convergent equation system, in R. Diaconescu (Def. 11) a homomorphism into a subset it fixes. Meseguer requires coherence for the canonical system to be faithful to the rules (p. 11, with Theorem 4); the counterpart condition in R. Diaconescu is β-coherence (Def. 12, a hypothesis of his Props. 5.1 and 5.5), to which he says the Maude literature's coherence conditions bear "some similarity" while playing "a different role" (p. 26). Neither is imposed here. A structure pairing a partial map whose every value is a fixed point, not required to be total or to come from equations, with a step relation was not located as of 2026-10-17, searched for the pair as follows: theoremsearch in six vocabularies (structural, categorical, coalgebraic, rewriting, dynamics, iteration theory) and three web searches. The pair is a record: every type carries one, recorded as a NO-GO gauge beside the declaration; its premises are indexed in `ZeroParadox/DieCannotBe.lean`. ### `MemGraph` — `ZeroParadox/Settheory/GraphBisim.lean` @@ -536,3 +536,33 @@ The concrete model confirming that `ValuationStructure`'s abstract axioms have a **Relationship to Mathlib:** No Mathlib analog; built from `‖·‖₊` on `ℚ_[2]` **Reason:** The extended norm on the 2-adic sphere `OnePoint ℚ_[2]`: `‖x‖₊` at a finite point and ⊤ of `ℝ≥0∞` at `∞`, so that `sNorm (rInv s) = (sNorm s)⁻¹` at every point (`sNorm_rInv`). Mathlib's extended norm `‖·‖ₑ` is defined on normed types, and `OnePoint ℚ_[2]` carries no norm. An extended norm on `OnePoint` was not located as of 2026-10-21, searched as follows: a grep of `Mathlib/Topology/Compactification/` for `enorm`, `ENNReal` and `ℝ≥0∞` (no hit). + +### `PinnedLimit` — `ZeroParadox/Die.lean` + +**Relationship to Mathlib:** No Mathlib analog for the four-clause predicate. Its standard name, for a monotone `g` and the run from ⊥ of a partial order, is closure ordinal ω: the least fixed point is reached at stage ω and at no finite stage (`pinnedLimit_iff_closure_omega`; A. Das and L. Melgaard, *Cyclic proofs for arithmetical inductive definitions*, FSCD 2023, doi:10.4230/LIPIcs.FSCD.2023.23, 23:4, Example 2.9: "we reached the (least) fixed point for the first time at stage ω. We say that ω is the closure ordinal of these operators"). Mathlib states the sup and leastness halves: Kleene's theorem `fixedPoints.lfp_eq_sSup_iterate` (`lfp = ⨆ n, f^[n] ⊥` on a complete lattice, `f` ω-Scott-continuous) with `OrderHom.isLeast_lfp`; its ω-complete-partial-order form, for an ω-continuous `f` (`α →𝒄 α`), `OmegaCompletePartialOrder.fixedPoints.ωSup_iterate_mem_fixedPoint` and `ωSup_iterate_le_fixedPoint`; on `Ordinal`, `Ordinal.nfp` with `Ordinal.iSup_iterate_eq_nfp`, `Ordinal.nfp_fp` and `Ordinal.nfp_le_fp`; and the transfinite approximants `OrdinalApprox.lfpApprox` (Cousot & Cousot 1979). The not-a-stage clause on `Ordinal` is `Ordinal.iterate_lt_nfp` (no stage reaches `nfp f a` when `f` is strictly monotone and `a < f a`), and the climbing clause at a run of a monotone `g` from `x ≤ g x` is `Monotone.monotone_iterate_of_le_map`. + +**Reason:** Tim's die role (2026-11-03): `c` is the least upper bound of the stages of `s`, is not a stage, and is the least fixed point of `g`, and the run climbs (`Monotone s`, Tim 2026-11-04), so that on a finite partial order the role has no occupant (`not_pinnedLimit_of_finite`; the `Bool` CONTROL after it shows the partial order is a premise). Stated on a preorder with no completeness hypothesis, so that `Ordinal` and `NInf` occupy it. `Ordinal` has no greatest element (`o < Order.succ o`), so it is not a complete lattice. Every ℕ-indexed family of ordinals does have a least upper bound (`isLUB_ciSup` with `Ordinal.bddAbove_of_small`), so what follows is an absence of an instance, not of the structure: an `OmegaCompletePartialOrder` instance on `Ordinal` was not located as of 2026-11-04, searched as follows: `#synth OmegaCompletePartialOrder Ordinal.{0}` fails against the pin, and a grep of `Mathlib/` for `instance.*OmegaCompletePartialOrder` and `: OmegaCompletePartialOrder` names none for `Ordinal`. The four-clause predicate was not located in the pinned Mathlib as of 2026-11-04, searched as follows: a grep of `Mathlib/` (`.lean` files), re-run 2026-11-04, for `IsLeast (Function.fixedPoints`, `IsLeast {x | f x = x}`, `closure ordinal` and `closureOrdinal`, case-insensitive (no hits), for `IsLeast .*fixedPoints` and `IsLeast .*lfp` (two hits in `Mathlib/Order/FixedPoints.lean`, `OrderHom.isLeast_lfp_le` and `OrderHom.isLeast_lfp`, complete-lattice statements of clause (c) alone), and for `IsLUB` on one line with `∉ Set.range` or followed by `Monotone` (no hit); theoremsearch in three phrasings on 2026-11-03 (Kleene's theorem, ordinal iteration of a monotone operator to its least fixed point, the successor on the one-point compactification), which returned `fixedPoints.lfp_eq_sSup_iterate` and the ordinal-stage form of the least fixed point, and on 2026-11-04 in a phrasing naming all four clauses ("monotone increasing sequence whose least upper bound is not attained and is the least fixed point of the step map"), which returned `fixedPoints.lfp_eq_sSup_iterate`, `OmegaCompletePartialOrder.fixedPoints.iterateChain`, the `OrdinalApprox` lemmas and the seeded Kleene theorem, none with the not-a-stage clause. + +### `PinnedLimitAbove` — `ZeroParadox/Die.lean` + +**Relationship to Mathlib:** Extends `PinnedLimit`. Clause (c), the least fixed point at or above a seed `x`, is `OrderHom.nextFixed` on a complete lattice when `x ≤ f x` (`OrderHom.le_nextFixed`, `OrderHom.nextFixed_le`); on an ω-complete partial order, for an ω-continuous `f` (`α →𝒄 α`), clause (c) from such a seed is `OmegaCompletePartialOrder.fixedPoints.ωSup_iterate_mem_fixedPoint` with `ωSup_iterate_le_fixedPoint` (premise `x ≤ y` for a fixed point `y`), and clause (a) there is `ωSup`'s own defining property (`OmegaCompletePartialOrder.le_ωSup`, `OmegaCompletePartialOrder.ωSup_le`); on `Ordinal`, for a normal `f`, clause (c) at the run from `x` is `Ordinal.nfp f x` (`Ordinal.nfp_fp` needs `Order.IsNormal f`, `Ordinal.nfp_le_fp` needs `Monotone f`). No Mathlib analog for the four-clause predicate. + +**Reason:** `PinnedLimit` with clause (c) relative to the first stage: `c` is the least fixed point of `g` at or above `s 0`. `PinnedLimit` asks for the least fixed point of the whole carrier, so under `α ↦ ω^α` its only occupant is ε₀ (`pinnedLimit_opow_eq_epsilon0`); the relative form is occupied by `ε_(o+1)` at the run from `succ ε_o`, for every `o` (`epsilon_succ_pinnedLimitAbove`). `PinnedLimit` implies it at every run (`PinnedLimit.toAbove`), the two agree when `s 0` is ⊥ of the carrier (`pinnedLimitAbove_iff_of_bot`), and ε₁ at the run from `succ ε₀` occupies it and not `PinnedLimit` (the CONTROL in `ZeroParadox/Order/UpAndOver.lean` § V). It carries the climbing clause too, and has no occupant on a finite partial order (`not_pinnedLimitAbove_of_finite`). The four-clause relative predicate was not located in the pinned Mathlib as of 2026-11-04, searched as follows: a grep of `Mathlib/` for `nextFixed` (all hits in `Mathlib/Order/FixedPoints.lean`, clause (c) alone) and for `IsLeast {` sets carrying a fixed-point conjunct (the regex `IsLeast \{[^}]*∧` has 11 hits, none of them about fixed points; `IsLeast \{.*(f x = x|fixedPoints|IsFixedPt)` has no hit); theoremsearch, "least upper bound of an increasing sequence that is not attained, which is the least fixed point above the starting point", which returned the seeded Kleene and Tarski–Kantorovitch theorems (the least fixed point above `x` is the supremum of the iterates from `x`), with no not-a-stage clause. + +### `IsCutPoint` — `ZeroParadox/Order/DieJoints.lean` + +**Relationship to Mathlib:** A conjunction of Mathlib's `IsLUB` and `IsGLB` at one point, for a pair of sets with the first below the second. Mathlib's `DedekindCut` (`Mathlib/Order/Completion.lean`) is the cut as an element of the Dedekind–MacNeille completion, a pair with `upperBounds A.left = A.right` and `lowerBounds A.right = A.left`, not a point of the carrier closing the cut. + +**Reason:** one point that is at once the least upper bound of the side below and the greatest lower bound of the side above. A point-level form of this conjunction was not located in the pinned Mathlib as of 2026-11-06, searched as follows: a grep of `Mathlib/` for `IsLUB` and `IsGLB` joined by `∧` on one line, in either order (no hit), and for `CutPoint`, `cutPoint` and `IsCut` (no hit); and, re-run 2026-11-06, for `IsSuccLimit` or `IsPredLimit` on one line with `IsLUB` or `IsGLB` (two hits: `Order.IsSuccLimit.isLUB_Iio` in `Mathlib/Order/SuccPred/Limit.lean`, at the canonical cut `Set.Iio a` only, and a normal-function lemma in `Mathlib/Order/IsNormal.lean`, neither a point closing an arbitrary pair). + +### `IsJoint` — `ZeroParadox/Order/DieJoints.lean` + +**Relationship to Mathlib:** Extends `IsCutPoint`. At the canonical cut `(Set.Iio x, Set.Ici x)` of a linear order, `IsJoint` is `Order.IsSuccLimit x`, and at `(Set.Iic x, Set.Ioi x)` `IsDualJoint` is `Order.IsPredLimit x` (`Mathlib/Order/SuccPred/Limit.lean`; the `example`s in `ZeroParadox/Order/DieJoints.lean`); for an arbitrary pair `(A, B)` not located in the pinned Mathlib as of 2026-11-06, searched as follows: a grep of `Mathlib/` for `IsLUB` and `IsGLB` joined by `∧` on one line, in either order (no hit), for `CutPoint`, `cutPoint` and `IsCut` (no hit), and for `IsSuccLimit` or `IsPredLimit` on one line with `IsLUB` or `IsGLB` (`Order.IsSuccLimit.isLUB_Iio`, canonical cut only, and a normal-function lemma); LeanExplore in two phrasings (returning `Order.IsSuccLimit.isLUB_Iio`, `IsLUB.isSuccLimit_of_notMem` and the `DedekindCut` API); theoremsearch in three phrasings (a cut filled from below, order-dual exchange with `formality: "formal"`, a well-order with no limit from above), returning `Order.isSuccLimit_toDual_iff`, `Order.isPredLimit_toDual_iff` and `Order.IsPredLimit.dual`. + +**Reason:** a cut point lying in the upper side, with the lower side nonempty and without a greatest element: approached from below and not reached there. The order dual turns it into `IsDualJoint` (`isJoint_toDual_iff`), and `PinnedLimit` in a partial order gives one (`PinnedLimit.isJoint`). + +### `IsDualJoint` — `ZeroParadox/Order/DieJoints.lean` + +**Relationship to Mathlib:** Extends `IsCutPoint`. At the canonical cut `(Set.Iic x, Set.Ioi x)` of a linear order, `IsDualJoint` is `Order.IsPredLimit x` and, at `(Set.Iio x, Set.Ici x)`, `IsJoint` is `Order.IsSuccLimit x` (`Mathlib/Order/SuccPred/Limit.lean`; the `example`s in `ZeroParadox/Order/DieJoints.lean`); for an arbitrary pair `(A, B)` not located in the pinned Mathlib as of 2026-11-06, searched as recorded under `IsJoint`. + +**Reason:** the mirror of `IsJoint`: a cut point lying in the lower side, with the upper side nonempty and without a least element. Stated as its own predicate so that a well-founded linear order can be shown to have none (`not_isDualJoint_of_wellFoundedLT`) without passing through the order dual. \ No newline at end of file diff --git a/MINIMAL_CORE.md b/MINIMAL_CORE.md index a59c32df..521e416f 100644 --- a/MINIMAL_CORE.md +++ b/MINIMAL_CORE.md @@ -42,11 +42,11 @@ A single capstone theorem bundles all of it: wall, floor, the collapse's irrever ## What the floor stands for -The minimal core represents the floor as bare fixed-point existence. In the full framework that fixed point is a *self-referential* object - the **Quine atom** (Quine; Aczel): the set that is its own only member, `⊥ = {⊥}`. It is one structural fact in several languages. Three of its faces are *proved* to be the same element within a single carrier, with no axioms beyond what the carrier's `AFAStructure` instance already asserts - the Quine atom (set theory), the order-bottom `⊥`, and the algebraic identity element, shown to coincide by the framework's execution theorem (T-EXEC, the three-face form `t_exec_triple_iff`). The fourth, the Kleene quine (a program that prints itself, in computability), is *joined* to them by an explicit structural commitment: the framework names the computational fixed point as filling the same role, without asserting an identity across types, rather than deriving that coincidence. +The minimal core represents the floor as bare fixed-point existence. In the full framework that fixed point is a *self-referential* object - the **Quine atom** (CC-2; Quine; Aczel), a role: a point that steps to itself and to nothing else, which in set theory is a set that is its own only member, x = {x}. Three of its faces are *proved* to be the same element within a single carrier, with no axioms beyond what the carrier's `AFAStructure` instance already asserts - the Quine atom (set theory), the order-bottom `⊥`, and the algebraic identity element, shown to coincide by the framework's execution theorem (T-EXEC, the three-face form `t_exec_triple_iff`). The fourth, the Kleene quine (a program that prints itself, in computability), is compared with them through that role, never joined by an identity: no code is equated with ⊥; with codes stepping to the codes whose output a map assigns them, no single code occupies the role (`evalStepMotion_not_selfOnlyAt`), and for a computable map respecting equal output a class of codes up to equal output does (`codes_vs_classes`). -**And that fourth commitment is the one to stop on** - it is where the whole thing starts to move. The other three faces are *static*: the order-bottom, the self-membered set, and the algebraic identity are timeless facts that simply hold, and nothing about them ever *happens*. The Kleene quine is the only one that *runs*. Anyone who writes software knows this in their hands: a program that is never run does nothing - it is inert text on disk; running it is the event, and execution is where the state changes, not the (often empty) output. ⊥ is the machine in its ground state, and the commitment is that even it must run itself. So committing that the self-contained bottom (`⊥ = {⊥}`) is the self-executing bottom is committing that **time enters the framework, as a state change**. That is the hinge, and it is the easiest thing here to walk past. It is what makes the framework dynamic at all: nothing static occurs on its own, so without that identification ⊥ would rest as a fixed point forever and the snap would never happen. +**And that fourth face is the one to stop on** - it is where the whole thing starts to move. The other three faces are *static*: the order-bottom, the self-membered set, and the algebraic identity are timeless facts that simply hold, and nothing about them ever *happens*. The Kleene quine is the only one that *runs*. Anyone who writes software knows this in their hands: a program that is never run does nothing - it is inert text on disk; running it is the event, and execution is where the state changes, not the (often empty) output. The framework once read ⊥ as the machine in its ground state, which must run itself. That reading splits in two: its identity half, that ⊥ IS some machine or code, is retired; its running half splits again: that ⊥ actually runs is the occurrence commitment, and that, if it runs, nothing outside it runs it is DA-1's Path 1 reading, which rules out an external executor and not an inert ⊥. So committing that ⊥ of the lattice actually runs is committing that **time enters the framework, as a state change**. That is the hinge, and it is the easiest thing here to walk past. It is what makes the framework dynamic at all: nothing static occurs on its own, so without that commitment ⊥ would rest as a fixed point forever and the snap would never happen. -Two honest halves, kept separate here as everywhere: the *structural* self-application fixed point is Lean-proved and axiom-free; the *literal* set-membership `⊥ = {⊥}` is a metatheoretic modeling commitment (it needs a non-well-founded set theory, ZF+AFA, to host it), a theorem nowhere. The minimal core shows the structural half; the literal half is cited to its home, not rebuilt. +Two honest halves, kept separate here as everywhere: the *structural* self-application fixed point is Lean-proved and axiom-free; the *literal* set-membership x = {x} is not asserted of the lattice's ⊥, since an equation between a lattice element and a set is ill-typed. In the die the Quine atom is a role, a point that steps to itself and to nothing else, and its occupancy is proved chart by chart: ⊥ of the lattice is the only occupant under a self-application map supplied by `AbstractSelfApp` (`selfApp_quine_role_iff`); in a `QuineAtomHost`, whose bottom is its own only member and the only such element, the host's own bottom is the only occupant with membership as the step (`quineAtomHost_quine_role_iff`); and no well-founded set occupies it (`zfset_quine_role_unoccupied`). A set equal to its own singleton needs a non-well-founded set theory, ZF+AFA, to host it, and adopting that host is the metatheoretic commitment. The minimal core shows the structural half; the set half is cited to its home, not rebuilt. ### Don't trust me - follow the reasoning @@ -55,8 +55,8 @@ Every step above is either something a machine already checked, or a commitment | The claim | What backs it | Status | |---|---|---| | Self-reference, once it closes, forces a fixed point - the engine | `lawvere` (Lawvere 1969 / Yanofsky 2003) | proved, no axioms | -| Three faces are one element *within one carrier*: the self-containing element, the order-bottom, the join-identity | `t_exec_triple_iff` | proved, no axioms - but read the bracket: the self-containment is a *field* of the `AFAStructure` instance, so it is supplied, not derived. The literal `⊥ = {⊥}` is proved nowhere | -| The fourth face, the running program, does that same job - in time | the `KleeneStructure` typeclass | **a commitment, not a theorem** | +| Three faces are one element *within one carrier*: the self-containing element, the order-bottom, the join-identity | `t_exec_triple_iff` | proved, no axioms - but read the bracket: the self-containment is a *field* of the `AFAStructure` instance, so it is supplied, not derived. The literal x = {x} is refuted in Mathlib's `ZFSet` (the `example` after `no_quine_atom` in `ZeroParadox/Settheory/Wall.lean`); `zfset_selfOnlyAt_mem_iff` makes it the die's Quine-atom role, which no set occupies (`zfset_quine_role_unoccupied`) and which is occupied in the coalgebra chart (`cofix_quine_role_occupied`), a one-point chart whose occupancy restates its own fork | +| The fourth face, the running program, does that same job - in time | the `KleeneStructure` typeclass | its identity reading is **retired**; that ⊥ runs is the occurrence commitment, not a theorem | | The machine's before- and after-states are distinct (that execution *is* the state change is part of the model, not this theorem) | `l_run` (`c₀ ≠ c₁`) | proved | **If you want to disagree, the place to do it is the commitment:** that the self-contained bottom and the self-executing program do the same job, one of them in time. Everything else above is either machine-checked or follows from it. The full claim-by-claim status, with every witness and its exact axiom footprint, is in the [Claims Ledger](CLAIMS.md). diff --git a/NOTICE b/NOTICE index 0cb4e126..c18b19ea 100644 --- a/NOTICE +++ b/NOTICE @@ -50,3 +50,10 @@ Arguments followed, not code included: ZeroParadox/Order/PataraiaFromBourbakiWitt.lean Cites the same formalization and proves its statements by a different route (the Bourbaki-Witt theorem); no TypeTopology code. + +Lake dependencies, fetched at build time, not included: + kolmogorov-complexity-lean + Copyright 2024 Alexey Milovanov. Apache License, Version 2.0. + https://github.com/AlexeyMilovanov/kolmogorov-complexity-lean, at + commit 7e7111685355e3e7925c32621788e977ca53108f; cited by + ZeroParadox/Information/BrudnoBridge.lean. Full text in its LICENSE. diff --git a/README.md b/README.md index 0b95fef0..0755a9e8 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # The Zero Paradox -*A Lean 4 formalization: one diagonal fixed point at the bottom of five mathematical fields - the snap off it a theorem, the recurrence machine-verified, the boundary proved.* +*A Lean 4 formalization: one diagonal fixed-point role at the bottom of five mathematical fields, filled field by field (in computability by Kleene codes up to equal output, not by a least element) - the snap off it a theorem, the recurrence machine-verified in the faces the Claims Ledger marks proved, the boundary proved.* -[![Minimal Core](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml) [![Complete Project](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml) [![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-ff69b4?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/timbrigham) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20060860.svg)](https://doi.org/10.5281/zenodo.20060860) +[![Minimal Core](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/minimal_core.yml) [![Complete Project](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/lean_action_ci.yml) [![Axiom Ledger (choice-free computability)](https://github.com/timbrigham/ZeroParadox/actions/workflows/axiom_ledger.yml/badge.svg)](https://github.com/timbrigham/ZeroParadox/actions/workflows/axiom_ledger.yml) [![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-ff69b4?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/timbrigham) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20060860.svg)](https://doi.org/10.5281/zenodo.20060860) Code: Apache License, Version 2.0. Documents (the PDFs, the site layouts, and every Markdown file except `CLAUDE.md` and those under `tools/` and `.claude/`): CC BY-NC-ND 4.0. Third-party material keeps its own licence. See [NOTICE](NOTICE). @@ -17,7 +17,7 @@ Code: Apache License, Version 2.0. Documents (the PDFs, the site layouts, and ev --- -**The same family of objects sits at the bottom of every framework it touches.** In order theory, p-adic valuation, category theory, computability, and set theory, each domain's bottom element ⊥ is the same *kind* of thing: a diagonal fixed point - the point that is its own image under the domain's self-map. This project machine-verifies that recurrence and proves exactly how far it reaches. +**The same family of objects sits at the bottom of every framework it touches.** In order theory, p-adic valuation, category theory, computability, and set theory, each domain's bottom element ⊥ is the same *kind* of thing: a diagonal fixed point - the point that is its own image under the domain's self-map. This project machine-verifies that recurrence in the faces the Claims Ledger marks proved, proves the computability face's fixed point up to equal output ([`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean)) without equating any code with the bottom ([`KleeneStructure`](ZeroParadox/Computability/Kleene.lean) asks only a periodicity condition, which constant codes meet), records which face is which row by row in the [Claims Ledger](CLAIMS.md), and proves exactly how far the recurrence reaches. That the classical self-reference arguments share one diagonal fixed point is prior art, not this framework's: **Lawvere (1969)** for Cantor, Russell, Gödel and Tarski, **Yanofsky (2003)** for Turing and the recursion theorem. What this framework adds is checkable and specific: @@ -29,20 +29,20 @@ That the classical self-reference arguments share one diagonal fixed point is pr ## The Result -The transition ⊥ → ε₀ - the **Binary Snap**, this project's shorthand - is a **theorem, not an axiom**. The existence of an **atom** above ⊥ of the discrete state chart (a state with nothing between it and ⊥; c₁ in `MachinePhase`) - what the framework calls a *first atomic state* - does **not** follow from A4 alone: a join-semilattice with a least element can be densely ordered and atomless, and a densely ordered set has no first step anywhere (Mathlib's `denselyOrdered_iff_forall_not_covBy`, restated as [`axb1_fails_everywhere_iff_dense`](ZeroParadox/Reals/OrderedField.lean)), so ℝ≥0 under `max`, whose least element is 0, has none. What supplies the atom is the framework's discrete state model - the states are atomic, not a continuum (AX-B1) - with A4 (∀ x, ⊥ ∨ x = x) giving only the join structure of the transition. The assembly is machine-verified in Lean 4 (`t_snap_derived`). The framework adds no *snap-specific* axiom (AX-1 is retired: 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, that instantiation occurs, together with DA-1, closed given DP-2), and `t_snap_derived` - the snap from ⊥ of `MachinePhase` to its atom c₁ - depends on **no Lean axioms at all** (`#print axioms` is empty): not the Axiom of Choice, not even propositional extensionality (the discreteness is carried by the finite state type and checked constructively, not invoked as a classical axiom). Identifying that first step with the *proof-theoretic ordinal* ε₀ is a separate step, and that is where `Classical.choice` enters - as it does at many of the places the framework builds on Mathlib's classically-built analysis, order, and computability libraries (p-adic topology, Hilbert space, ordinals), though not at all of them, and never in the core snap itself. Not all of them: [`IsKleeneFixedPoint`](ZeroParadox/Computability/Kleene.lean), whose type is `eval c = f c` over Mathlib's `Nat.Partrec.Code`, measures axiom-free, and ZP-K Section IV holds a dated measurement table of which declarations carry it - it is meant to be re-run, not cited. Some of the choice is the framework's own; [`ChoiceCannotBe.lean`](ZeroParadox/Category/ChoiceCannotBe.lean) § IV collects cases among them whose principles reduce to a taboo, with those reductions. The category-theory face is one example: its choice is a bare `classical` in [`Lawvere.lean`](ZeroParadox/Category/Lawvere.lean), and it is *essential* rather than incidental, given the premise stated in § IV - a separate axis from where the choice comes from - since `wem_of_fixedPointFree` reduces the general fixed-point-free principle to weak excluded middle. The honest contrast, showing exactly where choice appears, is a checkable artifact: [AxiomProfile.lean](ZeroParadox/AxiomProfile.lean). +The transition ⊥ → ε₀ - the **Binary Snap**, this project's shorthand - is a **theorem, not an axiom**; read in the discrete state chart it runs from ⊥ of `MachinePhase` (c₀) to the first state above it (c₁), which that chart names ε₀. The existence of an **atom** above ⊥ of the discrete state chart (a state with nothing between it and ⊥; c₁ in `MachinePhase`) - what the framework formerly called a *first atomic state* (a retired term) - does **not** follow from A4 alone: a join-semilattice with a least element can be densely ordered and atomless, and a densely ordered set has no first step anywhere (Mathlib's `denselyOrdered_iff_forall_not_covBy`, restated as [`axb1_fails_everywhere_iff_dense`](ZeroParadox/Reals/OrderedField.lean)), so ℝ≥0 under `max`, densely ordered with least element 0, has no first step and hence no atom (an atom is exactly a first step out of a least element: Mathlib's `bot_covBy_iff`). What supplies the atom is the framework's discrete state model - the states are atomic, not a continuum (AX-B1) - with A4 (∀ x, ⊥ ∨ x = x) giving only the join structure of the transition. The assembly is machine-verified in Lean 4 (`t_snap_derived`). The framework adds no *snap-specific* axiom (AX-1 is retired: 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, that instantiation occurs, together with DA-1, closed given DP-2), and `t_snap_derived` - the snap from ⊥ of `MachinePhase` to its atom c₁, whose cover is stated in [`t_snap_derived_cover`](ZeroParadox/Order/Snap.lean) - depends on **no Lean axioms at all** (`#print axioms` is empty): not the Axiom of Choice, not even propositional extensionality (the discreteness is carried by the finite state type and checked constructively, not invoked as a classical axiom). Linking the snap's step, c₀ to c₁ in `MachinePhase`, to the *proof-theoretic ordinal* ε₀ through the threshold map (`c1_epsilon_zero_identification`) is a separate step, and that is where `Classical.choice` enters - as it does at many of the places the framework builds on Mathlib's classically-built analysis, order, and computability libraries (p-adic topology, Hilbert space, ordinals), though not at all of them, and never in the core snap itself. Not all of them: [`IsKleeneFixedPoint`](ZeroParadox/Computability/Kleene.lean), whose type is `eval c = f c` over Mathlib's `Nat.Partrec.Code`, measures axiom-free, and ZP-K Section IV holds a dated measurement table of which declarations carry it - it is meant to be re-run, not cited. Some of the choice is the framework's own; [`ChoiceCannotBe.lean`](ZeroParadox/Category/ChoiceCannotBe.lean) § IV collects cases among them whose principles reduce to a taboo, with those reductions. The category-theory face is one example: its choice is a bare `classical` in [`Lawvere.lean`](ZeroParadox/Category/Lawvere.lean), and it is *essential* rather than incidental, given the premise stated in § IV - a separate axis from where the choice comes from - since `wem_of_fixedPointFree` reduces the general fixed-point-free principle to weak excluded middle. The honest contrast, showing exactly where choice appears, is a checkable artifact: [AxiomProfile.lean](ZeroParadox/AxiomProfile.lean). **The transition's destination and form are forced - each by a mechanism with its own requirement and its own Lean witness. That it OCCURS follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2) (see the closing note below):** - **Information** - ⊥ is the *degenerate* distribution (a point mass, zero information); a non-degenerate state provably needs at least two outcomes, so the minimal non-⊥ structure is binary, with no "half state." *Requires:* states are probability distributions. *Witnesses:* [`pmf_subsingleton_isPure`](ZeroParadox/Information/Surprisal.lean) (fewer than two outcomes forces the point mass), [`binaryState_exhaustive`](ZeroParadox/Information/Surprisal.lean) (no third state, axiom-free); the two point masses are exactly 1 bit apart ([`t1b_jsd`](ZeroParadox/Information/Surprisal.lean)). - **Order** - given two distinct states, the transition from ⊥ to an atom above it (c₀ → c₁ in `MachinePhase`) is a join. *Requires:* the bottom-element axiom A4. *Witness:* [`t_snap_derived`](ZeroParadox/Order/Snap.lean). -- **Self-execution** - nothing external can execute ⊥ of a ZPSemilattice, the occupant of the framework's ⊥ role, so if it executes at all, the executor is that ⊥ itself, and execution is a state change off ⊥ of `MachinePhase`. That rules out an external executor, not an inert ⊥. *Requires:* that ⊥ admits no external interpreter; that the configuration reaching the incompressibility threshold P₀ is executing is the occurrence commitment, not a consequence, and DA-1 consumes it and does not supply it. *Witness (structural half only):* [`da1_closed_concrete`](ZeroParadox/Computability/Kleene.lean) proves `IsQuineAtom (bot : MachinePhase)` - it mentions no code and no execution. +- **Self-execution** - nothing external can execute ⊥ of a ZPSemilattice, the occupant of the framework's ⊥ role, so if it executes at all, the executor is that ⊥ itself; with `MachinePhase` read as a ZPSemilattice through `machinePhaseZPS` ([`Snap.lean`](ZeroParadox/Order/Snap.lean)), execution is a state change off its ⊥, c₀. That rules out an external executor, not an inert ⊥. *Requires:* that ⊥ admits no external interpreter; that the configuration reaching the incompressibility threshold P₀ is executing is the occurrence commitment, not a consequence, and DA-1 consumes it and does not supply it. *Witness (structural half only):* [`da1_closed_concrete`](ZeroParadox/Computability/Kleene.lean) proves `IsQuineAtom (bot : MachinePhase)` - it mentions no code and no execution. - **Incompressibility** - the surprisal I(n) = n at ball-hierarchy depth n is unbounded: every bound M is exceeded at some depth. *Requires:* the information measure. *Witness:* [`l_inf`](ZeroParadox/Information/Surprisal.lean). *Reading:* ZP-C models its state c₀ as corresponding to the ⊥ of its configuration semilattice (CC-2, a modelling commitment), and reads c₀ as corresponding to the limit point 0 of the binary ball hierarchy at infinite depth (a reading across carriers, MC-1), and read there c₀ has no finite description; l_inf itself is a statement about depth n. This is what motivates the self-execution reading - a state without a finite description cannot be held by any external interpreter - and the step from unbounded surprisal to executing is a bridge principle of its own, which the framework does not adopt and which is not the occurrence commitment (ZP-E, DA-1 Path 2). -These force *different aspects*, not the same proposition four times: incompressibility is what motivates the self-execution reading; the information mechanism fixes its **destination** as the minimal binary state; and A4 gives it a **join** form. Together they constrain every aspect of ⊥ → first-atomic-state except that it fires, which follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). The single substantive commitment underneath is that states are **discrete** - a state exists or it does not, a distribution over atomic outcomes, not a continuum - which is exactly what the reals lack, and why the snap provably fails there ([`f_snap_impossible`](ZeroParadox/Reals/OrderedField.lean)). +These force *different aspects*, not the same proposition four times: incompressibility is what motivates the self-execution reading; the information mechanism fixes its **destination** as the minimal binary state; and A4 gives it a **join** form. Together they constrain every aspect of ⊥ → the atom above it except that it fires, which follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). The single substantive commitment underneath is that states are **discrete** - a state exists or it does not, a distribution over atomic outcomes, not a continuum - which is exactly what the reals lack, and why the snap provably fails there ([`f_snap_impossible`](ZeroParadox/Reals/OrderedField.lean)). -The bottoms across the layers form one characterized **family** (MC-1): per-domain membership is proved (the categorical criterion is [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean)), while the reading that they are numerically *one object* is 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). ε₀ is chosen as the proof-theoretic ordinal of PA - a cited classical fact the framework invokes, not one it re-proves, and it takes more than one result: transfinite induction up to ε₀ suffices to prove the consistency of PA (Gentzen, Math. Annalen 112 (1936) 493-565); 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. 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. Its role as the exact snap threshold is machine-verified. The type-level identity across types is ill-typed, not open: 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`](ZeroParadox/Ordinal/CnfBridge.lean) co-witnesses the two limits instead), 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`](ZeroParadox/Ordinal/Gentzen.lean); [`snapEmbed`](ZeroParadox/Ordinal/Incompleteness.lean)). The full labelled account is in [Axiomatic Commitments](#axiomatic-commitments). +The bottoms across the layers form one characterized **family** (MC-1): per-domain membership is proved, differently by category (a zero object, initial and terminal, in `ModuleCat ℂ`; initial and not terminal in `KleisliCat PMF`; in `TopCat` terminal, since it has one point, and not initial, and separately the limit cone [`floorConeIsLimit`](ZeroParadox/Order/PadicLimitCone.lean); the three full positions are stated together in [`floor_positions_full`](ZeroParadox/Category/TreeSeam.lean) (a zero object; initial and not terminal; terminal and not initial); [`mc1_correspondence`](ZeroParadox/Multihomed/MC1Bridge.lean) bundles the two initial-object fields, the no-return field and the set equation `fB_bottom_is_limit`), while the reading that they are numerically *one object* is 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). ε₀ is chosen as the proof-theoretic ordinal of PA - a cited classical fact the framework invokes, not one it re-proves, and it takes more than one result: transfinite induction up to ε₀ suffices to prove the consistency of PA (Gentzen, Math. Annalen 112 (1936) 493-565); 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. 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. Its role as the exact snap threshold is machine-verified. The type-level identity across types is ill-typed, not open: 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`](ZeroParadox/Ordinal/CnfBridge.lean) co-witnesses ε₀'s least-fixed-point face with the images' limit 0 in ℤ_[2] instead; its statement line is in [`Epsilon0CannotBe.lean`](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`](ZeroParadox/Ordinal/Gentzen.lean); [`snapEmbed`](ZeroParadox/Ordinal/Incompleteness.lean)). The full labelled account is in [Axiomatic Commitments](#axiomatic-commitments). -The snap is also **irreversible**: the p-adic topology layer (ZP-B) establishes, Lean-verified, that there is no continuous path from any nonzero element of Q₂ back to 0 ([`c3_irreversible`](ZeroParadox/Valuation/Padic.lean)) - the total disconnectedness of Q₂ makes any return path discontinuous. This is a claim about the carrier rather than about the snap alone - it holds in Q₂ and fails in ℝ, which is connected (`Statement:` CARRIER, this project's label for a property that holds in one carrier and fails in another). +The snap is also **irreversible**, and the one-way reading belongs to the order and to the categorical face: in any ZPSemilattice, for x ≤ y with x ≠ y no join from y lands back on x ([`t_snap_irreversible`](ZeroParadox/Order/Snap.lean)); in the probability functor no later stage `fC_functor.obj n`, n > 0, maps back to the floor `fC_functor.obj 0` ([`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean)), while the floor, an initial object ([`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean)), maps out to every stage. The p-adic topology layer (ZP-B) adds a carrier fact, Lean-verified: there is no continuous path from any nonzero element of Q₂ back to 0 ([`c3_irreversible`](ZeroParadox/Valuation/Padic.lean)) - the total disconnectedness of Q₂ makes any return path discontinuous. That fact has no direction: the `example` restating `c3_irreversible` for any two distinct endpoints x and y (in ZeroParadox/Valuation/Padic.lean, after `c3_irreversible`) rules out every path between two distinct points of Q₂, either way round, so the topology supplies no one-way arrow of its own. This is a claim about the carrier rather than about the snap alone - it holds in Q₂ and fails in ℝ, which is connected (`Statement:` CARRIER, this project's label for a property that holds in one carrier and fails in another). **Scope of the claim.** The internal coherence is formally established - the central theorem and the supporting layer theorems are verified in Lean 4 given the explicitly stated commitments. Whether those commitments are the right ones, and whether the formalism faithfully tracks the structural notion of zero it sets out to model, are questions Lean cannot answer from inside; they are what this repository invites external review on. The framework has been developed in public from the start for exactly this reason. @@ -53,9 +53,8 @@ The snap is also **irreversible**: the p-adic topology layer (ZP-B) establishes, → **the occurrence commitment** (the configuration reaching P₀ is a running machine's current configuration, not an inert string, ZP-E; a commitment, not derived) → **D7** (machine configuration definition, ZP-C; given the occurrence commitment, a running machine has left c₀ for c₁) → **DA-1** (DP-2 and `da1_minimal_path` show c₀ and c₁ distinct while returning the same output value, ZP-E; closed given DP-2; it consumes the occurrence commitment and does not supply it) -→ **L-RUN** (execution is a state change off ⊥ of `MachinePhase`, c₀ ≠ c₁, ZP-C) -→ **TQ-IH** (c₁ ≠ c₀: the same fact read from c₁, ZP-C) -→ **ZP-A D2** (a state change off ⊥ of `MachinePhase` is a join - the Binary Snap) +→ **L-RUN / TQ-IH** (c₀ ≠ c₁ in `MachinePhase`, ZP-C; TQ-IH is the same disequality read from c₁, not a further step) +→ **ZP-A D2** (in any ZPSemilattice a state change off its ⊥ is a join; here `MachinePhase` under `machinePhaseZPS`, whose ⊥ is c₀ - the Binary Snap) → **T-SNAP** (Binary Snap derived: A4, the standard bottom element axiom, gives its join, AX-B1 supplies the atom, and `t_snap_given` takes the start at ⊥ and occurrence at the first step as hypotheses; AX-1 is retired: the snap's shape is this theorem, and that the snap occurs is stated separately: it follows from the occurrence commitment, that instantiation occurs, together with DA-1, closed given DP-2) @@ -74,41 +73,41 @@ Machine-checked proofs of the formal documents using Lean 4 + Mathlib, with sour ### Reproducing the Verification -An independent re-check is three commands: `git clone https://github.com/timbrigham/ZeroParadox && cd ZeroParadox && lake build`. `elan` reads the pinned compiler from [lean-toolchain](lean-toolchain) (`leanprover/lean4:v4.30.0-rc2`) automatically, and Mathlib is fetched as a pinned dependency via `lake-manifest.json`; a clean `lake build` means every theorem in `ZeroParadox/` type-checks against the Lean kernel. To inspect the core axiom profile directly: `lake env lean ZeroParadox/AxiomProfile.lean`. +An independent re-check is three commands: `git clone https://github.com/timbrigham/ZeroParadox && cd ZeroParadox && lake build`. `elan` reads the pinned compiler from [lean-toolchain](lean-toolchain) (`leanprover/lean4:v4.35.0`) automatically, and Mathlib is fetched as a pinned dependency via `lake-manifest.json`; a clean `lake build` means every theorem in `ZeroParadox/` type-checks against the Lean kernel. To inspect the core axiom profile directly: `lake env lean ZeroParadox/AxiomProfile.lean`. ### Formal Framework Documents | File | Document | Version | Focus | |------|----------|---------|-------| -| [Lattice Algebra](ZP-A_Lattice_Algebra.pdf) | ZP-A | v1.33 | The lattice-algebra foundation: the bottom element ⊥ and the order it induces. | -| [p-adic Topology](ZP-B_pAdic_Topology.pdf) | ZP-B | v1.30 | The 2-adic topology: why p = 2, and why departure from ⊥ is irreversible. | -| [Information Theory](ZP-C_Information_Theory.pdf) | ZP-C | v1.26 | The information layer: state distributions, 1-bit cost, unbounded surprisal at ⊥. | -| [State Layer](ZP-D_State_Layer.pdf) | ZP-D | v1.19 | The Hilbert-space layer: the snap as an orthogonal shift between states. | -| [Bridge Document](ZP-E_Bridge_Document.pdf) | ZP-E | v3.61 | The bridge: the snap assembled as a derived theorem across the layers. | -| [The Counterexamples](ZP-F_The_Counterexamples.pdf) | ZP-F | v1.20 | The counterexamples: ordered fields (ℝ, ℚ) where the snap cannot occur. | -| [Category Theory](ZP-G_Category_Theory.pdf) | ZP-G | v1.23 | The categorical layer: ⊥ as initial object, the informational singularity. | -| [Categorical Bridge](ZP-H_Categorical_Bridge.pdf) | ZP-H | v1.27 | The categorical bridge: the snap holding under all four domain functors. | -| [Native Categories Addendum](ZP-H_Native_Categories_Addendum.pdf) | ZP-H Native Categories Addendum | v1.7 | The snap floor realized inside each framework's native Mathlib category (TopCat, ModuleCat ℂ, KleisliCat PMF). Reads after ZP-H. | -| [Inside Zero](ZP-I_Inside_Zero.pdf) | ZP-I | v1.28 | Inside zero: each nowhere-zero 2-adic sequence whose valuation equals a depth index in ℕ that climbs at every step converges to 0 in the 2-adics; reading that limit as an occupant of the ⊥ role, and then as a successor ⊥′, are two further commitments. | -| [Self-Reference](ZP-J_Self_Reference.pdf) | ZP-J | v2.13 | Self-reference: ⊥ as the Quine atom, and the AFA structure it requires. | -| [AFA Addendum](ZP-J_AFA_Addendum.pdf) | ZP-J AFA Addendum | v1.19 | Decoration uniqueness for finite graphs from the valuation structure alone. Reads after ZP-J. | -| [Wheel Addendum](ZP-J_Wheel_Addendum.pdf) | ZP-J Wheel Addendum | v1.8 | The wheel of fractions as a wheel: division by zero made total. Reads after ZP-J. | -| [Keystone Addendum](ZP-J_Keystone_Addendum.pdf) | ZP-J Keystone Addendum | v1.26 | The diagonal-fixed-point keystone: the Lawvere face-split (Set face machine-checked, computability face cited) and the snap as a well-foundedness boundary crossing. Reads after ZP-J. | -| [Computational Grounding](ZP-K_Computational_Grounding.pdf) | ZP-K | v1.27 | Computational grounding: the bottom's structural self-containment, with the computational reading carried as a commitment. | -| [Incomputability Convergence](ZP-L_Incomputability_Convergence.pdf) | ZP-L | v1.30 | ε₀ as the exact ordinal threshold the snap is keyed to. (That the snap occurs follows from the occurrence commitment together with DA-1, closed given DP-2.) | -| [Kleene-Ordinal Bridge](ZP-M_Kleene_Ordinal_Bridge.pdf) | ZP-M | v1.13 | The bridge between the Kleene quine and the ε₀ fixed point. | -| [The Constructive Snap](ZP-N_The_Constructive_Snap.pdf) | ZP-N | v2.5 | The constructive companion to ZP-L: the ε₀ snap from below on ordinal notations, choice-free (propext only). Locates ZP-L's classical dependency in Mathlib's order instance, and proves that comparing arbitrary well-orders implies excluded middle (a known taboo, cited to Kraus/Nordvall Forsberg/Xu), so comparability has no choice-free proof given the premise stated in [ChoiceCannotBe.lean](ZeroParadox/Category/ChoiceCannotBe.lean) § IV. Adds a carrier of notations denoting the ordinals up to ε₀, whose crossing into Ordinal is one named map with a measured price. ZP-L's ε₀ results, as stated, carry Classical.choice in their statements (measured 2026-10-08); the ascent below ε₀ is restated choice-free on ordinal notations, and for ε₀ itself a choice-free Lean restatement of the fixed-point equation and its uniqueness on E0Note sets existence by definition, while a choice-free derivation in Lean of the fixed point on a well-founded carrier, leastness included, was not located as of 2026-10-08 ([SnapNucleus.md](ZeroParadox/Ordinal/SnapNucleus.md) § Axiom footprint). | -| [The Fixed-Point Fork](ZP-P_The_Fixed_Point_Fork.pdf) | ZP-P | v1.26 | Synthesis layer: the least-vs-greatest fixed-point fork, generalizing the Foundation/AFA orthogonal-contact-point claim across frameworks. | -| [The Frame-Change](ZP-Q_The_Frame_Change.pdf) | ZP-Q | v1.13 | Synthesis layer (ZP-P sequel): the bottom read as both 0 and ∞, and what that does not settle. The order-theoretic frame-flip universal is proved; the categorical Lawvere universal meets a proven Cantor wall; the cross-domain identity is a type boundary. | -| [Cross-Category Fixed Point](ZP-R_Cross_Category_Fixed_Point.pdf) | ZP-R | v1.20 | Synthesis / placement layer. The framework's self-application fixed point is a role filled per face: in the fork / AFA face by ⊥ of the ZPSemilattice, a fixed point and the only one by the class fields fixed_bot and unique_fp of AbstractSelfApp (selfApp_pinnable), not produced by Lawvere's engine; in the computability face by a Kleene code, with fixed points up to eval (Rogers' form), infinitely many for each partial computable F (fixed_points_infinite). It asks where the role is filled by a Lawvere fixed point across three faces: refuted in Set on every carrier except a one-element one (Cantor), 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 first finite stage of Soto-Andrade and Varela's two-element example, 1984, §2.5, pp. 15–16; the case Y = 2 of Trimble's Cantor theorem for posets; Bergman 2008, Cor. 7), and realized in the computability face (Rogers/Kleene, the crossing; that Rogers' general form is a Lawvere instance is cited). F1 states what is measured per face; 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. Outside the PDF, the narrower case of computable eval-respecting maps is checked in Lean (hasWitnessRel_evalClass with fixedPoint_of_witnessRel, ZeroParadox/Category/DiagonalWitness.lean). | -| [Diagonal Family Addendum](ZP-R_Diagonal_Family_Addendum.pdf) | ZP-R Diagonal Family Addendum | v1.18 | The faces formalized here of the self-referential relationship, by the μ/ν fork: wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (Quine atom, Kleene quine, Löb / Gödel 2nd, Rice) where it does, Löb / Gödel 2nd from a hypothesized Löb diagonal; Gödel's first incompleteness sits between the columns and is not formalized here. Lean-witnessed except the Gödel-first row. The self-application fixed point is a role filled per face: in the fork / AFA face by ⊥ of the ZPSemilattice, from the class fields (t_exec); in the computability face by a Kleene code, computability_face_fixedPoint giving every computable self-map on codes a fixed point up to eval (Rogers' form). Reads after ZP-R. | -| [The Choice-Free Core](ZP_Choice_Free_Core_Addendum.pdf) | Choice-Free Core | v1.13 | Framework-wide note: the central results are choice-free (T-SNAP is axiom-free); the framework is not choice-free as a whole - most of its choice is inherited from Mathlib in the analytic realizations, and some is the framework's own. [ChoiceCannotBe.lean](ZeroParadox/Category/ChoiceCannotBe.lean) § IV collects cases, of either provenance, where a general statement proved with choice implies excluded middle or its weak form by a choice-free reduction, and ZeroParadox/AxiomProfile.lean § 0 prints their footprints; for the fixed-point-free case this concerns the general statement over arbitrary types: restricted to carriers with decidable equality it is `[propext]` (fixedPointFree_of_nontrivial_decidable). See CLAIMS.md. Anchored on AxiomProfile.lean. | +| [Lattice Algebra](ZP-A_Lattice_Algebra.pdf) | ZP-A | v1.37 | The lattice-algebra foundation: the bottom element ⊥ and the order it induces. | +| [p-adic Topology](ZP-B_pAdic_Topology.pdf) | ZP-B | v1.33 | The 2-adic topology: why p = 2, and why no continuous path in Q₂ joins two distinct points, so none returns from a nonzero point to 0 of Q₂. | +| [Information Theory](ZP-C_Information_Theory.pdf) | ZP-C | v1.39 | The information layer: state distributions, 1-bit cost, surprisal unbounded in depth, and the 2-adic additive valuation ⊤ at the point to which c₀, ⊥ of MachinePhase, corresponds. | +| [State Layer](ZP-D_State_Layer.pdf) | ZP-D | v1.21 | The Hilbert-space layer: the snap as an orthogonal shift between states. | +| [Bridge Document](ZP-E_Bridge_Document.pdf) | ZP-E | v3.80 | The bridge: the snap assembled as a derived theorem across the layers. | +| [The Counterexamples](ZP-F_The_Counterexamples.pdf) | ZP-F | v1.26 | The counterexamples: ordered fields (ℝ, ℚ), where 0 has no first step above it. | +| [Category Theory](ZP-G_Category_Theory.pdf) | ZP-G | v1.27 | The categorical layer: ⊥ as initial object, the informational singularity. | +| [Categorical Bridge](ZP-H_Categorical_Bridge.pdf) | ZP-H | v1.35 | The categorical bridge: the snap holding under all four domain functors. | +| [Native Categories Addendum](ZP-H_Native_Categories_Addendum.pdf) | ZP-H Native Categories Addendum | v1.14 | The snap floor realized inside each framework's native Mathlib category (TopCat, ModuleCat ℂ, KleisliCat PMF). Reads after ZP-H. | +| [Inside Zero](ZP-I_Inside_Zero.pdf) | ZP-I | v1.44 | Inside zero: each nowhere-zero 2-adic sequence whose valuation equals a depth index in ℕ that climbs at every step converges to 0 in the 2-adics; reading that limit as an occupant of the ⊥ role takes a choice of join, and reading it as a successor ⊥′ is a commitment. | +| [Self-Reference](ZP-J_Self_Reference.pdf) | ZP-J | v2.19 | Self-reference: ⊥ as the Quine atom, and the AFA structure it requires. | +| [AFA Addendum](ZP-J_AFA_Addendum.pdf) | ZP-J AFA Addendum | v1.22 | Decoration uniqueness for every graph, finite or not, from the valuation structure and collect's depth bound. Reads after ZP-J. | +| [Wheel Addendum](ZP-J_Wheel_Addendum.pdf) | ZP-J Wheel Addendum | v1.11 | The wheel of fractions as a wheel: division by zero made total. Reads after ZP-J. | +| [Keystone Addendum](ZP-J_Keystone_Addendum.pdf) | ZP-J Keystone Addendum | v1.31 | The diagonal-fixed-point keystone: the Lawvere face-split (Set face machine-checked, computability face cited) and the snap as a well-foundedness boundary crossing. Reads after ZP-J. | +| [Computational Grounding](ZP-K_Computational_Grounding.pdf) | ZP-K | v1.38 | Computational grounding: the bottom's structural self-containment, with the computational reading carried as a commitment. | +| [Incomputability Convergence](ZP-L_Incomputability_Convergence.pdf) | ZP-L | v1.38 | ε₀ as the exact ordinal threshold the snap is keyed to. (That the snap occurs follows from the occurrence commitment together with DA-1, closed given DP-2.) | +| [Kleene-Ordinal Bridge](ZP-M_Kleene_Ordinal_Bridge.pdf) | ZP-M | v1.20 | The bridge between the Kleene quine and the ε₀ fixed point. | +| [The Constructive Snap](ZP-N_The_Constructive_Snap.pdf) | ZP-N | v2.9 | The constructive companion to ZP-L: the ε₀ snap from below on ordinal notations, choice-free (propext only). Locates ZP-L's classical dependency in Mathlib's order instance, and proves that comparing arbitrary well-orders implies excluded middle (a known taboo, cited to Kraus/Nordvall Forsberg/Xu), so comparability has no choice-free proof given the premise stated in [ChoiceCannotBe.lean](ZeroParadox/Category/ChoiceCannotBe.lean) § IV. Adds a carrier of notations denoting the ordinals up to ε₀, whose crossing into Ordinal is one named map with a measured price. ZP-L's ε₀ results, as stated, carry Classical.choice in their statements (measured 2026-10-08); the ascent below ε₀ is restated choice-free on ordinal notations, and for ε₀ itself a choice-free Lean restatement of the fixed-point equation and its uniqueness on E0Note sets existence by definition, while a choice-free derivation in Lean of the fixed point on a well-founded carrier whose statements are choice-free, leastness included, was not located as of 2026-10-13 ([SnapNucleus.md](ZeroParadox/Ordinal/SnapNucleus.md) § Axiom footprint). | +| [The Fixed-Point Fork](ZP-P_The_Fixed_Point_Fork.pdf) | ZP-P | v1.37 | Synthesis layer: the least-vs-greatest fixed-point fork, generalizing the Foundation/AFA orthogonal-contact-point claim across frameworks. | +| [The Frame-Change](ZP-Q_The_Frame_Change.pdf) | ZP-Q | v1.25 | Synthesis layer (ZP-P sequel): the bottom read as both 0 and ∞ (`Statement:` COINCIDENCE, a chart claim and not a point identity; the hub entry under Reading Order names the witness per chart), and what that does not settle. The order-theoretic frame-flip universal is proved; the categorical Lawvere universal meets a proven Cantor wall; the cross-domain identity is a type boundary. | +| [Cross-Category Fixed Point](ZP-R_Cross_Category_Fixed_Point.pdf) | ZP-R | v1.27 | Synthesis / placement layer. The framework's self-application fixed point is a role filled per face: in the fork / AFA face by ⊥ of the ZPSemilattice, a fixed point and the only one by the class fields fixed_bot and unique_fp of AbstractSelfApp (selfApp_pinnable), not produced by Lawvere's engine; in the computability face by a Kleene code, with fixed points up to eval (Rogers' form), infinitely many for each partial computable F (fixed_points_infinite). It asks where the role is filled by a Lawvere fixed point across three faces: refuted in Set on every carrier except a one-element one (Cantor), 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 first finite stage of Soto-Andrade and 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 realized in the computability face (Rogers/Kleene, the crossing; that Rogers' general form is a Lawvere instance is cited). F1 states what is measured per face; 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. Outside the PDF, the narrower case of computable eval-respecting maps is checked in Lean (hasWitnessRel_evalClass with fixedPoint_of_witnessRel, ZeroParadox/Category/DiagonalWitness.lean). | +| [Diagonal Family Addendum](ZP-R_Diagonal_Family_Addendum.pdf) | ZP-R Diagonal Family Addendum | v1.25 | The faces formalized here of the self-referential relationship, by the μ/ν fork: wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (Quine atom, Kleene quine, Löb / Gödel 2nd, Rice) where it does, Löb / Gödel 2nd from a hypothesized Löb diagonal; Gödel's first incompleteness sits between the columns and is not formalized here. Lean-witnessed except the Gödel-first row. The self-application fixed point is a role filled per face: in the fork / AFA face by ⊥ of the ZPSemilattice, from the class fields (t_exec); in the computability face by a Kleene code, computability_face_fixedPoint giving every computable self-map on codes a fixed point up to eval (Rogers' form). Reads after ZP-R. | +| [The Choice-Free Core](ZP_Choice_Free_Core_Addendum.pdf) | Choice-Free Core | v1.19 | Framework-wide note: the central results are choice-free (T-SNAP is axiom-free); the framework is not choice-free as a whole - much of its choice is inherited from Mathlib in the analytic realizations (no proportion is measured), and some is the framework's own. [ChoiceCannotBe.lean](ZeroParadox/Category/ChoiceCannotBe.lean) § IV collects cases, of either provenance, where a general statement proved with choice implies excluded middle or its weak form by a choice-free reduction, and ZeroParadox/AxiomProfile.lean § 0 prints their footprints; for the fixed-point-free case this concerns the general statement over arbitrary types: restricted to carriers with decidable equality it is `[propext]` (fixedPointFree_of_nontrivial_decidable). See CLAIMS.md. Anchored on AxiomProfile.lean. | ### Reading Order (by Specialty) -The framework is not a line. Several fields each reach a bottom, and those bottoms all play the same structural role, the diagonal fixed point ⊥; the documents above are the spokes into it. Start at the hub, then follow your own field. A document that appears in more than one field's route is a bridge, and the overlap is the point: the fields' bottoms share one structural shape. Whether they are literally one object is a type boundary, not a theorem (see [The Frame-Change](ZP-Q_The_Frame_Change.pdf)). +The framework is not a line. Several fields each reach a bottom, and those bottoms all play the same structural role, the diagonal fixed point ⊥; the documents above are the spokes into it. Start at the hub, then follow your own field. A document that appears in more than one field's route is a bridge, and the overlap is the point: the fields' bottoms share one structural shape. Membership in the bottom family (MC-1) is proved for each of its four domains; which faces of the shared role are proved and which are carried as requirements or commitments is recorded row by row in the [Claims Ledger](CLAIMS.md), and each field's bottom is named as ⊥ of its own carrier and order in [The Bottom Element (⊥)](BOTTOMELEMENT.md). Whether they are literally one object is a type boundary, not a theorem (`Reading:`; see [The Frame-Change](ZP-Q_The_Frame_Change.pdf) Section III, where the cross-domain identity is a type boundary). -**Start here (the hub, for everyone):** two companion maps - [The Bottom Element (⊥)](BOTTOMELEMENT.md), the map of the object ⊥, and [The Binary Snap (⊥ → ε₀)](SNAP.md), the map of the transition off it - each with what is proved versus open → [Bridge Document](ZP-E_Bridge_Document.pdf), the snap assembled as a derived theorem → [The Frame-Change](ZP-Q_The_Frame_Change.pdf), the bottom read as both 0 and ∞, and why every field's bottom plays the same structural role. Keep the [Claims Ledger](CLAIMS.md) beside you for proved-versus-conjectural status. +**Start here (the hub, for everyone):** two companion maps - [The Bottom Element (⊥)](BOTTOMELEMENT.md), the map of the object ⊥, and [The Binary Snap (⊥ → ε₀)](SNAP.md), the map of the transition off it - each with what is proved versus open → [Bridge Document](ZP-E_Bridge_Document.pdf), the snap assembled as a derived theorem → [The Frame-Change](ZP-Q_The_Frame_Change.pdf), the bottom read as both 0 and ∞ (`Statement:` COINCIDENCE, a chart claim and not a point identity: in any `InfinitudeFloor` the complexity at the floor is ⊤, [`infinitude_forces_infinite_complexity`](ZeroParadox/Valuation/InfinitudeFloor.lean), with ℚ₂ as the instance `q2InfinitudeFloor`, whose floor 0 is least under the norm preorder (the `example` stating that 0 is the unique least point of the norm preorder, in ZeroParadox/Valuation/Padic.lean) and is the only point of valuation ⊤, `padic_addVal_eq_top_iff`; across the p-adic Riemann sphere the INVERSION chart exchanges two distinct poles (`Statement:` INVERSION), [`point_and_field_at_the_poles`](ZeroParadox/Valuation/PoleCornersBridge.lean); ZP-Q Section II. `Reading:` in the coincidence chart, whether the 0 and the ∞ are literally one object is a type boundary (the floor 0 lies in ℚ₂, the complexity ⊤ in ℕ∞); on the sphere they are provably two points), and why every field's bottom plays the same structural role. Keep the [Claims Ledger](CLAIMS.md) beside you for proved-versus-conjectural status. **Then follow your field:** @@ -133,7 +132,7 @@ This framework adds no axioms specific to the result: the central theorem takes Of the remaining commitments, most are restatements of structure established in earlier layers (AX-G1's initial object is grounded in ZP-A's bottom element, and AX-G2 in ZP-A antisymmetry with ZP-B C3; AX-G1's no-terminal half is ZP-G's own commitment, since ZP-A's two-state carriers have a top). **One is substantive and is not reducible to computation: AX-B1**, that existence is discrete rather than a continuum of partial states. 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`) checks that the two states are distinct *given* a two-element type; choosing a discrete alphabet over a continuum is the commitment itself, and is not what `decide` verifies. See the [Claims Ledger](CLAIMS.md) for the full statement. -The framework is stated over ZF + AFA (not ZFC), but the commitment is not the *adoption of AFA specifically*: it is a set of requirements on the host theory - that the bottom is a Quine atom (⊥ = {⊥}: its only member is itself, the reading CC-2 commits to), and that it is the only such reflexive set - of which AFA is the canonical example, since AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). Those requirements are a checkable object, the `QuineAtomHost` typeclass (`ZeroParadox/Settheory/QuineHost.lean`): Foundation-freeness is *forced* by ⊥ ∈ ⊥ (`quineAtomHost_not_wellFounded`); ZFC + Foundation is excluded in-kernel about Mathlib's real `ZFSet` (`zfSet_no_singleton_bottom`); Boffa's BA₁ - its reflexive sets form a proper class, not one (Aczel 1988, Prop. 5.1, p. 57) - fails the uniqueness, witnessed by a toy model (`boffa_fails_reflexive_unique`) rather than an in-kernel fact about that theory; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older class `QuineHost`, which asks for ⊥ ∈ ⊥ with no other self-membered element, is a different requirement: AFA's membership fails it, since 0* = {∅, 0*} is self-membered (Aczel 1988, Example 1.5, p. 7), and the two classes are incomparable (`QuineHost.lean` § VII). Only "these are the right requirements to demand" remains argued (and where AFA-specific results are used elsewhere, they are proved separately, not assumed from full AFA); the discipline every such claim must meet is defined in [Forced Metatheoretic Commitment](fmc.md). The bottoms across the layers form one **family** (MC-1): per-domain membership is proved (its correspondence half is `mc1_correspondence`), and the reading that they are numerically *one object* is retired as ill-typed. +The framework is stated over ZFC⁻ + AFA (ZFC with AFA in place of Foundation, Choice kept), and adopting AFA is CC-2's commitment. Its Lean abstraction is a set of requirements on the host theory - that the host has a bottom b that is a Quine atom (b = {b}: its only member is itself, a set filling the Quine-atom role of CC-2 with membership as the step), and that it is the only such reflexive set - which AFA meets, since AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). Those requirements are a checkable object, the `QuineAtomHost` typeclass (`ZeroParadox/Settheory/QuineHost.lean`): Foundation-freeness is *forced* by b ∈ b (`quineAtomHost_not_wellFounded`); ZFC + Foundation is excluded in-kernel about Mathlib's real `ZFSet` (`zfSet_no_singleton_bottom`); Boffa's BA₁ - its reflexive sets form a proper class, not one (Aczel 1988, Prop. 5.1, p. 57) - fails the uniqueness, witnessed by a toy model (`boffa_fails_reflexive_unique`) rather than an in-kernel fact about that theory; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older class `QuineHost`, which asks for a self-membered bottom with no other self-membered element, is a different requirement: AFA's membership fails it, since 0* = {∅, 0*} is self-membered (Aczel 1988, Example 1.5, p. 7), and the two classes are incomparable (`QuineHost.lean` § VII). That any such host gives up Foundation is forced; that these are the right requirements to abstract is argued (and where AFA-specific results are used elsewhere, they are proved separately, not assumed from full AFA); the discipline every such claim must meet is defined in [Forced Metatheoretic Commitment](fmc.md). The bottoms across the layers form one **family** (MC-1): per-domain membership is proved (its correspondence half is `mc1_correspondence`), and the reading that they are numerically *one object* is retired as ill-typed. The full labelled account - the supporting commitments (AX-B1, AX-G1, AX-G2, MP-1, RP-1, DP-1), the metatheoretic stance and the host-theory requirements (where AFA fits), and the bottom-family (MC-1) account in full - is in the **[Claims Ledger](CLAIMS.md)** (Tiers 4-5). diff --git a/RELEASES.md b/RELEASES.md index 677a338b..048c196d 100644 --- a/RELEASES.md +++ b/RELEASES.md @@ -93,6 +93,8 @@ Each GitHub release triggers an automatic Zenodo snapshot with a permanent DOI. ## v2.1 - 2026-05-28 +This entry was written to this file but never tagged; no v2.1 release or Zenodo snapshot exists. + **Why this release:** ZP-J v2.0 is a major document update (seven new sections added: Aczel DC-free connection, ValuationStructure→AbstractSelfApp→AFAStructure abstraction chain, concrete instances, APG decoration uniqueness). The ZPJ Lean sub-layer is correspondingly expanded with a complete sorry-free chain from valuation structure through APG decoration uniqueness — the most substantial new formal content since v2.0. **What changed:** @@ -248,6 +250,8 @@ Each GitHub release triggers an automatic Zenodo snapshot with a permanent DOI. ## v2.5 - 2026-06-17 +This entry was written to this file but never tagged; no v2.5 release or Zenodo snapshot exists, and v2.6 supersedes it. + **Why this release:** ZP-P "The Fixed-Point Fork" added as a synthesis layer, plus the new ZP-J Wheel illustrated companion and a project-wide rendered-version cleanup (C1). A minor doc release per the v2.4 threshold: ZP-P proves no new foundational result, so v3.0 stays reserved for a new foundational layer. **What changed:** @@ -413,16 +417,18 @@ Each GitHub release triggers an automatic Zenodo snapshot with a permanent DOI. ## v5.0 - 2026-07-22 +This entry was written to this file but never tagged; no v5.0 release or Zenodo snapshot exists, and as of 2026-11-05 the latest tagged release is v4.0. + **Why this release:** A new formal layer - ZP-R (Cross-Category Fixed Point), with its Diagonal Family Addendum - locating the framework's self-application fixed point ⊥ across the diagonal-family faces; together with the machine-checked claim graph (ClaimsMirror.lean), the snap-nucleus meta-lattice, and a round of bedrock corrections that struck a false premise shared by three documents. **What changed (since v4.0):** -- **ZP-R Cross-Category Fixed Point** (new synthesis / placement layer): locates and realizes ⊥ as a Lawvere fixed point across three faces - refuted in Set (Cantor), a fork rather than a reflexive object in the monotone / domain regime, and realized in the computability face (the crossing). Existence-as-Lawvere, uniqueness, and location are each proved but face-local and non-composable; the global identification is held as a fenced conjecture. Choice-free spine, choice-carrying computability realization. Lean: RequirementsGap, MetaFork, LawvereBridge, ComputableCrossing. -- **ZP-R Diagonal Family Addendum** (new): the complete diagonal-family roster tied to ⊥ by the μ/ν fork - wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (Quine atom, Kleene quine, Löb / Gödel 2nd, Rice) where it closes and lands at ⊥. Unification credited to Lawvere (1969) / Yanofsky (2003); the contribution is the axiom-free core formalization and the tie to ⊥, with the cross-face identity a type boundary. Supersedes the private ZP-W "Zero as a Wall" draft. +- **ZP-R Cross-Category Fixed Point** (new synthesis / placement layer): locates where the self-application role is filled by a Lawvere fixed point across three faces - refuted in Set (Cantor), a fork rather than a reflexive object in the monotone / domain regime, and realized in the computability face (the crossing). Existence-as-Lawvere, uniqueness, and location are each proved but face-local and non-composable; ZP-R conjectures nothing global (CLAIMS.md, the ZP-R row). Choice-free spine, choice-carrying computability realization. Lean: RequirementsGap, MetaFork, LawvereBridge, ComputableCrossing. +- **ZP-R Diagonal Family Addendum** (new): the complete diagonal-family roster tied to ⊥ by the μ/ν fork - wall faces (Cantor, Russell, Turing, Tarski, Curry) where self-reference cannot close, and floor faces (Quine atom, Kleene quine, Löb / Gödel 2nd, Rice) where it closes, Löb / Gödel 2nd from a hypothesized Löb diagonal; the fixed point is ⊥ of the ZPSemilattice only in the fork / AFA face, and a Kleene code, up to eval, in the computability face (README.md, the Diagonal Family Addendum row). Unification credited to Lawvere (1969) / Yanofsky (2003); the contribution is the formalization and its tie to the self-application role (the footprint per face is in the Addendum's abstract), and abstract Löb and Gödel 2 are also formalized by Popescu & Traytel (Isabelle, 2019) and Saitou & Noguchi (Lean 4, arXiv:2609.13780), with the cross-face identity a type boundary. Supersedes the private ZP-W "Zero as a Wall" draft. - **ClaimsMirror.lean - the claim graph made checkable**: a machine-checked mirror of the SSOT claim store. Each claim marked proved / corroborated / deep is restated and discharged from the existing machinery, so a claim's status is a verified link to a green declaration rather than a label; the three non-theorems are represented by their deliberate absence. Nineteen claim nodes are linked to their declarations. - **The snap-nucleus meta-lattice**: the snap lifted to a nucleus on WithTop Ordinal (snapNucleus sends ⊥ to ε₀), the double-negation nucleus (closed points the Boolean core), and the lattice of systems (Nucleus Frame / Sublocale Coframe) unlocked by the point at infinity. - **Bedrock corrections (premise / theorem-status)**: a false premise shared by three documents - "a well-founded ⊥ would admit an external interpreter" / "well-founded implies a finite membership tree" (ω is well-founded and infinite) - was struck, with Foundation-incompatibility rebased on the self-membership of the Quine atom ⊥ = {⊥} (no_quine_atom, choice-free). Corrected in ZP-E (v3.24), ZP-A (v1.20), and the Foreword (v2.12); CC-2 relabelled a Forced Metatheoretic Commitment. ZP-I (v1.14) purity corrected - the p-adic convergence spine carries Mathlib's Classical.choice and is not axiom-free. -- **Constructive-ordinal deepening (ZP-N v1.0 to v2.0)**: the classical dependency located and shown load-bearing (comparability of arbitrary well-orders implies excluded middle, cited to Kraus / Nordvall Forsberg / Xu), the axiom-footprint instrument shown uninformative for ε₀ results, and a carrier sized to ε₀ with its crossing price measured. Whether ZP-L's ε₀ results are eliminable remains unclassified. -- **The choice reference index (ChoiceCannotBe.lean) and roots enumeration**: a check-only index of the framework's relationship to Classical.choice, plus the two essential cases where the core does invoke it - comparability of arbitrary well-orders implies excluded middle, and the general fixed-point-free endomap principle implies weak excluded middle - each a choice-free reduction. +- **Constructive-ordinal deepening (ZP-N v1.0 to v2.0)**: the classical dependency located and shown load-bearing (comparability of arbitrary well-orders implies excluded middle, cited to Kraus / Nordvall Forsberg / Xu), the axiom-footprint instrument shown uninformative for ε₀ results, and a carrier of notations denoting the ordinals up to ε₀ with its crossing price measured (README.md, the ZP-N row). Whether ZP-L's ε₀ results are eliminable remains unclassified. +- **The choice reference index (ChoiceCannotBe.lean) and roots enumeration**: a check-only index of the framework's relationship to Classical.choice, plus five general statements proved with choice that imply excluded middle or its weak form by a choice-free reduction (ChoiceCannotBe.lean § IV) - among them comparability of arbitrary well-orders implies excluded middle, and the general fixed-point-free endomap principle implies weak excluded middle - while the core declarations printed in AxiomProfile.lean § I are choice-free (README.md, the Choice-Free Core row). - **Prior-art audit**: ten confirmed citation gaps closed across seven Lean files. - **Precision fixes and infrastructure**: ZP-C (v1.21), ZP-J AFA Addendum (v1.7), ZP-L (v1.4), the ZP-B companion, and SNAP.md; review signals moved to a per-file SHA-256 scheme and a severity-tiered review cap. diff --git a/SNAP.md b/SNAP.md index 5921e397..80859c9b 100644 --- a/SNAP.md +++ b/SNAP.md @@ -12,7 +12,7 @@ For the framework's *object*, the bottom element ⊥, see its companion referenc This is a **reference** for the framework's central transition, the **snap** - the one-way move off the bottom element ⊥ into the first structured state, ε₀. It is the companion to [The Bottom Element](BOTTOMELEMENT.md): that page maps the *object* ⊥ (the noun); this page maps the *transition* off it (the verb). Where the bottom dictionary is mostly nouns, this one is mostly verbs - the snap is an action. -It is a **beginning, not a resolution.** What is *proved* is that the snap's shape is derived rather than assumed (that it occurs follows from the occurrence commitment together with DA-1, closed given DP-2), one-way, takes its first step from below, and that the domain snaps form one **family** (MC-1, membership proved per domain); what is *retired* is the reading that they are numerically one object (ill-typed: object equality across categories does not typecheck and is not invariant under equivalence); and what stays *open* is a choice-free proof of ε₀'s leastness on a well-founded carrier, not located as of 2026-10-08 (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The frame-change faces are proved theorems that compose known results, so no new theorem is claimed there; what stays a conjecture is only the abstract cross-domain reading (`Reading:` INVERSION, conjectural) - that they are literally one change of frame (a type boundary) - written up in [ZP-Q](ZP-Q_The_Frame_Change.pdf). +It is a **beginning, not a resolution.** What is *proved* is that the snap's shape is derived rather than assumed (that it occurs follows from the occurrence commitment together with DA-1, closed given DP-2), one-way, takes its first step from below, and that the domain snaps form one **family** (MC-1, membership proved per domain); what is *retired* is the reading that they are numerically one object (ill-typed: object equality across categories does not typecheck and is not invariant under equivalence); and what stays *open* is the derived reading of the choice-free restatement: ε₀'s fixed point, leastness included, derived on a well-founded Lean carrier whose statements are choice-free, not located as of 2026-10-13 (the defined reading, on E0Note, is in Lean; both: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The frame-change faces are proved theorems that compose known results, so no new theorem is claimed there; no identity across the domains is stated - an equation across them is ill-typed (a type boundary, MC-1) - so "the faces are literally one change of frame" is not a well-formed statement; each domain's frame-flip is proved in its own chart. Whether the snap is an instance of the frame-change is a separate question, ZP-Q's open conjecture (`Reading:` INVERSION, conjectural), written up in [ZP-Q](ZP-Q_The_Frame_Change.pdf). --- @@ -22,17 +22,17 @@ The snap is the framework's one theorem - the one-way departure from ⊥ into th **Proved - the snap is DERIVED rather than assumed, and adds no axiom.** T-SNAP ([`t_snap_derived`](ZeroParadox/Order/Snap.lean)): the transition ⊥ → ε₀ (in the discrete state chart, ε₀ names c₁, which covers c₀, ⊥ of MachinePhase, because that carrier has two states, `ZeroParadox/Order/SnapCannotBe.lean` § II; the ordinal ε₀ is a different chart, at once the least fixed point of α ↦ ω^α and the supremum of its tower, [`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean), indexed in `ZeroParadox/Ordinal/Epsilon0CannotBe.lean`) is a derived consequence of the bottom axiom A4 and the framework's computational commitments, not an assumption. **"Derived" is a claim about where the transition comes from, not that it is taken:** T-SNAP constrains the SHAPE of the transition and the same file's [`tsnap_holds_but_nothing_moves`](ZeroParadox/Order/Snap.lean) proves it holds where nothing moves. That the snap occurs is not a theorem. Earlier layers posited the Binary Snap as AX-1. AX-1 is retired: its content was split in two, the shape proved as Theorem T-SNAP, and that the snap occurs stated separately, following from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2); no snap-specific axiom appears anywhere. -**Proved - the snap is one-way.** It does not reverse: no join returns to a strictly lower state ([`t_snap_irreversible`](ZeroParadox/Order/Snap.lean), algebraic), and the same irreversibility is proved topologically in the 2-adics ([`c3_irreversible`](ZeroParadox/Valuation/Padic.lean)) and categorically in the probability functor ([`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean)). ⊥ is a source, not a round trip. +**Proved - the snap is one-way.** It does not reverse: no join returns to a strictly lower state ([`t_snap_irreversible`](ZeroParadox/Order/Snap.lean), algebraic; the order chart carries a one-way direction), no return is proved categorically in the probability functor ([`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean); that chart is one-way too: the floor's initial maps run out to every stage ([`fC_zero_isInitial`](ZeroParadox/Multihomed/InfoFunctor.lean)) and no later stage maps back), and topologically the 2-adics admit no continuous path from a nonzero point back to 0 ([`c3_irreversible`](ZeroParadox/Valuation/Padic.lean)), a symmetric fact that holds between any two distinct points of Q₂ in either direction (the `example` restating [`c3_irreversible`](ZeroParadox/Valuation/Padic.lean) for any two distinct endpoints, in ZeroParadox/Valuation/Padic.lean), so the topology supplies no direction of its own. ⊥ is a source, not a round trip. -**Proved - a frame-change in each domain, and an order-theoretic universal.** Over any complete lattice the order-duality frame-change swaps the fork's two closures and the fork collapses at the diagonal fixed point ([`fork_is_frameflip`](ZeroParadox/Settheory/ForkFrameChange.lean)); this is the standard lfp/gfp duality, choice-free, claimed as no novelty. It is realized concretely in the valuation face ([`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean): one ω-tower's encodings converge to ⊥ in the encoding chart and diverge to ∞ through the 0 ↔ ∞ inversion) and the category face ([`catseam_is_frameflip`](ZeroParadox/Category/SeamFrameChange.lean)). (The abstract cross-domain reading - that these are one and the same frame-change - stays a conjecture; see below.) +**Proved - a frame-change in each domain, and an order-theoretic universal.** Over any complete lattice the order-duality frame-change swaps the fork's two closures and the fork collapses at the diagonal fixed point ([`fork_is_frameflip`](ZeroParadox/Settheory/ForkFrameChange.lean)); this is the standard lfp/gfp duality, choice-free, claimed as no novelty. It is realized concretely in the valuation face ([`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean): one ω-tower's encodings converge to ⊥ in the encoding chart and diverge to ∞ through the 0 ↔ ∞ inversion) and the category face ([`catseam_is_frameflip`](ZeroParadox/Category/SeamFrameChange.lean)). (`Statement:` CARRIER - each domain's frame-flip is proved in its own carrier; see below.) **Proved - the first fixed point of ω^· above ⊥ of `Ordinal`, approached choice-free from below.** ε₀ is the least fixed point of omega-to-the-power reached from 0 ([`epsilonZero_eq_nfp`](ZeroParadox/Ordinal/Gentzen.lean)); on ordinal notations the tower climbs from below with no choice ([`exp_lt_term`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean), [`omegaPow_no_fixedpoint`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean), [`tower_strictMono`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean); footprints printed in `ZeroParadox/Ordinal/ConstructiveOrdinals.lean` § PurityCheck) and never reaches ε₀ there, since no notation bounds the tower ([`tower_no_upper_bound`](ZeroParadox/Ordinal/SnapNucleusConstructive.lean)); ε₀ is co-witnessed with the 2-adic limit and the machine snap ([`zpm_triangle`](ZeroParadox/Ordinal/Incompleteness.lean)). (That ε₀ *is* the least fixed point is proved on `Ordinal`, with choice carried by the statement, [`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean); the open item is below.) **Proved - a wall: the snap is not one mechanism across categories.** The per-domain frame-flips share a shape, not a single categorical map. In Set (all endofunctions) no nontrivial total type carries a Lawvere fixed-point witness - Cantor forbids it - so the lattice and 2-adic faces are provably not Set-level Lawvere instances ([`nontrivial_lattice_no_witness`](ZeroParadox/Category/Lawvere.lean), [`q2_no_witness`](ZeroParadox/Category/Lawvere.lean)); their ⊥ is a proved fixed point of its own self-map ([`q2_unique_fp`](ZeroParadox/Computability/SelfApp.lean), [`selfApp_fp_set_eq_singleton`](ZeroParadox/Multihomed/SelfAppForkPlace.lean)), carrying the diagonal shape but not a genuine Set-level Lawvere instance. The computability face, by contrast, IS a genuine recursion fixed point ([`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean), Kleene / Rogers) - but it lives in the effective category, where the fixed-point-free DIAGONAL CONSTRUCTION is not admissible. `Reading:` CARRIER - the verdict is category-relative, not a property of the object: the same diagonal shape is refuted in Set and available in the effective setting. That is not the claim that no fixed-point-free computable endomap exists - c |-> Code.pair c c is one - and the fixed point it gets is Rogers', up to eval. Heterogeneous categories, heterogeneous verdicts: what unifies them is the diagonal shape, not one mechanism. The universality that holds is order-theoretic (the fork), not categorical - a proved obstruction. -**The family (proved), the identity (retired), choice-free minimality (open).** The domain snaps form one **family** (MC-1): per-domain membership is proved, the reading that they are *numerically one* transition is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). Separately, leastness is proved on `Ordinal` ([`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean), with choice); a choice-free proof of it on a well-founded carrier was not located as of 2026-10-08. The choice is carried by the statement, so no re-routing of the proof can remove it; only a restatement whose own statement is choice-free can (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). +**The family (proved), the identity (retired), choice-free minimality (open).** The domain snaps form one **family** (MC-1): per-domain membership is proved, the reading that they are *numerically one* transition is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). Separately, leastness is proved on `Ordinal` ([`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean), with choice); the choice is carried by the statement, so no proof of the statement as written can drop it; restated on a carrier whose statements are choice-free, it has two readings: a defined one, in Lean on [`E0Note`](ZeroParadox/Ordinal/PricedInterface.lean), where the fixed point is unique by theorem and exists by definition ([`e0OmegaPow_fixedpoint_iff`](ZeroParadox/Ordinal/PricedInterface.lean)), and a derived one, on a well-founded Lean carrier with leastness derived, not located as of 2026-10-13 (both, with the search record: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint; the same-carrier respelling: `ZeroParadox/Category/ChoiceCannotBe.md`, STATEMENT-CARRIED). -**A note on the frame-change faces.** [`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean), [`catseam_is_frameflip`](ZeroParadox/Category/SeamFrameChange.lean), and [`fork_is_frameflip`](ZeroParadox/Settheory/ForkFrameChange.lean) are proved theorems that compose known results (no novelty is claimed); the per-domain frame-flips and the order-theoretic universal hold. What remains a conjecture is only the abstract cross-domain statement "the snap ⊥ → ε₀ IS the change of point of view" - that the faces are literally one change of frame (a type boundary). The formal write-up is the finalized document [ZP-Q The Frame-Change](ZP-Q_The_Frame_Change.pdf) (see register.md for the current version). Note the scope: the DOCUMENT is finalized; the three Lean files above are still marked experimental probes in their own headers, and `SnapFrameChange.lean` carries the cross-domain claim as an explicit open conjecture. "Finalized" refers to the write-up, not to the Lean support. +**A note on the frame-change faces.** [`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean), [`catseam_is_frameflip`](ZeroParadox/Category/SeamFrameChange.lean), and [`fork_is_frameflip`](ZeroParadox/Settheory/ForkFrameChange.lean) are proved theorems that compose known results (no novelty is claimed); the per-domain frame-flips and the order-theoretic universal hold. Two different statements are kept apart. That the faces are literally one change of frame is not stated: an equation across the domains is ill-typed (a type boundary, MC-1), and each domain's frame-flip is proved in its own chart. That "the snap ⊥ → ε₀ IS the change of point of view" is ZP-Q's open conjecture. The formal write-up is the finalized document [ZP-Q The Frame-Change](ZP-Q_The_Frame_Change.pdf) (see register.md for the current version). Note the scope: the DOCUMENT is finalized; the three Lean files above are still marked experimental probes in their own headers, and `SnapFrameChange.lean` carries the snap-as-instance reading as an explicit open conjecture. "Finalized" refers to the write-up, not to the Lean support. --- @@ -40,13 +40,13 @@ The snap is the framework's one theorem - the one-way departure from ⊥ into th ### The snap is (positive handles, with witnesses) -The handles sort by **aspect**: what the snap *is* (**noun** - the endpoints it joins) or what the snap *does* (**verb** - the action itself). Most are verbs; that is the point. *(The frame-change is the POLE EXCHANGE - the bottom read as both 0 and infinity. Whether the snap is an instance of that exchange is ZP-Q's open conjecture, not a settled identification either way; see ZP-Q and the declaration docstrings.)* *The per-domain frame-flips and the order-theoretic universal are proved theorems, written up in ZP-Q (The Frame-Change); they compose known results, so no new theorem is claimed. Only the abstract cross-domain reading - that these are literally one change of frame - is a conjecture (a type boundary).* +The handles sort by **aspect**: what the snap *is* (**noun** - the endpoints it joins) or what the snap *does* (**verb** - the action itself). Most are verbs; that is the point. *(The frame-change is the POLE EXCHANGE - the bottom read as both 0 and infinity. Whether the snap is an instance of that exchange is ZP-Q's open conjecture, not a settled identification either way; see ZP-Q and the declaration docstrings.)* *The per-domain frame-flips and the order-theoretic universal are proved theorems, written up in ZP-Q (The Frame-Change); they compose known results, so no new theorem is claimed. That they are literally one change of frame is not stated: an equation across the domains is ill-typed (a type boundary, MC-1).* | aspect | characterization of the snap | witness (links to Lean source) | |---|---|---| | theorem | the *derived* (not assumed) transition off c₀, ⊥ of MachinePhase, into c₁ (in that two-state carrier c₁ covers c₀: `ZeroParadox/Order/SnapCannotBe.lean` § II) - derived, which is a claim about its provenance and not that it is taken: the join c₀ ∨ c₁ = c₁ is a valid transition, and c₀, c₁ are provably distinct in both directions. AX-1 (the Binary Snap) is retired: its shape 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) | [`t_snap_derived`](ZeroParadox/Order/Snap.lean) | -| verb | *one-way*: the departure from ⊥ does not reverse. No join can return to a strictly lower state (algebraic form), and the 2-adic and Kleisli faces prove the same irreversibility topologically and categorically | [`t_snap_irreversible`](ZeroParadox/Order/Snap.lean), [`c3_irreversible`](ZeroParadox/Valuation/Padic.lean), [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) | -| verb | a chart-reading of the LIMIT - `Statement:` INVERSION, `Reading:` INVERSION and conjectural, since no snap transition appears in the statement - valuation face: the same ω-tower's encodings descend to the 2-adic floor 0 = ⊥ (the ascent to ε₀ resolving back onto the floor - the SAME 0 it started from, `snap_arc_z2_loop`; reading it as a new bottom ⊥ₙ₊₁ is C-DA2, a commitment) and, through the Riemann-sphere inversion that swaps 0 ↔ ∞, rise to ∞. The inversion is the passage between the two charts | [`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean), [`snap_frameflip_tower_tendsto_infty`](ZeroParadox/Multihomed/SnapFrameChange.lean) | +| verb | *one-way*: the departure from ⊥ does not reverse. No join can return to a strictly lower state (algebraic form, and the direction is the order's), and the Kleisli face proves the no-return categorically. The 2-adic face proves no continuous path from a nonzero point back to 0 topologically, and that fact is symmetric: it holds between any two distinct points of Q₂, either way round (the `example` restating c3_irreversible for any two distinct endpoints, in ZeroParadox/Valuation/Padic.lean), so the one-way direction comes from the order and categorical charts, not the topology | [`t_snap_irreversible`](ZeroParadox/Order/Snap.lean), [`c3_irreversible`](ZeroParadox/Valuation/Padic.lean), [`fC_no_return`](ZeroParadox/Multihomed/InfoFunctor.lean) | +| verb | a chart-reading of the LIMIT - `Statement:` INVERSION, `Reading:` INVERSION and conjectural, since no snap transition appears in the statement - valuation face: the same ω-tower's encodings descend to ℤ_[2]'s 0, least under the 2-adic norm preorder (the ascent to ε₀ resolving back onto the floor - the SAME 0 it started from, `snap_arc_z2_loop`; reading it as a new bottom ⊥ₙ₊₁ is C-DA2, a commitment) and, through the Riemann-sphere inversion that swaps 0 ↔ ∞, rise to ∞. The inversion is the passage between the two charts | [`snap_is_frameflip`](ZeroParadox/Multihomed/SnapFrameChange.lean), [`snap_frameflip_tower_tendsto_infty`](ZeroParadox/Multihomed/SnapFrameChange.lean) | | verb | a chart-reading of the SEAM (the seam is what the frame-flip FIXES, not a flip, and no snap appears), category face: the categorical seam is an op-self-dual zero object of the module category ModuleCat ℂ - initial and terminal at once, with the op-duality frame-change swapping the two | [`catseam_is_frameflip`](ZeroParadox/Category/SeamFrameChange.lean) | | verb | a *change of frame*, order-theoretic universal (choice-free): order-duality swaps the fork's two closures (least fixed point ↔ greatest fixed point), and the fork collapses to the diagonal fixed point exactly when the map has a unique fixed point. This is the standard lfp/gfp duality, bundled - the domain-independent shape the valuation and category faces realize concretely | [`fork_is_frameflip`](ZeroParadox/Settheory/ForkFrameChange.lean), [`fork_collapse_iff`](ZeroParadox/Settheory/FixedPointFork.lean) | | verb | *generation*: the ω-tower seeded at ⊥ (= 0) of `Ordinal` closes at ε₀, the least fixed point of α ↦ ω^α, the first ordinal fixed by omega-to-the-power | [`epsilonZero_eq_nfp`](ZeroParadox/Ordinal/Gentzen.lean) | @@ -64,7 +64,7 @@ Each exclusion is either a **proved obstruction** (a Lean-checked wall), a **ret | *numerically one transition across its carriers*. The valuation, categorical, order, and computability snaps form one **family** (MC-1), not one object: each is a member (membership proved per domain), but the reading that they are numerically the same object is **retired** as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). What they share is the diagonal-fixed-point *shape*, not an identity | *meta (no Lean witness)* | | *a physical, temporal, or causal event*. The framework is silent on physics. The snap is an order and derivation transition, not a process unfolding in time; which specific state emerges first is outside its scope | *meta (no Lean witness)* | | *dependent on a snap-specific axiom*. T-SNAP is derived from the bottom axiom A4 (the join identity ∀ x, ⊥ ∨ x = x) and the framework's commitments; `t_snap_given` states two of them, the start at ⊥ and occurrence at the first step, as its hypotheses. No snap axiom appears anywhere in the development: AX-1 is retired, and that the snap occurs follows from the occurrence commitment together with DA-1, neither of them an axiom | [`t_snap_derived`](ZeroParadox/Order/Snap.lean), [`t_snap_given`](ZeroParadox/Order/Snap.lean) | -| *proved to be a choice-free least fixed point*. Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); a choice-free proof of it on a well-founded carrier was not located as of 2026-10-08. The choice is carried by the statement, through Mathlib's `Ordinal` order instance and operations, so no re-routing of the proof can remove it; only a restatement whose own statement is choice-free can (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The from-below ascent on notations is choice-free (`tower_strictMono`) | [`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean), [`epsilonZero_eq_nfp`](ZeroParadox/Ordinal/Gentzen.lean) | +| *proved to be a choice-free least fixed point*. Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); the choice is carried by the statement, through Mathlib's `Ordinal` order instance and operations, so no proof of the statement as written can drop it; restated on a carrier whose statements are choice-free, it has two readings: a defined one, in Lean on `E0Note`, where the fixed point is unique by theorem and exists by definition (`e0OmegaPow_fixedpoint_iff`), and a derived one, on a well-founded Lean carrier with leastness derived, not located as of 2026-10-13 (both, with the search record: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint; the same-carrier respelling: `ZeroParadox/Category/ChoiceCannotBe.md`, STATEMENT-CARRIED). The from-below ascent on notations is choice-free (`tower_strictMono`) | [`epsilon0_min_eq_max`](ZeroParadox/Ordinal/Epsilon0MinMax.lean), [`epsilonZero_eq_nfp`](ZeroParadox/Ordinal/Gentzen.lean) | --- @@ -85,7 +85,7 @@ The pattern is worth stating plainly. The self-referential *shape* - the diagona | proof theory (ordinals) | **Available, and minimal** | ε₀ is the proof-theoretic ordinal of PA; the ω-tower climbs from below choice-free, ε₀ is the least fixed point of α ↦ ω^α, and the tower is cofinal in it (the from-below climb is choice-free; the least-fixed-point and cofinality facts use classical logic) | [`tower_strictMono`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean), [`epsilonZero_eq_nfp`](ZeroParadox/Ordinal/Gentzen.lean), [`epsilonZero_le_fixedPoint`](ZeroParadox/Ordinal/Gentzen.lean), [`fundamentalSeq_cofinal`](ZeroParadox/Ordinal/Gentzen.lean) | | information | **Available** | surprisal is unbounded at the floor - the bottom has no finite description, so nothing external holds it in place | [`info_bottom_diverges`](ZeroParadox/Information/BottomMeasure.lean) | | category | **Available, one-way** | the initial object has a unique morphism out to every object and none back; ⊥ is a pure source, not a round trip | [`t2_universal_constituent`](ZeroParadox/Category/Category.lean), [`t4_chains_forward_only`](ZeroParadox/Category/Category.lean) | -| order / set theory | **Available** (choice-free spine) | the fork collapses to the diagonal fixed point exactly when the map has a unique fixed point, and the self-containing ⊥ = {⊥} realizes it. The field snaps form one family (MC-1); the reading that they are numerically one object is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence) | [`fork_collapse_iff`](ZeroParadox/Settheory/FixedPointFork.lean), [`selfMem_eq_singleton_bot`](ZeroParadox/Computability/SelfApp.lean) | +| order / set theory | **Available** (choice-free spine) | the fork collapses to the diagonal fixed point exactly when the map has a unique fixed point, and the Quine atom (CC-2) realizes it: in the die, under a self-application map supplied by AbstractSelfApp, ⊥ of a ZP-A semilattice is the only point that steps to itself and to nothing else, by that class's own fields (selfApp_quine_role_iff), which the constant map onto ⊥ also meets; the set-theoretic content sits in the host: adopting AFA is CC-2's commitment, the host requirements (QuineAtomHost) are its Lean abstraction, and that any such host gives up Foundation is forced (quineAtomHost_not_wellFounded). The field snaps form one family (MC-1); the reading that they are numerically one object is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence) | [`fork_collapse_iff`](ZeroParadox/Settheory/FixedPointFork.lean), [`selfMem_eq_singleton_bot`](ZeroParadox/Computability/SelfApp.lean), [`selfApp_quine_role_iff`](ZeroParadox/Settheory/QuineDichotomy.lean), [`quineAtomHost_not_wellFounded`](ZeroParadox/Settheory/QuineHost.lean) | | real numbers | **Walled - the snap fails** | two global properties, each a separate fence. Order: the field order is dense, and an order is dense exactly when no element has a first step (Mathlib's denselyOrdered_iff_forall_not_covBy, restated as axb1_fails_everywhere_iff_dense), so 0 has none either, in every ordered field (axb1_fails_in_ordered_field). Topology: ℝ is connected while ℚ₂ is totally disconnected (place_topological_signature). Lacking a first step at 0 is not the wall on its own: ℚ₂'s 0 lacks one too in its norm preorder, which is nonetheless not dense (ZeroParadox/BottomCannotBe.lean § ROLE), and the first step the snap takes is AX-B1's cover of ⊥ on the state carrier, a commitment rather than a property of ℚ₂. The one row of this map where the transition provably cannot happen, and that impossibility is itself a theorem: the order fence is proved for every ordered field, ℝ among them. Statement: CARRIER, for the topology fence | [`axb1_fails_everywhere_iff_dense`](ZeroParadox/Reals/OrderedField.lean), [`axb1_fails_in_ordered_field`](ZeroParadox/Reals/OrderedField.lean), [`place_topological_signature`](ZeroParadox/Valuation/ArchPlace.lean), [`f_snap_impossible`](ZeroParadox/Reals/OrderedField.lean) | The cross-cutting walls - Cantor for the Lawvere fixed point, the MC-1 type boundary that retires the cross-frame identity, and the absence of a measure-preserving comparison between the two attracting bottoms ([`no_mp_attractor_to_markov`](ZeroParadox/Valuation/BottomInvariant.lean)) - are catalogued in *The snap is not* above. The walls are not failures of the program; locating them exactly is the program. diff --git a/ZP-A_Illustrated_Companion.pdf b/ZP-A_Illustrated_Companion.pdf index d074cec5..453dee44 100644 Binary files a/ZP-A_Illustrated_Companion.pdf and b/ZP-A_Illustrated_Companion.pdf differ diff --git a/ZP-A_Lattice_Algebra.pdf b/ZP-A_Lattice_Algebra.pdf index a0859c9f..62c49c0a 100644 Binary files a/ZP-A_Lattice_Algebra.pdf and b/ZP-A_Lattice_Algebra.pdf differ diff --git a/ZP-B_pAdic_Topology.pdf b/ZP-B_pAdic_Topology.pdf index 6e9d4bde..1b274aa0 100644 Binary files a/ZP-B_pAdic_Topology.pdf and b/ZP-B_pAdic_Topology.pdf differ diff --git a/ZP-C_Illustrated_Companion.pdf b/ZP-C_Illustrated_Companion.pdf index a6818617..bacb8066 100644 Binary files a/ZP-C_Illustrated_Companion.pdf and b/ZP-C_Illustrated_Companion.pdf differ diff --git a/ZP-C_Information_Theory.pdf b/ZP-C_Information_Theory.pdf index 1978de2c..cbc7c8fc 100644 Binary files a/ZP-C_Information_Theory.pdf and b/ZP-C_Information_Theory.pdf differ diff --git a/ZP-D_State_Layer.pdf b/ZP-D_State_Layer.pdf index 58d94a35..d2741386 100644 Binary files a/ZP-D_State_Layer.pdf and b/ZP-D_State_Layer.pdf differ diff --git a/ZP-E_Bridge_Document.pdf b/ZP-E_Bridge_Document.pdf index 9fec4872..fee3e34c 100644 Binary files a/ZP-E_Bridge_Document.pdf and b/ZP-E_Bridge_Document.pdf differ diff --git a/ZP-E_Illustrated_Companion.pdf b/ZP-E_Illustrated_Companion.pdf index 8fa98ac1..263cea60 100644 Binary files a/ZP-E_Illustrated_Companion.pdf and b/ZP-E_Illustrated_Companion.pdf differ diff --git a/ZP-F_Illustrated_Companion.pdf b/ZP-F_Illustrated_Companion.pdf index e5f5d815..81369b36 100644 Binary files a/ZP-F_Illustrated_Companion.pdf and b/ZP-F_Illustrated_Companion.pdf differ diff --git a/ZP-F_The_Counterexamples.pdf b/ZP-F_The_Counterexamples.pdf index 71fd0f39..5930ae1b 100644 Binary files a/ZP-F_The_Counterexamples.pdf and b/ZP-F_The_Counterexamples.pdf differ diff --git a/ZP-G_Category_Theory.pdf b/ZP-G_Category_Theory.pdf index f24db19d..901962dc 100644 Binary files a/ZP-G_Category_Theory.pdf and b/ZP-G_Category_Theory.pdf differ diff --git a/ZP-G_Illustrated_Companion.pdf b/ZP-G_Illustrated_Companion.pdf index 32af0399..cb797188 100644 Binary files a/ZP-G_Illustrated_Companion.pdf and b/ZP-G_Illustrated_Companion.pdf differ diff --git a/ZP-H_Categorical_Bridge.pdf b/ZP-H_Categorical_Bridge.pdf index dc8ad88a..e62e8286 100644 Binary files a/ZP-H_Categorical_Bridge.pdf and b/ZP-H_Categorical_Bridge.pdf differ diff --git a/ZP-H_Illustrated_Companion.pdf b/ZP-H_Illustrated_Companion.pdf index f71aa588..fdebb971 100644 Binary files a/ZP-H_Illustrated_Companion.pdf and b/ZP-H_Illustrated_Companion.pdf differ diff --git a/ZP-H_Native_Categories_Addendum.pdf b/ZP-H_Native_Categories_Addendum.pdf index b4f8b736..0fda654f 100644 Binary files a/ZP-H_Native_Categories_Addendum.pdf and b/ZP-H_Native_Categories_Addendum.pdf differ diff --git a/ZP-I_Illustrated_Companion.pdf b/ZP-I_Illustrated_Companion.pdf index c472589b..113ff323 100644 Binary files a/ZP-I_Illustrated_Companion.pdf and b/ZP-I_Illustrated_Companion.pdf differ diff --git a/ZP-I_Inside_Zero.pdf b/ZP-I_Inside_Zero.pdf index dd8cca91..5cd76c31 100644 Binary files a/ZP-I_Inside_Zero.pdf and b/ZP-I_Inside_Zero.pdf differ diff --git a/ZP-J_AFA_Addendum.pdf b/ZP-J_AFA_Addendum.pdf index ea7409b3..f9cd4984 100644 Binary files a/ZP-J_AFA_Addendum.pdf and b/ZP-J_AFA_Addendum.pdf differ diff --git a/ZP-J_Illustrated_Companion.pdf b/ZP-J_Illustrated_Companion.pdf index dfb8b36e..b70f3a7e 100644 Binary files a/ZP-J_Illustrated_Companion.pdf and b/ZP-J_Illustrated_Companion.pdf differ diff --git a/ZP-J_Keystone_Addendum.pdf b/ZP-J_Keystone_Addendum.pdf index 52ac7106..40ebcb60 100644 Binary files a/ZP-J_Keystone_Addendum.pdf and b/ZP-J_Keystone_Addendum.pdf differ diff --git a/ZP-J_Self_Reference.pdf b/ZP-J_Self_Reference.pdf index a8fd8839..2413fbc1 100644 Binary files a/ZP-J_Self_Reference.pdf and b/ZP-J_Self_Reference.pdf differ diff --git a/ZP-J_Wheel_Addendum.pdf b/ZP-J_Wheel_Addendum.pdf index 8fab15ff..d36df490 100644 Binary files a/ZP-J_Wheel_Addendum.pdf and b/ZP-J_Wheel_Addendum.pdf differ diff --git a/ZP-J_Wheel_Illustrated_Companion.pdf b/ZP-J_Wheel_Illustrated_Companion.pdf index fa908ed4..75d39502 100644 Binary files a/ZP-J_Wheel_Illustrated_Companion.pdf and b/ZP-J_Wheel_Illustrated_Companion.pdf differ diff --git a/ZP-K_Computational_Grounding.pdf b/ZP-K_Computational_Grounding.pdf index 47190296..4254e482 100644 Binary files a/ZP-K_Computational_Grounding.pdf and b/ZP-K_Computational_Grounding.pdf differ diff --git a/ZP-K_Illustrated_Companion.pdf b/ZP-K_Illustrated_Companion.pdf index 06522e88..f0ada5c2 100644 Binary files a/ZP-K_Illustrated_Companion.pdf and b/ZP-K_Illustrated_Companion.pdf differ diff --git a/ZP-L_Illustrated_Companion.pdf b/ZP-L_Illustrated_Companion.pdf index 37896d94..84681aa0 100644 Binary files a/ZP-L_Illustrated_Companion.pdf and b/ZP-L_Illustrated_Companion.pdf differ diff --git a/ZP-L_Incomputability_Convergence.pdf b/ZP-L_Incomputability_Convergence.pdf index 2aba8cd9..22f1ec63 100644 Binary files a/ZP-L_Incomputability_Convergence.pdf and b/ZP-L_Incomputability_Convergence.pdf differ diff --git a/ZP-M_Illustrated_Companion.pdf b/ZP-M_Illustrated_Companion.pdf index 72a40dcf..37a58414 100644 Binary files a/ZP-M_Illustrated_Companion.pdf and b/ZP-M_Illustrated_Companion.pdf differ diff --git a/ZP-M_Kleene_Ordinal_Bridge.pdf b/ZP-M_Kleene_Ordinal_Bridge.pdf index e0ea0bbc..95d5043e 100644 Binary files a/ZP-M_Kleene_Ordinal_Bridge.pdf and b/ZP-M_Kleene_Ordinal_Bridge.pdf differ diff --git a/ZP-N_The_Constructive_Snap.pdf b/ZP-N_The_Constructive_Snap.pdf index a68f3fa5..0f4a388a 100644 Binary files a/ZP-N_The_Constructive_Snap.pdf and b/ZP-N_The_Constructive_Snap.pdf differ diff --git a/ZP-P_The_Fixed_Point_Fork.pdf b/ZP-P_The_Fixed_Point_Fork.pdf index c2b1924c..1b004268 100644 Binary files a/ZP-P_The_Fixed_Point_Fork.pdf and b/ZP-P_The_Fixed_Point_Fork.pdf differ diff --git a/ZP-Q_The_Frame_Change.pdf b/ZP-Q_The_Frame_Change.pdf index b98dfe5a..f3a2a029 100644 Binary files a/ZP-Q_The_Frame_Change.pdf and b/ZP-Q_The_Frame_Change.pdf differ diff --git a/ZP-R_Cross_Category_Fixed_Point.pdf b/ZP-R_Cross_Category_Fixed_Point.pdf index fd321b62..26ea5f50 100644 Binary files a/ZP-R_Cross_Category_Fixed_Point.pdf and b/ZP-R_Cross_Category_Fixed_Point.pdf differ diff --git a/ZP-R_Diagonal_Family_Addendum.pdf b/ZP-R_Diagonal_Family_Addendum.pdf index 35fceb85..b19ec3d8 100644 Binary files a/ZP-R_Diagonal_Family_Addendum.pdf and b/ZP-R_Diagonal_Family_Addendum.pdf differ diff --git a/ZP_Choice_Free_Core_Addendum.pdf b/ZP_Choice_Free_Core_Addendum.pdf index 8022397e..09d044ee 100644 Binary files a/ZP_Choice_Free_Core_Addendum.pdf and b/ZP_Choice_Free_Core_Addendum.pdf differ diff --git a/ZP_Tools_and_Methods.pdf b/ZP_Tools_and_Methods.pdf index bbbd5bb0..925fbab3 100644 Binary files a/ZP_Tools_and_Methods.pdf and b/ZP_Tools_and_Methods.pdf differ diff --git a/ZeroParadox/Algebra/Wheel.lean b/ZeroParadox/Algebra/Wheel.lean index 539dd79f..a53313b6 100644 --- a/ZeroParadox/Algebra/Wheel.lean +++ b/ZeroParadox/Algebra/Wheel.lean @@ -24,7 +24,7 @@ we're confident calling it a wheel. In particular, `inf_ne_bot` (∞ ≠ ⊥). ## Formal Overview (AI-assisted) **⚠ SCOPE OF `⊥ = {⊥}` IN THIS FILE (CC-2 convention, applied 2026-08-02).** Every occurrence below is -the **ZF+AFA metatheoretic** statement — anti-foundation's actual content, where Aczel's Quine atom is a +the **ZFC⁻ + AFA metatheoretic** statement — anti-foundation's actual content, where Aczel's Quine atom is a real object and the equation is well-formed and true. **It is never a claim about a Lean carrier.** Asserted of a carrier it would be a cross-type `=` (`bot : L` against `{bot} : Set L`), which is on the framework's bedrock-violation list. Carrier-level statements take the **instance-of-family** form the @@ -33,11 +33,10 @@ corpus already proves: `IsQuineAtom q := selfMem q ∧ ∀ x, selfMem x → x = `selfMem_eq_singleton_bot : {x | selfMemDerived x} = {bot}` as the `Set L` equality. **Do not "retire" the equation** — that would deny a true theorem of a real set theory; scope it. -**Terminology — porthole (shorthand):** The zero-infinity identification point: the -element where `val(x) = ∞` and `/x = ∞` coincide, corresponding to `⊥ = {⊥}` in -ZF+AFA and `v₂(0) = ∞` in the 2-adic valuation. In wheel theory this is the element -where `/0` is a first-class defined value rather than an error. Used throughout as -shorthand for "the ZFC/AFA contact point where these structural identifications hold." +**Three objects, named separately throughout:** the 0/∞ exchange under the wheel inverse +(`wheelInf := /0`, and `/∞ = 0` is `winv_wheelInf`); the absorbing element `0·/0` (`wheelBot`); and +the valuation condition `val(0) = ⊤` (`wvs_val_zero`, § VII). No equation across their carriers is +stated. Wheel theory (Carlström 2001:11) extends a commutative ring by making division by zero a defined first-class operation. The resulting structure has two special elements: @@ -46,14 +45,15 @@ a defined first-class operation. The resulting structure has two special element **The ZP Conjecture (see §VIII — construction now formalized in `ZeroParadox/Algebra/WheelFrac.lean`):** The wheel axioms for /0 are derivable from ring structure rather than independently -assumed, with the porthole (`val(⊥) = ∞` and `⊥ = {⊥}`) pinning the special element — -making wheel theory the algebraic representation of the porthole rather than a coincidence. +assumed, with the valuation condition `val(0) = ⊤` (`wvs_val_zero`) and `⊥ = {⊥}` (ZFC⁻ + AFA) pinning the +special element — making wheel theory the algebraic representation of the 0/∞ exchange rather than a +coincidence. **Structural alignment (not proof):** - In ZFC+Foundation: division by zero is undefined; the Axiom of Regularity prohibits x ∈ x for all sets x, ruling out self-containing elements -- In ZF+AFA: `⊥ = {⊥}` (the Quine atom) is admitted as the unique self-containing set -- In wheel theory: /0 is a first-class defined element — the porthole is structurally open +- In ZFC⁻ + AFA: the Quine atom `⊥ = {⊥}` is admitted as the unique x with x = {x} (Aczel 1988, p. 19) +- In wheel theory: /0 is a first-class defined element — the 0/∞ exchange is a defined operation **The gap:** Derivation requires ring structure not present in the current ZP typeclasses. `WheelValuationStructure` (§VII) is the intended bridge, and §VII-b is the NO-GO gauge showing it is @@ -64,7 +64,7 @@ This file: § II. Derived elements: wheelInf, wheelBot; winv_one proved abstractly § III. Concrete carrier: ZPWheelElem (ℚ extended with ∞ and ⊥ₗ) § IV. Operations and Wheel instance (all axiom proofs sorry-free) - § V. Porthole theorems: /0 = ∞, 0·/0 = ⊥ₗ (proved); § V-b, the wheel as a die face + § V. The 0/∞ exchange and the absorbing element: /0 = ∞, 0·/0 = ⊥ₗ (proved); § V-b, the wheel as a die face § VI. Connection to ValuationStructure: val(⊥) = ∞ ↔ /0 = ∞ (proved) § VII. WheelValuationStructure: the algebraic bridge (typeclass) § VII-b. NO-GO gauge: the class is degenerately inhabited; nondegeneracy as an explicit predicate @@ -76,9 +76,8 @@ construction it points to is proved in `ZeroParadox/Algebra/WheelFrac.lean` — the wheel of fractions `⊙_S A = (A × A)/≡_S` is a `Wheel` for any commutative ring `A` and multiplicative submonoid `S` (sorry-free, `Classical.choice`-free, `[propext, Quot.sound]`). §VII defines WheelValuationStructure — the typeclass identifying the bridge: a commutative -ring + multiplicative valuation with val(0) = ⊤, with the porthole (the ZF+AFA Quine atom -`⊥ = {⊥}` **motivating** val(⊥) = ∞ — see § VIII; nothing in the Lean derives it) pinning -the special element. The construction closes the construction +ring + multiplicative valuation, with val(0) = ⊤ pinning the special element (motivated by the +ZFC⁻ + AFA Quine atom `⊥ = {⊥}`, see § VIII; nothing in the Lean derives it from the Quine atom). The construction closes the construction gap; §VI closes the identification gap. The universality result previously scoped as Tier 3 (a substantial, non-near-term target) is now formalized. See notes/wheel_conjecture_proof_gap_2026-05-31.md for the original three-tier diagnosis. @@ -105,7 +104,8 @@ open ZeroParadox the construction of fields of fractions from integral domains so that wheels are obtained instead of fields"*; and *"In this paper, we generalize Setzer's construction, so that it applies not only to integral domains, but to any commutative semiring."* This file follows - Carlström's Definition 1.1, which is the general one. + Carlström's Definition 1.1, which is the general one. (`[Set97]` is Carlström's key for + A. Setzer, *Wheels* (draft), 1997, in his bibliography.) The axiom fields below are exactly Carlström's eight Definition 1.1 axioms, with his two "commutative monoid" axioms unbundled into their separate equational laws: @@ -175,11 +175,11 @@ section WheelBasic variable {W : Type*} [Wheel W] /-- wheelInf: the infinite element /0. Conjectured ZP counterpart: the algebraic - expression of `val(⊥) = ∞` at the porthole — see §VIII for status. -/ + expression of `val(⊥) = ∞` — see §VIII for status. -/ def wheelInf : W := Wheel.winv (Wheel.wzero) /-- wheelBot: the absorbing bottom element 0·/0. Conjectured ZP counterpart: the - algebraic expression of `⊥ = {⊥}` at the porthole — see §VIII for status. -/ + algebraic expression of `⊥ = {⊥}` (ZFC⁻ + AFA) — see §VIII for status. -/ def wheelBot : W := Wheel.wmul (Wheel.wzero) (Wheel.winv (Wheel.wzero)) /-- /(∞) = 0: applying / to wheelInf returns wzero. -/ @@ -209,7 +209,8 @@ end WheelBasic -- ============================================================ /-- The ZP wheel carrier: rationals extended with ∞ (= /0) and ⊥ₗ (= 0·/0). - This is the minimal type witnessing that the ZP porthole structure forms a wheel. + This is the minimal type witnessing that the 0/∞ exchange and the absorbing element 0·/0 sit + together in a wheel. ⚠ **Not new, and it is the ORIGINAL example rather than a general one.** `ℚ ∪ {∞, ⊥}` is Carlström 2001:11's own first listed example — *"`⊙_{ℤ\{0}}ℤ = ℚ ∪ {/0, 0/0}`"* (printed p. 6, @@ -218,12 +219,14 @@ end WheelBasic A \ {0}"* (printed p. 3). What is contributed here is the machine-checked encoding and the ZP reading below, never the object. - - `bot`: 0 · /0 — the absorbing undefined element (ZP: the porthole; the algebraic counterpart + - `bot`: 0 · /0 — the absorbing undefined element (ZP: the algebraic counterpart of the Quine-atom role, not an identity with it — different types) - - `fin q`: a finite rational (ZP: nonzero states for q ≠ 0; q = 0 is the semilattice ⊥) + - `fin q`: a finite rational (ZP: nonzero states for q ≠ 0; q = 0 is ℚ's zero, least under |·| + and under the 2-adic norm, greatest under the 2-adic valuation preorder, and not + least in ℚ's field order; `z2_two_views` states the two 2-adic readings on ℤ_[2]) - `inf`: /0 = ∞ — the infinite element (ZP: v₂(0) = ∞) - The porthole is the identification fin(0) ↔ inf via winv: + The 0/∞ exchange is fin(0) ↔ inf via winv: winv (fin 0) = inf and winv inf = fin 0. -/ inductive ZPWheelElem where | bot : ZPWheelElem @@ -241,7 +244,7 @@ inductive ZPWheelElem where def zpwAdd : ZPWheelElem → ZPWheelElem → ZPWheelElem | .bot, _ => .bot | .inf, .bot => .bot - | .inf, .inf => .bot -- ∞ + ∞ = ⊥ (undefined sum at the porthole) + | .inf, .inf => .bot -- ∞ + ∞ = ⊥ₗ, the absorbing element 0·/0 | .inf, .fin _ => .inf | .fin _, .bot => .bot | .fin _, .inf => .inf @@ -342,10 +345,10 @@ instance : Wheel ZPWheelElem where cases x <;> simp [zpwAdd, zpwMul, zpwInv] -- ============================================================ --- § V. Porthole Theorems (proved without sorry) +-- § V. The 0/∞ Exchange and the Absorbing Element (proved without sorry) -- ============================================================ -/-- /0 = ∞: the porthole identification in algebraic form, proved for ZPWheelElem. +/-- /0 = ∞: the 0/∞ exchange in algebraic form, proved for ZPWheelElem. Conjectured ZP counterpart: corresponds to val(⊥) = ∞ — see §VIII for status. -/ theorem zpw_inv_zero_eq_inf : zpwInv (.fin 0) = .inf := by simp [zpwInv] @@ -355,15 +358,15 @@ theorem zpw_inv_zero_eq_inf : zpwInv (.fin 0) = .inf := by theorem zpw_zero_mul_inf_eq_bot : zpwMul (.fin 0) .inf = .bot := by simp [zpwMul] -/-- ∞ · 0 = ⊥ₗ: commutativity of the porthole identification. -/ +/-- ∞ · 0 = ⊥ₗ: the absorbing-element identity with the factors swapped. -/ theorem zpw_inf_mul_zero_eq_bot : zpwMul .inf (.fin 0) = .bot := by simp [zpwMul] -/-- /∞ = 0: the porthole is symmetric — /(/0) = 0 as expected from W7. -/ +/-- /∞ = 0: the 0/∞ exchange runs both ways — /(/0) = 0 as expected from W7. -/ theorem zpw_inv_inf_eq_zero : zpwInv .inf = .fin 0 := by simp [zpwInv] -/-- ∞ ≠ ⊥ₗ: the two portal elements stay distinct — wheel behaviour, not meadow collapse. +/-- ∞ ≠ ⊥ₗ: the infinite element /0 and the absorbing element 0·/0 stay distinct — wheel behaviour, not meadow collapse. Identifying them would force triviality (Carlström 2001:11, Prop. 4.4). -/ theorem zpw_inf_ne_bot : ZPWheelElem.inf ≠ .bot := by simp @@ -460,11 +463,11 @@ example : ¬ (∀ x y z : ZPWheelElem, have hx : zpwMul (zpwAdd (ZPWheelElem.fin 1) (.fin 0)) .inf = zpwAdd (zpwMul (ZPWheelElem.fin 1) .inf) (zpwMul (.fin 0) .inf) := h (.fin 1) (.fin 0) .inf - norm_num [zpwAdd, zpwMul] at hx + simp only [zpwAdd, zpwMul, add_zero, one_ne_zero, ite_false, ite_true] at hx exact zpw_inf_ne_bot hx -/-- fin(0) ≠ ⊥ₗ: the semilattice ⊥ is distinct from the wheel's absorbing element. - Algebraically: the porthole contact point (fin 0 ↔ inf) is not confusion with ⊥ₗ. -/ +/-- fin(0) ≠ ⊥ₗ: `fin 0`, ℚ's zero, is distinct from the wheel's absorbing element ⊥ₗ. + Algebraically: the 0/∞ exchange (fin 0 ↔ inf) does not pass through ⊥ₗ. -/ theorem zpw_zero_ne_bot : ZPWheelElem.fin 0 ≠ .bot := by simp @@ -492,6 +495,12 @@ theorem wheelBot_absorbs {W : Type*} [Wheel W] : rw [hz, Wheel.wadd_comm] exact Wheel.wadd_zeroinv_absorb z +/-- `Statement:` in every wheel, under `a → a + z` only `0·/0` steps only to itself. -/ +theorem wheelBot_addSelfOnly_unique {W : Type*} [Wheel W] (y : W) + (hy : (Motion.ofTotal (id : W → W) (fun _ => rfl) + (fun a b => ∃ z, b = Wheel.wadd a z)).SelfOnlyAt y) : y = wheelBot := + (hy.2 _ (wheelBot_absorbs.2 y)).symm + /-- `Statement:` on `ZPWheelElem` that step goes `0 → 1` and `1 → 0`, so under no partial order does it raise, and under none does it lower. -/ theorem zpw_addStep_no_polarity (o : PartialOrder ZPWheelElem) : @@ -511,14 +520,14 @@ theorem zpw_addStep_no_polarity (o : PartialOrder ZPWheelElem) : -- § VI. Connection to ValuationStructure -- ============================================================ -/-- The valuation on ZPWheelElem: fin(0) has infinite valuation (the porthole), +/-- The valuation on ZPWheelElem: fin(0) has infinite valuation (the condition val(0) = ⊤), all other finite rationals have valuation 1, bot and inf have valuation 0. -/ def zpwVal : ZPWheelElem → ℕ∞ | .bot => 0 | .inf => 0 | .fin q => if q = 0 then ⊤ else 1 -/-- val(fin 0) = ∞: the porthole identification in valuative form. +/-- val(fin 0) = ∞: the valuation condition val(0) = ⊤ on this carrier. This is the algebraic counterpart of ValuationStructure.val_bot. -/ theorem zpwVal_zero_eq_top : zpwVal (.fin 0) = ⊤ := by simp [zpwVal] @@ -530,7 +539,7 @@ theorem zpwVal_inv_zero : zpwVal (zpwInv (.fin 0)) = 0 := by simp [zpwInv, zpwVal] /-- For ZPWheelElem: the element with infinite valuation (fin 0) is exactly the element - whose wheel-inverse is ∞ (inf). This proves the porthole correspondence concretely: + whose wheel-inverse is ∞ (inf). This ties val(0) = ⊤ to the 0/∞ exchange concretely: val(x) = ⊤ ↔ winv(x) = ∞ holds in ZPWheelElem. The abstract version — that this holds in any wheel satisfying the ZP structural constraints — is the content of the §VIII conjecture. -/ @@ -552,7 +561,7 @@ theorem zpw_top_val_iff_inv_is_inf (x : ZPWheelElem) : satisfying val(0) = ⊤. This typeclass identifies the bridge needed to close the structural gap between the ZP typeclasses and Wheel theory. - **The "infinitudes of zero" argument** motivates the porthole condition val(0) = ⊤ from the + **The "infinitudes of zero" argument** motivates the condition val(0) = ⊤ from the self-referential structure of the bottom. It is a **motivation, not a derivation**: the condition is an assumed field here, and it is an assumed field under the standard structure too (see the PRIOR ART block below). Val(⊥) = ∞ is the algebraic signature of the Quine atom: @@ -589,7 +598,7 @@ theorem zpw_top_val_iff_inv_is_inf (x : ZPWheelElem) : sentence across successive revisions, each of which fixed the arithmetic while leaving the ordering claim in place.)* - **And the porthole condition is NOT discharged by adopting the standard structure.** `map_zero'` + **And the condition val(0) = ⊤ is NOT discharged by adopting the standard structure.** `map_zero'` is a structure *field* (reached via `Valuation` → `MonoidWithZeroHom` → `ZeroHom`; `AddValuation.map_zero` is the projection — **not** the `map_zero'` assignment inside `AddValuation.of`, which is a different thing), and `ZeroParadox/Valuation/FloorWitness.lean`'s `addVal_bot` @@ -600,7 +609,7 @@ theorem zpw_top_val_iff_inv_is_inf (x : ZPWheelElem) : of also assuming the ultrametric inequality; that trade is **not** made here. However, the "infinitudes of zero" argument works at the *identification* layer — - it tells you which element plays the porthole role. To *construct* a Wheel from + it tells you which element carries val = ⊤ and is sent to ∞ by the wheel inverse. To *construct* a Wheel from this requires binary multiplication. ValuationStructure supplies only `scale : L → L` (a unary endomorphism, "multiply by p"), not a binary product. WheelValuationStructure closes this gap by adding ring structure explicitly. @@ -610,12 +619,12 @@ theorem zpw_top_val_iff_inv_is_inf (x : ZPWheelElem) : (the submonoid-quotient relation; naive cross-multiplication `a·d = b·c` is *not* an equivalence on a general commutative ring — transitivity fails without cancellation) yields a Wheel instance where: - - wzero = [0, 1] — porthole element + - wzero = [0, 1] — the zero that winv sends to ∞ = [1, 0] - winv([a, b]) = [b, a] — involution is pair-swap - wmul([a,b],[c,d]) = [a·c, b·d] — inherited from ring multiplication The wheel axioms (Carlström Def 1.1) follow from the ring axioms on L plus the submonoid structure of S. This construction is now formalized in `ZeroParadox/Algebra/WheelFrac.lean` (`instWheel`) — the - Tier 3 result of the porthole conjecture (§VIII). -/ + Tier 3 result of the wheel conjecture (§VIII). -/ -- [ZP-CUSTOM] incomparable with: Mathlib `AddValuation A ℕ∞` (RingTheory/Valuation/Basic.lean) | reason: -- INCOMPARABLE, not ordered — it drops `map_one'` AND the ultrametric `map_add_le_max'`, so it is not a -- reduct by one axiom; but `AddValuation` needs only `[Ring R]` while this class @@ -631,13 +640,13 @@ theorem zpw_top_val_iff_inv_is_inf (x : ZPWheelElem) : -- does not have — so do not describe `WVSNondegenerate` in terms of `supp`. It is also NOT -- `Valuation.IsNontrivial` (`∃ x, v x ≠ 0 ∧ v x ≠ 1`, two conjuncts, strictly stronger).) class WheelValuationStructure (L : Type*) extends CommRing L where - /-- The porthole valuation: measures proximity to the porthole element. -/ + /-- The valuation: `wvs_val_zero` below makes it ⊤ at the ring's zero. -/ wvs_val : L → ℕ∞ /-- Multiplicativity: val is a semiring homomorphism to (ℕ∞, +). -/ wvs_val_mul : ∀ x y : L, wvs_val (x * y) = wvs_val x + wvs_val y - /-- Porthole condition: val(0_L) = ⊤. This is an axiom — an assumed requirement, + /-- The condition val(0_L) = ⊤. This is an axiom — an assumed requirement, not a derived result. The motivation: in ZP-compatible extensions the ring's zero is intended to - **play the Quine-atom role** (`IsQuineAtom`, the family predicate — not to *be* the ZF+AFA Quine + **play the Quine-atom role** (`IsQuineAtom`, the family predicate — not to *be* the ZFC⁻ + AFA Quine atom, which lives in a different type), and anything in that role has infinite valuation; this axiom encodes that as a formal requirement on any instance. The ZP argument motivates the choice; the type-checker does not verify the necessity. -/ @@ -652,8 +661,9 @@ class WheelValuationStructure (L : Type*) extends CommRing L where **Nothing depends on this class.** Outside this gauge no theorem takes `[WheelValuationStructure L]` and no instance is registered; the wheel is carried by `Algebra/WheelFrac.lean`'s `instWheel` over `[CommRing A]` plus a submonoid. So the defect below is preventive, not propagating, and the -published ZP-J addendum already says so — *"Ring structure is an input, not a conclusion"*, -`scripts/build_zpj_wheel_addendum.py:264`, the tracked script `register.md` fingerprints. +published ZP-J addendum already says so — *"Ring structure is an input, not a conclusion"* +(`ZP-J_Wheel_Addendum.pdf`, Section V, built by `scripts/build_zpj_wheel_addendum.py`, the tracked +script `register.md` fingerprints). Mirrors `Computability/SelfApp.lean`'s `trivialSelfApp`: a warning comment is not checkable, an inhabiting term is. -/ @@ -708,7 +718,7 @@ theorem collapse_from_unit {L : Type*} [W : WheelValuationStructure L] /-- `Statement:` `WVSNondegenerate L ↔ wvs_val 1 ≠ ⊤` — nondegeneracy is a fact about the unit alone. ⚠ Use this form, not `nondegenerate_iff_map_one`, in anything that must stay axiom-free: same - content, and only this one avoids the `ℕ∞` numeral. -/ + content, and this one measures no axioms where that one measures `[propext, Quot.sound]` (§ IX). -/ theorem nondegenerate_iff_unit_ne_top (L : Type*) [W : WheelValuationStructure L] : WVSNondegenerate L ↔ W.wvs_val 1 ≠ ⊤ := ⟨fun ⟨x, hx⟩ h1 => hx (collapse_from_unit h1 x), fun h => ⟨1, h⟩⟩ @@ -748,7 +758,7 @@ theorem nondegenerate_iff_map_one (L : Type*) [W : WheelValuationStructure L] : is nondegenerate, and still sends `2 ↦ ⊤` with `2 ≠ 0`. So a nondegenerate `WheelValuationStructure` is **not** an `AddValuation`: nondegeneracy restores - `map_one` and leaves the ultrametric axiom absent, and a porthole valuation in the intended sense + `map_one` and leaves the ultrametric axiom absent, and the valuation the motivation intends is strictly stronger than both. Anonymous, so it declares nothing and owes no registry row. -/ example : ∃ W : WheelValuationStructure ℤ, @WVSNondegenerate ℤ W ∧ ∃ x : ℤ, x ≠ 0 ∧ W.wvs_val x = ⊤ := by @@ -767,15 +777,40 @@ example : ∃ W : WheelValuationStructure ℤ, · show (if (2 : ℤ) % 2 = 0 then (⊤ : ℕ∞) else 0) = ⊤ norm_num +-- `Statement:` for a multiplicative map into `ℕ∞`, `v 0 = ⊤` holds exactly when some element has +-- valuation other than `0`: `v 0 = v (0 * x) = v 0 + v x` with `v x ≠ 0` forces `v 0 = ⊤`, and +-- conversely `x := 0` serves. So given `wvs_val_mul` the field `wvs_val_zero` says exactly that +-- `wvs_val` is not the zero map. Stated for a bare map, so it does not consume `wvs_val_zero`. +example {L : Type*} [MulZeroClass L] (v : L → ℕ∞) + (hmul : ∀ x y : L, v (x * y) = v x + v y) : v 0 = ⊤ ↔ ∃ x : L, v x ≠ 0 := by + refine ⟨fun h => ⟨0, by rw [h]; exact ENat.top_ne_zero⟩, fun h => ?_⟩ + obtain ⟨x, hx⟩ := h + have h0 := hmul 0 x + rw [zero_mul] at h0 + generalize v 0 = a at h0 ⊢ + generalize v x = b at h0 hx + induction a using ENat.recTopCoe with + | top => rfl + | coe n => + exfalso + induction b using ENat.recTopCoe with + | top => simp at h0 + | coe m => + have hnm : n = n + m := by exact_mod_cast h0 + exact hx (by rw [show m = 0 by omega]; rfl) + +-- `Statement:` the control on the `example` above: without an element of nonzero valuation the +-- condition fails. The zero map on `ℤ` is multiplicative and sends `0` to `0`, not `⊤`. +example : ∃ v : ℤ → ℕ∞, (∀ x y : ℤ, v (x * y) = v x + v y) ∧ v 0 ≠ ⊤ := + ⟨fun _ => 0, fun _ _ => by simp, by simp⟩ + /-! **Axiom footprint**, checked by § IX rather than asserted here. Six of the seven gauge -declarations are axiom-free; `nondegenerate_iff_map_one` reports `[propext, Classical.choice, -Quot.sound]` — and that footprint is carried by the STATEMENT, not the proof. -⚠ The two `nondegenerate_iff_*` theorems are the measurement: same fact, same file, same style, only -the second writing the `ℕ∞` numeral `0`. Measured 2026-09-12 in this pinned Mathlib — at `ℕ∞`, -`(⊤ : ℕ∞) = ⊤`, `((n : ℕ) : ℕ∞) = n` and `a + b = a + b` are each axiom-free by `rfl`, while -`(0 : ℕ∞) = 0` and `(1 : ℕ∞) = 1` by `rfl` each report the same triple. Scope: those five `rfl`s; no -claim about which instance declaration carries it. `ZeroParadox/Ordinal/SyntacticCollapse.lean` -records the same shape on `ℚ`. -/ +declarations are axiom-free; `nondegenerate_iff_map_one` reports `[propext, Quot.sound]`, and none of +the seven carries `Classical.choice`. +⚠ The two `nondegenerate_iff_*` theorems state the same fact, the second writing the `ℕ∞` numeral `0`. +At the pinned Mathlib the numerals `(0 : ℕ∞)` and `(1 : ℕ∞)` measure no axioms +(`ZeroParadox/Valuation/PricedPadicInterface.lean` § IV prints them), so the numeral does not account +for the difference between the two footprints. -/ -- ============================================================ -- § VIII. The Main Conjecture (Resolved) @@ -783,13 +818,15 @@ records the same shape on `ℚ`. -/ /-! ### Resolution -A documentation anchor; no theorem object. The conjecture — that the ZP porthole forces the wheel +A documentation anchor; no theorem object. The conjecture — that the 0/∞ exchange with val(0) = ⊤ forces the wheel axioms — is proved in `ZeroParadox/Algebra/WheelFrac.lean` (`instWheel`, `inf_ne_bot`), not importable here without a cycle; concretely for this carrier, `zpw_top_val_iff_inv_is_inf` (§VI). Two gaps, and only one closes. "Infinitudes of zero" closes the IDENTIFICATION gap — which element -plays the porthole role — leaving `wvs_val 0 = ⊤` an assumed class field, motivated and not forced -(§VII). It does not close the CONSTRUCTION gap: `scale` is unary and `wmul` binary, so ring structure +carries val = ⊤ — leaving `wvs_val 0 = ⊤` an assumed class field, motivated and not forced +(§VII), and recoverable from `wvs_val_mul` once some element has valuation other than `0` (the +second and third `example`s after `nondegenerate_iff_map_one`: `v 0 = ⊤ ↔ ∃ x, v x ≠ 0` for a +multiplicative map, and its zero-map control). It does not close the CONSTRUCTION gap: `scale` is unary and `wmul` binary, so ring structure is the missing hypothesis (the `WithTop L` + `selfApp` route does not close). Read § VII-b first. -/ -- ============================================================ @@ -806,6 +843,7 @@ section PurityCheck #print axioms zpw_top_val_iff_inv_is_inf #print axioms wheelBot_selfOnlyAt_winv #print axioms wheelBot_absorbs +#print axioms wheelBot_addSelfOnly_unique #print axioms zpw_addStep_no_polarity -- § VII-b NO-GO gauge. The footprint block there asserts nothing; it is checked here. -- Six axiom-free, and `nondegenerate_iff_map_one` is the one that is not — read the two diff --git a/ZeroParadox/Algebra/WheelFrac.lean b/ZeroParadox/Algebra/WheelFrac.lean index 7c629684..9af8ffcb 100644 --- a/ZeroParadox/Algebra/WheelFrac.lean +++ b/ZeroParadox/Algebra/WheelFrac.lean @@ -13,7 +13,7 @@ A ZP-J wheel sub-file. See the Engineer's Take in `ZeroParadox/Algebra/Wheel.lea ## Formal Overview `⊙_S A = (A × A) / ≡_S`, giving `/0 = ∞` and `0·/0 = ⊥` with `∞ ≠ ⊥` — the wheel, not the meadow, -matching the ZP porthole. **Status: complete**, `sorry`-free, every `Wheel` axiom; `instWheel` and +with the infinite element /0 and the absorbing element 0·/0 kept apart. **Status: complete**, `sorry`-free, every `Wheel` axiom; `instWheel` and `inf_ne_bot` are `Classical.choice`-free (`[propext, Quot.sound]`). Construction and argument: `ZeroParadox/Algebra/WheelFrac.md`. -/ @@ -141,8 +141,8 @@ instance instWheel : Wheel (WheelFrac S) where induction x using Quotient.inductionOn with | _ a => apply Quotient.sound; refine ⟨1, S.one_mem, 1, S.one_mem, ?_, ?_⟩ <;> ring -/-- Porthole: in `⊙_S A`, the infinity element `/0` and the bottom `0·/0` are distinct — the wheel - (not meadow) behaviour, matching the ZP porthole `∞ ≠ ⊥`. -/ +/-- In `⊙_S A`, the infinity element `/0` and the absorbing element `0·/0` are distinct — the wheel + (not meadow) behaviour, `∞ ≠ ⊥ₗ`. -/ theorem inf_ne_bot (h0 : (0 : A) ∉ S) : wheelInf (W := WheelFrac S) ≠ wheelBot := by intro h obtain ⟨s, hs, s', hs', e1, _⟩ := Quotient.exact h @@ -152,9 +152,9 @@ theorem inf_ne_bot (h0 : (0 : A) ∉ S) : wheelInf (W := WheelFrac S) ≠ wheelB /-! ## § The involutive fork, and why it does NOT unify with the ordered μ/ν fork `fixed_pole_forces_collapse` below witnesses the involutive-fork-with-a-fixed-pole row of the wall -taxonomy: **if the involution fixes the pole, the two poles coincide.** ⚠ That is a much SMALLER -statement than Carlström Prop. 4.4 off the same antecedent — do not present the collapse as a framework -finding. Why the two forks are different species, the prior art and the standard names: `ZeroParadox/Algebra/WheelFrac.md`. -/ +taxonomy (`ZeroParadox/Settheory/Wall.md`): **if the involution fixes the pole, the two poles +coincide.** ⚠ That is a much SMALLER statement than Carlström Prop. 4.4 off the same antecedent — do +not present the collapse as a framework finding. Why the two forks are different species, the prior art and the standard names: `ZeroParadox/Algebra/WheelFrac.md`. -/ /-- An **involutive fork**: an involution `dual` together with two poles it swaps. The wheel / Riemann fork (`z ↦ 1/z` swapping `0 ↔ ∞`) is the motivating instance. @@ -212,13 +212,22 @@ theorem wheelFrac_fork_open (h0 : (0 : A) ∉ S) : have hs'0 : s' = 0 := by simpa using e1.symm exact h0 (hs'0 ▸ hs') -/-- Restated through the abstraction: the wheel-of-fractions `InvolutiveFork` is NOT collapsed. So - `InvolutiveFork` is a non-vacuous abstraction with a concrete, provably-open, choice-free - instance — it is not a gauge that everything satisfies. -/ +/-- Restated through the abstraction: the wheel-of-fractions `InvolutiveFork` is NOT collapsed, so + `Collapsed` is not a property every `InvolutiveFork` has: this instance is provably open and + choice-free. `InvolutiveFork α` itself is inhabited on every inhabited `α` and on no empty one + (the two `example`s after this theorem). -/ theorem wheelFork_not_collapsed (h0 : (0 : A) ∉ S) : ¬ (wheelFork (WheelFrac S)).Collapsed := wheelFrac_fork_open S h0 +-- Statement: every inhabited type carries an `InvolutiveFork` (the identity, both poles at one point). +example {α : Type*} (a : α) : InvolutiveFork α := + ⟨id, fun _ => rfl, a, a, rfl⟩ + +-- Statement: control, no empty type carries one. +example {α : Type*} [IsEmpty α] : IsEmpty (InvolutiveFork α) := + ⟨fun F => IsEmpty.false F.pole₀⟩ + /-- **The obstruction, Lean-witnessed.** An involutive fork whose pole is a FIXED point of the involution — the ordered-fork condition — is necessarily COLLAPSED. Hence the involutive and ordered forks coincide only at the diagonal point: they are different species. This is the diff --git a/ZeroParadox/Algebra/WheelFrac.md b/ZeroParadox/Algebra/WheelFrac.md index fa34a974..37140b85 100644 --- a/ZeroParadox/Algebra/WheelFrac.md +++ b/ZeroParadox/Algebra/WheelFrac.md @@ -6,8 +6,10 @@ declarations, the Engineer's Take and the per-declaration glosses. ## The construction The wheel of fractions of a commutative ring `A` with respect to a multiplicative submonoid `S`, built -to prove it is a `Wheel` (`ZeroParadox/Algebra/Wheel.lean`). This turns that file's §VIII conjecture -into a theorem. +to prove it is a `Wheel` (`ZeroParadox/Algebra/Wheel.lean`). `instWheel` proves the part of that +file's conjecture that starts from ring structure: for every commutative ring and submonoid, the wheel +axioms hold. Ring structure is an input, not derived; `ZeroParadox/Algebra/Wheel.lean` § VIII, a +documentation anchor with no theorem object, records what stays open. Carlström, source-verified: `⊙_S A = (A × A) / ≡_S`, where @@ -15,7 +17,8 @@ Carlström, source-verified: `⊙_S A = (A × A) / ≡_S`, where with `0 = [0,1]`, `1 = [1,1]`, `[x,y] + [x',y'] = [x·y' + x'·y, y·y']`, `[x,y]·[x',y'] = [x·x', y·y']`, and `/[x,y] = [y,x]`. Then `/0 = [1,0] = ∞`, `0·/0 = [0,0] = ⊥`, with `∞ ≠ ⊥` (the wheel, not the -meadow) — matching the ZP porthole. +meadow): the 0/∞ exchange and the absorbing element, the objects `ZeroParadox/Algebra/Wheel.lean`'s +Formal Overview names. **Status: complete.** Fully `sorry`-free: `≡_S` is an equivalence, the five operations are well-defined on the quotient, every axiom of the ZP `Wheel` typeclass holds (a faithful encoding of Carlström's @@ -25,7 +28,8 @@ on the quotient, every axiom of the ZP `Wheel` typeclass holds (a faithful encod ## The involutive fork, and why it does NOT unify with the ordered μ/ν fork `fixed_pole_forces_collapse` is the witness for the involutive-fork-with-a-fixed-pole row of the wall -taxonomy: **if the involution fixes the pole, the two poles coincide.** +taxonomy (`ZeroParadox/Settheory/Wall.md`, the failure-mode table): **if the involution fixes the pole, +the two poles coincide.** The two forks are **different species**: @@ -48,6 +52,11 @@ CATEGORY, dualizing μ↔ν, while inversion acts on the ELEMENT set, swapping 0 ## Prior art — Carlström § 4 proves MORE +Locators below are to J. Carlström, *Wheels — On Division by Zero*, Research Reports in Mathematics +No. 11, Department of Mathematics, Stockholm University, 2001 (cited here as Carlström 2001:11). The +later journal version, *Mathematical Structures in Computer Science* 14(1):143–184, 2004, paginates +differently, and these locators do not apply to it. + The specific result is **Prop. 4.4** (Carlström 2001:11, PDF p. 27, printed p. 25): *"If any two of the elements 0, 1, /0 and 0/0 are equal in a wheel H, then H is trivial."* @@ -70,8 +79,9 @@ corpus uses. The substance — `0 ∈ S` trivializes, so exclude it — is his. ⚠ **The construction's lineage runs through Setzer.** Carlström credits him for the name and the construction at printed p. 3 and presents his own paper as a generalisation from integral domains to any -commutative semiring — so "Carlström's" here means that general form, which is the one this file -formalizes. The quotations and the full credit chain are in `ZeroParadox/Algebra/Wheel.lean` +commutative semiring — so "Carlström's" here means that general form. This file formalizes the +commutative-ring case (`[CommRing A]` in `ZeroParadox/Algebra/WheelFrac.lean`), a special case of his semiring +generality. The quotations and the full credit chain are in `ZeroParadox/Algebra/Wheel.lean` § "Lineage" (the `Wheel` class docstring). ## Standard names for what is written by hand @@ -101,9 +111,9 @@ originals before citing them directly. Searched 2026-08-02: no prior art located Until this date `InvolutiveFork` had a witness for exactly one of its two states. `wheelFork_not_collapsed` inhabits the OPEN side; nothing inhabited the COLLAPSED one, so `fixed_pole_forces_collapse` had **no -witness for its own hypothesis** and could have been true vacuously for all the corpus showed. `R-TWOPOLE` -is the rule that asks for both; the gap survived because the open side's docstring defends non-vacuity -convincingly and one pole reads as enough. +witness for its own hypothesis** and could have been true vacuously for all the corpus showed. The +project's rule is to build a witness on both sides; the gap survived because the open side's docstring +defends non-vacuity convincingly and one pole reads as enough. Mathlib supplies the missing one and no construction is needed. `inv_zero` — the junk-value convention `(0 : G)⁻¹ = 0` on any `GroupWithZero` — **is** the fixed-pole condition, and `inv_inv` is the involution @@ -111,8 +121,8 @@ law. So the example takes `dual := Inv.inv`, `pole₀ := 0`, and discharges `Col ⚠ **`dual` and `pole₀` are pinned in the statement**, mirroring `Wheel.lean`'s `gauge_strong`. The bare `∃ F, F.Collapsed` is satisfied on any inhabited type by the identity involution at a single point, so it -would witness nothing — the genericity trap `R-TOLEAN` names. Pinning is what makes the existential say -something about *inversion* rather than about *forks*. +would witness nothing. Pinning is what makes the existential say something about *inversion* rather +than about *forks*. **The reading.** This is what totalising division looks like when you adjoin nothing: the reciprocal of zero lands on the zero already there, so the fork's two ends are the same point and there is no distinct @@ -126,18 +136,24 @@ distributivity. `ZeroParadox/Algebra/Wheel.lean` § V carries both directions of deals — the forward leg (identifying `∞` with `⊥` forces triviality) and the reverse (the meadow equation `/0 = 0` forces triviality), each with controls showing the hypotheses are load-bearing on `ZPWheelElem`. -⚠ **Not a claim that a meadow is a collapsed wheel.** It is not: a meadow stays a commutative ring, and -`ZPWheelElem` is not one. The shared object is the `InvolutiveFork` abstraction, which both instantiate -with opposite verdicts. Bergstra and Ponse (1406.6878, § 4 "Concluding Remarks", printed p. 14) write -that *"we have not yet found a structural connection"* between wheels and **common** meadows — their -own first-person hedge, not a settled negative. Common meadows are the NON-involutive ones, where `0⁻¹` -is a separate error element, so they are a different pair from the involutive meadow (`0⁻¹ = 0`, -BHT 0901.0823) this paragraph is built on — involutivity being exactly what separates them. Nothing -here supplies a connection on either pair. - -## Unstated adjacency — five involution declarations under four names, none wired up as of 2026-09-25 +⚠ **Not a claim that a meadow is a collapsed wheel.** A wheel with `/0 = 0` is trivial (the reverse-leg +`example` in `ZeroParadox/Algebra/Wheel.lean` § V, Carlström's Prop. 4.4), so an involutive meadow +(`0⁻¹ = 0`) with more than one element is never one; the one-element carrier is both, and § V states +that overlap. The shared +object is +the `InvolutiveFork` abstraction, which both instantiate with opposite verdicts. Bergstra and Ponse +(1406.6878, § 4 "Concluding Remarks", printed p. 14) write that *"we have not yet found a structural connection"* between wheels and **common** meadows — their +own first-person hedge, not a settled negative. Common meadows are non-involutive, with `0⁻¹` a +separate error element (in Bergstra and Ponse's fracpairs over a reduced commutative ring every `x/0` is equivalent to +`0/0`: arXiv:1411.4410, Prop. 2.1.2, printed p. 4, so `/0` and `0·/0` are one element there, where the +wheel keeps them apart), so they are a different pair from the involutive meadow (`0⁻¹ = 0`, +BHT 0901.0823) this paragraph is built on. Common meadows are not the only non-involutive kind: +Bergstra & Middelburg (arXiv:1406.2092, p. 2) study "one-based non-involutive meadows", where the +inverse of zero is one, an element already present, so being non-involutive alone does not single out common +meadows. Nothing here supplies a connection on either pair. + +## Unstated adjacency — involution declarations not wired up as of 2026-09-25 -**The unit is the DECLARATION, not the identifier: five declarations, four distinct names.** `rInv_involutive` + `rInv_swaps` (`ZeroParadox/Valuation/RiemannSphere.lean`) is the Riemann fork the `InvolutiveFork` docstring calls "the motivating instance"; also `flipPoles_involutive` (`ZeroParadox/Computability/Occurrence.lean` — stated pointwise rather than as `Function.Involutive`), @@ -145,7 +161,10 @@ here supplies a connection on either pair. at two sites (`ZeroParadox/Valuation/PoleCorners.lean`, `ZeroParadox/Miniature.lean`). Searched 2026-09-25 over `ZeroParadox/**/*.lean` and the tracked `.md`: the only `InvolutiveFork` instances located are `wheelFork` and the `GroupWithZero` example, both in `ZeroParadox/Algebra/WheelFrac.lean`, -so none of the five is wired up. **Not a closed list of the corpus's involutions** — the same sweep for +so none of these is wired up. **Not a closed list of the corpus's involutions** — the same sweep for `Function.Involutive` also returns `σ_involutive` (`ZeroParadox/Computability/MarkovNuUniversal.lean`), an involution but not a pole exchange. Wiring any -of them is a pointer exercise, not new declarations. +of them is a pointer exercise, not new declarations. Since that search, +`ZeroParadox/Algebra/WheelFrac.lean` has also gained the identity-fork `example` after +`wheelFork_not_collapsed`: a generic witness on any inhabited type, and not one of the declarations +listed here. diff --git a/ZeroParadox/AxiomProfile.lean b/ZeroParadox/AxiomProfile.lean index fb2c792c..d7737dd8 100644 --- a/ZeroParadox/AxiomProfile.lean +++ b/ZeroParadox/AxiomProfile.lean @@ -51,7 +51,7 @@ required in places... the heart of what we're trying to prove is choice free. A **checkable artifact** (`lake build ZeroParadox.AxiomProfile`): the `#print axioms` output reports each result's complete axiom dependency. **The core is choice-free; T-SNAP depends on no axioms at -all.** Choice appears mostly in the realization layers, mostly inherited from Mathlib, and in the +all.** Choice appears mainly in the realization layers, largely inherited from Mathlib, and in the die (`ZeroParadox/Die.lean`), both its own and inherited; where it is essential, and on what premise: `ZeroParadox/Category/ChoiceCannotBe.lean` § IV, whose cases § 0 prints. -/ diff --git a/ZeroParadox/AxiomProfile.md b/ZeroParadox/AxiomProfile.md index 1fa11fd0..6a63f3ff 100644 --- a/ZeroParadox/AxiomProfile.md +++ b/ZeroParadox/AxiomProfile.md @@ -54,13 +54,15 @@ decision of where UP is defined (`Motion.registeredDecidable_of_classical`) and (`Motion.selectedTotal_of_classical`, whose proof also calls `Classical.choose` directly), all in `ZeroParadox/Die.lean`. -**Inherited, in the die:** `Motion.RegisteredComputable` (a definition, so its statement), -`registeredDecidable_of_registeredComputable`, `registeredComputable_of_upTotal` and -`ofOption_registeredComputable` each measure `[propext, Classical.choice, Quot.sound]`. The choice -enters through Mathlib's `Bool` encoding instance `Primcodable.bool`, which stating `Computable d` -for a `Bool`-valued `d` uses; `Computable` itself is choice-free. A theorem that only assumes `M.RegisteredComputable`, or only -`∃ d : ℕ → Bool, Computable d`, reports the same (statement control, 2026-10-18), so that variant is -**statement-carried**. +**Inherited, in the die:** `Motion.RegisteredComputable` and the theorems stated with it; their +footprints are printed in the purity block of `ZeroParadox/Die.lean`. `Motion.RegisteredComputable` +is a definition whose value is its statement, so its printed footprint is the statement's. The +choice enters through `Primcodable.bool`, the encoding of the `Bool` codomain, and not through +`Computable` itself: a statement assuming only `∃ d : ℕ → Bool, Computable d` carries +`Classical.choice`, while one assuming `∃ d : ℕ → ℕ, Computable d` is `[propext, Quot.sound]` (the two +statement-control `example`s after `#print axioms Computable.const` in `ZeroParadox/DieCannotBe.lean` +§ IX, with the measurement). The `ℕ`-valued variant and the footprint of the proof it uses are there +too. ⚠ **Do not read `no_witness_of_fixedPointFree`'s axiom-freedom as evidence the choice is avoidable.** It is not a purer proof of the same statement — it *takes* a fixed-point-free map as a hypothesis, @@ -85,7 +87,7 @@ inherited dependence can be essential**, and *inherited* is not a synonym for *r | | own | inherited | |---|---|---| | **essential** (on § IV's premise) | `fixedPointFree_of_nontrivial`, `botCovered_botIntervalTwo_classical`, `Motion.registeredDecidable_of_classical`, `Motion.selectedTotal_of_classical` | well-order comparability | -| **statement-carried** (statement control, measured 2026-10-08; the die's row 2026-10-18) | — | `c3_irreversible`, `t4_snap_orthogonal`, `fD_functor`, `fC_functor`, `snap_dichotomy`, `quine_dichotomy`; in the die, `Motion.RegisteredComputable` | +| **statement-carried** (statement control, measured 2026-10-08; for `Motion.RegisteredComputable`, its printed footprint in `ZeroParadox/Die.lean`) | — | `c3_irreversible`, `t4_snap_orthogonal`, `fD_functor`, `fC_functor`, `snap_dichotomy`, `quine_dichotomy`; in the die, `Motion.RegisteredComputable` | | **open** | — | the remaining analytic layers (e.g. `fB_functor`, whose statement is choice-free) | ⚠ **A proof's footprint never establishes a principle's necessity.** `#print axioms` on a proof @@ -96,9 +98,14 @@ side needs a **reduction**. So the reductions are the evidence on the necessity becomes "not removable" only on § IV's premise. Provenance ("not inherited") is a separate question, settled by the footprint table above read against the source. -For the statement-carried rows no proof can drop the choice (`ZeroParadox/Category/ChoiceCannotBe.md`, +For the statement-carried row no proof can drop the choice (`ZeroParadox/Category/ChoiceCannotBe.md`, STATEMENT-CARRIED); the open question there is a restatement on a carrier whose statements are -choice-free. Whether the *remaining* analytic-layer dependence is removable is genuinely open — see the README +choice-free. The ε₀ results of `ZeroParadox/Ordinal/Epsilon0MinMax.lean` and +`ZeroParadox/Ordinal/SnapNucleus.lean` are statement-carried too, though not rows of the table (their +statement controls, `epsilon0EqNfpBotStatement`, `epsilon0MinMaxStatement`, +`snapNucleusNonemptyStatement` and `snapNucleusBotStatement`, are printed in those files); for them +the restatement's two readings and the search record are in `ZeroParadox/Ordinal/SnapNucleus.md` +§ "Axiom footprint". Whether the *remaining* analytic-layer dependence is removable is an open question (UNCLASSIFIED) — see the README Question Register and the `choice-probe` experiment, which found it mostly incidental in the one layer classified so far. None of it is load-bearing for the core claims: those (`ZeroParadox/AxiomProfile.lean` § I) are proved without choice. diff --git a/ZeroParadox/BottomCannotBe.lean b/ZeroParadox/BottomCannotBe.lean index 100ea26e..aa42d300 100644 --- a/ZeroParadox/BottomCannotBe.lean +++ b/ZeroParadox/BottomCannotBe.lean @@ -39,6 +39,9 @@ import ZeroParadox.Valuation.FloorWitness import ZeroParadox.Ordinal.ProofFloorCanonical import ZeroParadox.Valuation.RiemannSphere import ZeroParadox.Valuation.PoleCornersBridge +import ZeroParadox.Valuation.PolePassage +import ZeroParadox.Valuation.BallLine +import ZeroParadox.Reals.ConnectedNoFirstStep import ZeroParadox.Multihomed.HilbertDiagonal import ZeroParadox.Reals.MarkovSpectralGap import ZeroParadox.Category.Node4Generation @@ -140,6 +143,12 @@ example : letI : Preorder ℚ_[2] := Preorder.lift (‖·‖); (2 : ℚ_[2]) ⋖ example : @DenselyOrdered ℝ (Preorder.lift (‖·‖ : ℝ → ℝ)).toLT ∧ DenselyOrdered ℝ := ⟨@DenselyOrdered.mk ℝ (Preorder.lift (‖·‖ : ℝ → ℝ)).toLT fun a _ h => NormedField.exists_lt_norm_lt ℝ (norm_nonneg a) h, inferInstance⟩ +-- Statement: ℝ has no least element, so a dense case WITH one is the non-negative reals: there `0` +-- is ⊥ of `NNReal` and has no first step (no atom above it). +example : (⊥ : NNReal) = 0 ∧ ¬ ZeroParadox.HasFirstStep (0 : NNReal) := + ⟨rfl, ZeroParadox.axb1_fails_everywhere_iff_dense.mp inferInstance 0⟩ +-- Statement: and `NNReal` is preconnected, so no point of it, ⊥ of `NNReal` included, has a first step. +example : ∀ x : NNReal, ¬ ZeroParadox.HasFirstStep x := ZeroParadox.no_firstStep_of_preconnected -- Reading: other chart, the valuation order, stated on ℤ_[2] (the next two lines; `addVal_bot`, -- § POSITIVE, is `v 0 = ⊤` for an additive valuation). -- Statement: on ℤ_[2], ℤ_[2]'s 0 included, `q2Val x ≤ q2Val y ↔ ‖y‖ ≤ ‖x‖`. @@ -150,8 +159,7 @@ example : @DenselyOrdered ℝ (Preorder.lift (‖·‖ : ℝ → ℝ)).toLT ∧ -- Statement: in `TopCat` the one-point space `{0} ⊆ ℚ₂` is TERMINAL (it is not initial, -- `padic_bottom_not_initial`); `TopCat`'s initial object is the empty space -- (`ZeroParadox/Multihomed/TreeObstructions.lean`). -example : Nonempty (CategoryTheory.Limits.IsTerminal (TopCat.of (↥({(0 : ℚ_[2])} : Set ℚ_[2])))) := - ⟨TopCat.isTerminalPUnit.ofIso (TopCat.isoOfHomeo (Homeomorph.homeomorphOfUnique _ _))⟩ +#check @ZeroParadox.padic_bottom_isTerminal -- Reading: one point, two orders, neither THE order (the next three lines). -- Statement: the boundary model's floor is the least element of `WithBot Ordinal`. #check @ZeroParadox.phase_floor_isBot @@ -160,6 +168,9 @@ example : Nonempty (CategoryTheory.Limits.IsTerminal (TopCat.of (↥({(0 : ℚ_[ -- Statement: the map carrying ⊥ of `WithBot Ordinal` to ⊤ of `WithTop Ordinal`, fixing every `↑o`, is -- not monotone. #check @ZeroParadox.phaseFloorToTop_apply +-- Statement: CARRIER. `NInf.det` sends ⊥ of `ℕ → Bool` (the all-`false` tape) to ⊤ of `NInf` and ⊤ of +-- `ℕ → Bool` to ⊥ of `NInf` (`ZeroParadox/Die.lean` § XXV). +#check @ZeroParadox.NInf.det_poles -- Statement: INVARIANT within one `ZPSemilattice` structure (carrier and join): the join-identity -- `∀ x, join S x = x` holds exactly of `S = bot`. #check @ZeroParadox.da2_bottom_characterization @@ -271,7 +282,7 @@ example : letI := ZeroParadox.trivialZPSemilattice -- Statement: `fixToCofix` is not surjective. #check @ZeroParadox.fixToCofix_not_surjective -/-! ### orbits: ℚ₂ unit multipliers, the swap chain, balanced starts -/ +/-! ### orbits: ℚ₂ norm-one multipliers, the swap chain, balanced Markov starts -/ -- Statement: in ℚ₂, for `‖u‖ = 1` and `x ≠ 0`, the orbit `uⁿ * x` does not converge to 0. #check @ZeroParadox.unit_orbit_not_tendsto_zero @@ -289,8 +300,8 @@ example : letI := ZeroParadox.trivialZPSemilattice -- apex. #check @ZeroParadox.seam_not_mu_colimit_apex -- Statement: for `constPF Unit` the QPF seam `qpfSeam Unit` is the canonical bijection, no --- `Fix ≃ Cofix` exists for the recursive `idPF_Coalgebra`, the lattice seam is the identity equivalence, and the `selfApp` fixed points --- are `{bot}`. +-- `Fix ≃ Cofix` exists for the recursive `idPF_Coalgebra`, the lattice seam is the identity +-- equivalence, and the `selfApp` fixed points are `{bot}`. -- Reading: this records that no cross-setting map was EXHIBITED — an open "none given", not a no-go. -- The `IsEmpty` conjunct above is about `Fix ≃ Cofix`, not about any cross-setting map type. #check @ZeroParadox.no_cross_setting_map @@ -303,8 +314,8 @@ example : letI := ZeroParadox.trivialZPSemilattice example : @ZeroParadox.t3_unreachability = @ZeroParadox.ZPCategory.ax_g2 := rfl -- Statement: rose trees over a partially-well-ordered preorder are partially well ordered. -- Reading: this is the labeled Kruskal tree theorem; attribution in `ZeroParadox/Ordinal/Kruskal.md`. --- Indexed as a SCOPE FENCE — a well-quasi-order is not a descent to a bottom, so the "canonical floor 0" claim does --- not reach here. +-- Indexed as a SCOPE FENCE — a well-quasi-order is not a descent to a bottom, so the "canonical +-- floor 0" claim does not reach here. #check @ZeroParadox.kruskal_is_wqo_not_descent /-! ### POSITIVE — ⊥ as the fixed point where operation and result coincide -/ @@ -345,6 +356,15 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl #check @ZeroParadox.q2_zero_is_fixed -- Statement: in ℚ₂, the intersection of the nested balls is exactly `{0}`. [NARROW] #check @ZeroParadox.fB_bottom_is_limit +-- Statement: indexed by `ℤ` (`ballLine`, `ZeroParadox/Valuation/BallLine.lean`), the same balls continue +-- upward and their union is all of ℚ₂. +-- Reading: the other end of that line from `{0}`. +#check @ZeroParadox.iUnion_ballLine +-- Statement: in `TopCat`, `{0} ⊆ ℚ₂` with its inclusion cone is a limit of the ball tower `fB_functor`. +#check @ZeroParadox.floorConeIsLimit +-- Statement: that space is also terminal in `TopCat`; the proof uses only that it has one point, not the +-- limit above. +#check @ZeroParadox.padic_bottom_isTerminal -- Statement: the partial circulation exceeds every bound `M`. [WIDE, infinite measure] #check @ZeroParadox.t2_diverges -- Statement: surprisal exceeds every bound `M` — the same shape over a different function; this @@ -367,6 +387,9 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl #check @ZeroParadox.addVal_bot -- Statement: the `cnfToZp2` images of the ω-tower stages below ε₀ converge to ℤ_[2]'s 0. [WIDE, reach] #check @ZeroParadox.tower_converges_to_zero +-- Statement: read by `q2Val`, those images are ⊤ of `ℕ∞` at stage 0, `n` at stage `n ≥ 1`, and tend +-- to ⊤, which is `q2Val` of ℤ_[2]'s 0 (`q2Val_bot`; `ZeroParadox/Valuation/PolePassage.lean`). +#check @ZeroParadox.arc_q2Val /-! ### INVERSION — the symmetry linking the narrow and wide poles -/ @@ -374,6 +397,11 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl -- Reading: the inversion symmetry of the tower. ⚠ It is ℤ-valued and carries NO literal 0=∞ -- content — 0 is the excluded centre, and the source file disclaims that reading. #check @ZeroParadox.inversion_reverses_filtration +-- Statement: on the shells of the ball line, `(·⁻¹)` maps `ballLine n \ ballLine (n + 1)`, the nonzero +-- points of valuation `n`, onto `ballLine (-n) \ ballLine (-n + 1)`. +-- Reading: INVERSION on the ball line; 0 is fixed by inversion in ℚ₂ (`inv_zero`), and the exchange +-- of 0 with ∞ is `rInv` on `Sphere` (`sphere_exchange`), not this map. +#check @ZeroParadox.ballLine_inv_shell -- Statement: for rational `x ≠ 0`, the one orbit `2ⁿx` converges to 0 in ℚ₂ AND diverges to ∞ in ℝ. -- Reading: this is where the literal 0=∞ content lives — one orbit, two place-views. #check @ZeroParadox.doubling_place_dichotomy @@ -398,6 +426,12 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl -- Statement: DRIFT — in any `InfinitudeFloorInversion`, the members tend to the floor while their -- complexities tend to `⊤ : ℕ∞`. It carries no `cx floor = ⊤`, so it is not the coincidence witness. #check @ZeroParadox.pole_inversion +-- Statement: no continuous path in `Sphere` runs from 0 of `ℚ_[2]` to ∞ of `Sphere` +-- (`ZeroParadox/Valuation/PolePassage.lean`). +-- Reading: CARRIER — `rInv` exchanges those two points (`sphere_exchange`) and no path joins them. +#check @ZeroParadox.no_path_zero_infty +-- Statement: control, on `OnePoint ℝ` ∞ lies in the connected component of 0 of ℝ. +#check @ZeroParadox.real_zero_infty_connected -- Statement: Mathlib's `IsInitial.op` — the opposite of an initial object is terminal. -- Reading: CITED, not ZP-proved; attribution is the point. Passing to `Cᵒᵖ` is the categorical face -- of inversion, swapping the μ-bottom to a terminal object. @@ -405,9 +439,11 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl -- Statement: Mathlib's `hasZeroObject_op` — a zero object stays a zero object in the opposite. -- Reading: the seam is self-dual under `op`, the fixed centre of the inversion. #check @CategoryTheory.Limits.hasZeroObject_op --- Reading: PRIOR-ART RECORD, do NOT rebuild. "Order-reversal swaps ⊥ and ⊤" is Mathlib's --- `OrderIso.map_bot` below, applied to an order isomorphism into an order dual. The three inversions --- share no single buildable type, so their "unification" is a schema, not a theorem. +-- Reading: PRIOR-ART RECORD, do NOT rebuild. "Order-reversal swaps ⊥ and ⊤" is two Mathlib facts, +-- applied to an order isomorphism `α ≃o βᵒᵈ` into an order dual: `OrderIso.map_bot` sends ⊥ of `α` to +-- ⊤ of `β`, and `OrderIso.map_top` sends ⊤ of `α` to ⊥ of `β` (both below, with the Boolean-algebra +-- complement as the instance). The three inversions share no single buildable type, so their +-- "unification" is a schema, not a theorem. -- Statement: Mathlib's `OrderIso.map_bot`: for `[LE α]`, `[PartialOrder β]`, `[OrderBot α]` and -- `[OrderBot β]`, an order isomorphism `α ≃o β` sends ⊥ of `α` to ⊥ of `β`. #check @OrderIso.map_bot @@ -415,6 +451,12 @@ example : (fun x : ℤ => -x) (0 : ℤ) = 0 := rfl -- `OrderIso.compl α : α ≃o αᵒᵈ`. example {α : Type*} [BooleanAlgebra α] : (⊥ : α)ᶜ = ⊤ := congrArg OrderDual.ofDual ((OrderIso.compl α).map_bot) +-- Statement: Mathlib's `OrderIso.map_top`: an order isomorphism `α ≃o β` between orders with a +-- greatest element sends ⊤ of `α` to ⊤ of `β`. +#check @OrderIso.map_top +-- Statement: the other half, `⊤ᶜ = ⊥`, as `OrderIso.map_top` applied to `OrderIso.compl α`. +example {α : Type*} [BooleanAlgebra α] : (⊤ : α)ᶜ = ⊥ := + congrArg OrderDual.ofDual ((OrderIso.compl α).map_top) -- Statement: Mathlib's `compl_bot`: `⊥ᶜ = ⊤` in any Heyting algebra, the general home of that fact. #check @compl_bot @@ -438,8 +480,15 @@ The cross-field routing, and its Lawvere / Yanofsky attribution, live in -- period, so this does not tie index to function. A periodicity fact, not a diagonal identity. #check @ZeroParadox.quine_period_is_goedel -- Statement: a Kleene-periodic code exists AND a least ordinal with `ω^α = α` exists. --- Reading: the two diagonalization fixed points coexist; the conjunction is not an identification. +-- Reading: the ordinal conjunct is a least fixed point. The code conjunct is witnessed in the proof +-- by a computational quine (`quine_period_is_goedel`), but as stated every constant code meets it +-- (the `example` below), so the statement carries no diagonal content on the code side. The +-- conjunction is not an identification. #check @ZeroParadox.both_fixed_points_exist +-- Statement: every constant code `Code.const k` satisfies `both_fixed_points_exist`'s code conjunct. +example (k : ℕ) : ∀ n, Nat.Partrec.Code.eval (Nat.Partrec.Code.const k) n = + Nat.Partrec.Code.eval (Nat.Partrec.Code.const k) (Encodable.encode (Nat.Partrec.Code.const k) + n) := + fun _ => by simp [Nat.Partrec.Code.eval_const] -- Statement: a finite-dimensional `X : ModuleCat ℂ` with `X ≅ X ⊞ X` is the zero object. -- Reading: the OTHER sub-sense of self — self-similarity under the biproduct diagonal, as opposed to -- the Kleene sense of a code applied to its own index. @@ -562,8 +611,9 @@ noncomputable example : Ordinal.{0} →o Ordinal.{0} := -- under the 2-adic multiplicity valuation `AddValuation ℤ_[2] ℕ∞` (`addVal_bot`, § POSITIVE). example (x : ℤ_[2]) : x - x = 0 ∧ multiplicity_addValuation PadicInt.prime_p (x - x) = ⊤ := ⟨sub_self x, by rw [sub_self]; exact ZeroParadox.addVal_bot _⟩ --- Statement: Mathlib's `dist_eq_norm`: in a seminormed additive commutative group, `dist a b = ‖a - b‖`, so every --- comparison of two points is the norm of their difference, measured from 0. +-- Statement: Mathlib's `dist_eq_norm`: in a seminormed additive commutative group, +-- `dist a b = ‖a - b‖`, so every comparison of two points is the norm of their difference, measured +-- from 0. #check @dist_eq_norm -- Statement: a tape `ℕ → Bool` is disjunctive when every finite word occurs in it infinitely often. #check @ZeroParadox.Disjunctive @@ -596,8 +646,12 @@ example : (ℕ → Bool) ↪o Set ℕ := -- Statement: Mathlib's `Set.preimage_boolIndicator_true`, the inverse direction: the tape -- `s.boolIndicator` read back this way is `s`. #check @Set.preimage_boolIndicator_true -#check @IsSimpleOrder.orderIsoBool -- Statement: Mathlib neighbour: a bounded simple order with decidable equality is order-isomorphic to `Bool` -#check @CompleteAtomicBooleanAlgebra.toSetOfIsAtom -- Statement: Mathlib neighbour: a complete atomic Boolean algebra is order-isomorphic to the sets of its atoms +-- Statement: Mathlib neighbour: a bounded simple order with decidable equality is +-- order-isomorphic to `Bool`. +#check @IsSimpleOrder.orderIsoBool +-- Statement: Mathlib neighbour: a complete atomic Boolean algebra is order-isomorphic to the sets +-- of its atoms. +#check @CompleteAtomicBooleanAlgebra.toSetOfIsAtom -- Statement: under pointwise exclusive-or, every tape's self-difference is the all-false tape, so -- a tape read against itself is never disjunctive. example (x : ℕ → Bool) : (fun n => xor (x n) (x n)) = (fun _ => false) ∧ diff --git a/ZeroParadox/Category/BottomUndecidable.lean b/ZeroParadox/Category/BottomUndecidable.lean index 026a208b..a4c2d376 100644 --- a/ZeroParadox/Category/BottomUndecidable.lean +++ b/ZeroParadox/Category/BottomUndecidable.lean @@ -8,8 +8,8 @@ set_option maxHeartbeats 400000 `ZeroParadox/Category/LawvereTaboo.lean` proves `wem_of_fixedPointFree`: the general form of the diagonal engine's supplier (*every type with two distinct points admits a fixed-point-free endomap*) -implies **weak excluded middle**, choice-free. The reading recorded alongside it -(`.claude-local/notes/ambiguity_is_what_choice_buys_2026-07-20.md`) is that the cost is located at +implies **weak excluded middle**, choice-free. The framework's reading of that result is that the +cost is located at **unresolved identity** — the one step that must decide whether two things are the same. This file tests a sharpening of that reading: **is the framework's ⊥ (the self-containing Quine atom) @@ -50,11 +50,11 @@ result stated honestly is worth as much as the positive one it replaces. What is ## Why the ⊥-essential version cannot even be posed in Lean (the honest boundary) The non-termination Tim points at is a property of the *semantic* set-theoretic Quine atom: deciding -`y = ⊥` unfolds `⊥ = {⊥}` and descends forever. That object is **not a Lean type** — `Set` is -well-founded, `x = {x}` is forbidden (Cantor), which the framework already proves as -`quine_no_literal` / `nontrivial_lattice_no_witness` (`ZeroParadox/Category/Lawvere.lean`). The Lean -encoding `AbstractSelfApp` replaces the infinite descent with a *pinned unique* fixed point, and a -pinned fixed point has the most decidable identity there is. So the ⊥-essential undecidability is +`y = ⊥` unfolds `⊥ = {⊥}` (in ZF + AFA) and descends forever. In the well-founded charts that object is **not a Lean +type**: no `ZFSet` occupies the die's Quine-atom role (`zfset_quine_role_unoccupied`), and a lattice with a second +element has no Lawvere witness (`quine_no_literal`, `nontrivial_lattice_no_witness`). The coalgebra chart occupies the +role (`cofix_quine_role_occupied`) at its one point (`cofix_subsingleton`), so no descent is posed there. The Lean encoding +`AbstractSelfApp` replaces the descent with a *pinned unique* fixed point, the most decidable identity there is. So the ⊥-essential undecidability is **unsettled in Lean because it is unposeable in Lean**, and *inessential in the encoding we do have*. Reporting it as proved would repeat the MC-1 over-identification the project retracted. It stays a rhyme with a mechanism, not a theorem — the fence in the conjecture note, unmoved. @@ -140,10 +140,12 @@ uniform in `p`, yields weak excluded middle. Choice-free: the decision is the hy witness facts (`gx_eq_gb0`, `gx_eq_gb1`, `glue_b0_ne_b1`) carry only `[propext, Quot.sound]`. -/ theorem wem_of_glue_identity (h : ∀ p : Prop, Decidable (gx p = gb0 p)) : WeakExcludedMiddle := by intro p - rcases h p with hne | heq - · -- `gx p ≠ gb0 p`: were `p` to hold, `gx p = gb0 p` (`gx_eq_gb0`). So `¬p`. + cases h p with + | isFalse hne => + -- `gx p ≠ gb0 p`: were `p` to hold, `gx p = gb0 p` (`gx_eq_gb0`). So `¬p`. exact Or.inl fun hp => hne (gx_eq_gb0 p hp) - · -- `gx p = gb0 p`: were `¬p` to hold, `gx p = gb1 p`, forcing `gb0 p = gb1 p`. So `¬¬p`. + | isTrue heq => + -- `gx p = gb0 p`: were `¬p` to hold, `gx p = gb1 p`, forcing `gb0 p = gb1 p`. So `¬¬p`. exact Or.inr fun hnp => glue_b0_ne_b1 p (heq.symm.trans (gx_eq_gb1 p hnp)) /-! ## § II — Decidable equality of the carrier implies weak excluded middle -/ diff --git a/ZeroParadox/Category/Category.lean b/ZeroParadox/Category/Category.lean index e38ba4cd..1eee4622 100644 --- a/ZeroParadox/Category/Category.lean +++ b/ZeroParadox/Category/Category.lean @@ -109,7 +109,7 @@ example (α : Type) [Preorder α] (h : ∀ x : α, ∃ y, x < y) : ∀ t : α, I /-! ## II. ZPSurprisal — I-KC Import (D7') -/ --- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib has no formalization of Kolmogorov complexity. ZPSurprisal is an import stub for the I-KC axiom (D7'): it models conditional K-complexity as an abstract ℕ-valued morphism assignment. The one field (surp_id: identity morphisms have zero surprisal) is the only structurally usable I-KC axiom in the ZP-G theorems; the rest of K-complexity is outside Lean scope. +-- [ZP-CUSTOM] no Mathlib analog | reason: No formalization of Kolmogorov complexity was located in the Mathlib then pinned (`5450b53`) as of 2026-10-04; the search is recorded in `ZeroParadox/Information/Disjunctive.md`. Outside Mathlib, K is now in the build: the Lake dependency AlexeyMilovanov/kolmogorov-complexity-lean (commit 7e7111685355e3e7925c32621788e977ca53108f) defines `plainK` and `KPPlain`, and `ZeroParadox/Information/BrudnoBridge.lean` restates, for `trials` and `MLRandom`, its entropy-rate theorems (SUV Thm 148 and Problems 238, 239, which this corpus labels Brudno; the dependency does not use the name) and its prefix-complexity Levin–Schnorr criterion (SUV Thm 94(d)), SUV being Shen, Uspensky, Vereshchagin, *Kolmogorov Complexity and Algorithmic Randomness*, AMS 2017 (facebookresearch/atlas-lean also defines `K`, commit acf9c1f8, read at its source by a prior-art gate on 2026-10-31 and not a dependency). ZPSurprisal is not tied to that K: it is an import stub for the I-KC axiom (D7') that models conditional K-complexity as an abstract ℕ-valued morphism assignment. The one field (surp_id: identity morphisms have zero surprisal) is the only structurally usable I-KC axiom in the ZP-G theorems; no further K-complexity content is formalized for them. /-- ZPSurprisal models the I-KC import: conditional Kolmogorov complexity K(x_B | x_A). D7' assigns surprisal I(f) = K(x_B | x_A) to each morphism f: A → B. K is well-defined up to additive constant c; structural claims (zero/undefined/finite) @@ -163,9 +163,12 @@ theorem t4_chains_forward_only {C : Type*} [Category C] [ZPC : ZPCategory C] This is the same category as DA-1 Path 3's Kolmogorov content in the formal document **ZP-E** (DA-1 insert § IV) — a PDF cross-reference, not a Lean file: that prose is generated by `scripts/build_zpe.py` and exists in no Lean source. The - K-specific content is mathematically sound and drives the PDF derivation, but - requires a full K-formalization to verify in Lean. The I-KC import marks this - boundary: structural implications are Lean-verified; AIT content is not. + K-specific content is mathematically sound and drives the PDF derivation. K itself is + now in the build (`plainK`, `KPPlain` from kolmogorov-complexity-lean at commit 7e71116; + see `ZeroParadox/Information/BrudnoBridge.lean`), but T6-b/c are not proved from it and + ZPSurprisal is not tied to it; Path 3's argument is likewise not formalized (searched in + three phrasings, 2026-11-07; the record is ZP-J's DA-1 paragraph in `scripts/build_zpj.py`). + The I-KC import marks this boundary: structural implications are Lean-verified; this AIT content is not. T6-b/c are not load-bearing for any subsequent formal result. The load-bearing singularity claim — that surprisal diverges along sequences approaching ⊥ — is separately proved in t2_diverges using Q₂'s specific structure, without K. -/ diff --git a/ZeroParadox/Category/ChoiceCannotBe.lean b/ZeroParadox/Category/ChoiceCannotBe.lean index 88478a62..1d79a719 100644 --- a/ZeroParadox/Category/ChoiceCannotBe.lean +++ b/ZeroParadox/Category/ChoiceCannotBe.lean @@ -16,6 +16,7 @@ import ZeroParadox.Order.PataraiaFromBourbakiWitt import ZeroParadox.Reals.OrderedField import ZeroParadox.Valuation.PoleRegistration import ZeroParadox.Die +import ZeroParadox.Information.CrossingTrials /-! # Machine-checked characterization index of the framework's relationship to `Classical.choice` @@ -76,7 +77,8 @@ footprint; `[propext]` means propositional extensionality only. -/ -- The ν-side inhabitation witnesses at the root cut: NO axioms. These matter because they REFUTE the -- general form of "choice enters precisely where the diagonal fixed point is asserted inhabited." -- Inhabiting a non-well-founded (greatest) fixed point can be entirely choice-free. FENCE: the --- refutation is functor-specific, not universal — the QPF `Cofix` route in `ZeroParadox/Computability/ChoicePurityInvariant.lean` +-- refutation is functor-specific, not universal — the QPF `Cofix` route in +-- `ZeroParadox/Computability/ChoicePurityInvariant.lean` -- (`cofix_nonempty'`) DOES carry `Classical.choice`. Located exactly, measured 2026-08-03: the M-type -- FORMER and its constructors are axiom-free (`PFunctor.M`, `M.mk`, `M.corec`), its DESTRUCTOR is -- not @@ -97,8 +99,17 @@ footprint; `[propext]` means propositional extensionality only. -/ #check @ZeroParadox.boundaryDouble_selfCopyRef -- Statement: along a GIVEN `α ≃ ℕ`, a `SelfCopyRef` map exists on `α`; measured `[propext, Quot.sound]`. #check @ZeroParadox.selfCopyRef_of_equiv_nat --- Statement: an ACCIDENTAL case — over `[Fintype] [DecidableEq]` no `SelfCopyRef` map exists, re-proved at --- `[propext, Quot.sound]`; Mathlib's `Finite.injective_iff_surjective` route reports `Classical.choice`. +-- Statement: an ACCIDENTAL case — over `[Finite]` no `SelfCopyRef` map exists, re-proved by list +-- pigeonhole at `[propext, Quot.sound]`, a statement whose constants measure no axioms; +-- `no_selfCopyRef_of_finite` takes Mathlib's `Finite.injective_iff_surjective` route and reports +-- `Classical.choice`. The `example` after the re-proof in its home file derives that statement. +#check @ZeroParadox.no_selfCopyRef_of_finite_constructive +-- Statement: the `[Fintype] [DecidableEq]` form, by the same pigeonhole, measured `[propext, +-- Classical.choice, Quot.sound]`: STATEMENT-CARRIED through the `[Fintype α]` binder, since `Fintype` +-- itself reports that triple under the pinned Mathlib (printed in the home file's PurityCheck). +-- Reading: both instance readings, neither denied: under `[Fintype]` the statement carries the choice +-- and no proof drops it; under `[Finite]` the same pigeonhole runs without it (§ III, STATEMENT-CARRIED +-- IS INSTANCE-RELATIVE). #check @ZeroParadox.no_selfCopyRef_of_fintype -- Statement: an ACCIDENTAL case — Pataraia's theorem (monotone `f` on `[CompletePartialOrder α]` has a @@ -128,7 +139,8 @@ footprint; `[propext]` means propositional extensionality only. -/ /-! ## § II. What choice is NOT to be confused with — the excluded-middle boundary The modality of §I generates classical LOGIC — excluded middle — which is strictly weaker than **full** -choice (Cohen 1963). The RESTRICTED fragment is a different matter: see `ZeroParadox/Category/ChoiceCannotBe.md`. This section indexes +choice (Cohen 1963). The RESTRICTED fragment is a different matter: see +`ZeroParadox/Category/ChoiceCannotBe.md`. This section indexes the boundary and its scope fence. -/ -- What the modality's closed points actually are: the regular elements `aᶜᶜ = a` — the Boolean core. @@ -141,13 +153,16 @@ the boundary and its scope fence. -/ -- DIACONESCU, hypothesis form: a choice fragment implies excluded middle. PRIOR ART, not a framework -- result: Diaconescu (1975), "Axiom of choice and complementation"; the analogue in intuitionistic set -- theory is Goodman–Myhill (1978), "Choice implies excluded middle". The framework contributes only the --- hypothesis-form packaging (Lean's kernel realizes the arrow as a derivation, not a reusable theorem). +-- hypothesis-form packaging in Lean: Lean core (`Init/Classical.lean`) proves `Classical.em` from the +-- axiom `Classical.choice` by the same argument, a theorem about that axiom rather than one taking a +-- choice principle as a hypothesis; the Rocq hypothesis forms are cited in § IV (`Diaconescu.v`). -- DIRECTION, stated precisely. Diaconescu's theorem is an EQUIVALENCE between two topos properties -- (p. 176), with choice implying complements as its corollary (p. 178). It already concerns a two-point -- shape: his construction (pp. 176-177) is a coequalizer of two disjoint monomorphisms, and such a --- coequalizer has fibres of at most two points. Goodman–Myhill state the restriction explicitly, choice "for sets B, C of at most two --- elements" (p. 461). With unique choice into `Bool`, `ChoiceFragment` and `ExcludedMiddle` are --- inter-derivable (the `example` after `em_of_choiceFragment` in its home file). "The converse fails" +-- coequalizer has fibres of at most two points. Goodman–Myhill state the restriction explicitly, +-- choice "for sets B, C of at most two elements" (p. 461). With unique choice into `Bool`, +-- `ChoiceFragment` and `ExcludedMiddle` are +-- inter-derivable (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, the `example` after `em_of_choiceFragment`). "The converse fails" -- belongs to FULL AC and is Cohen 1963, not Diaconescu. -- Reading: in `ZeroParadox/Category/ExcludedMiddleBridge.lean` the natural construction of the fragment -- from `ExcludedMiddle` fails to elaborate without `classical`, and a candidate explanation is Lean's @@ -181,6 +196,15 @@ example : fun ⟨hw, hm⟩ f => (hw f).imp id (hm f)⟩ rw [heq] at hn; cases hn +-- Statement: the same decision at the same ⊥ (LPO's shape), as continuity rather than logic: no continuous Boolean +-- test on `ℕ → Bool` (product topology) is `true` exactly on the tapes with a `true`, and any such +-- test fails to be continuous at ⊥ of `ℕ → Bool`. Home: `ZeroParadox/Information/CrossingTrials.lean` +-- § IX, with the converse direction (a test fixed by one finite prefix is continuous). +-- Reading: (cited, not claimed) Weihrauch, *Computable Analysis* (Springer 2000), Thm 2.2.3, p. 30: +-- computable implies continuous, so no machine computes that total test either. +#check @ZeroParadox.no_continuous_test_fires_once +#check @ZeroParadox.not_continuousAt_bot_of_decides_fires_once -- Statement: discontinuous at ⊥ + /-! ## § III. What IS established about choice here Not "what choice is" — that is Lean's, not the framework's. What this corpus has actually measured or @@ -199,7 +223,7 @@ proved about where choice does work. -/ -- Reading: the framework therefore attributes this footprint to Mathlib's QPF *quotient layer* -- rather than to the mathematics — escaping it means changing the carrier, not cleaning the proof. -- (Setting: ACS's construction needs only function extensionality, which Lean has; only its --- uniqueness half uses univalence. See ZeroParadox/Computability/ChoicePurityInvariant.lean.) +-- uniqueness half uses univalence. See `ZeroParadox/Computability/ChoicePurityInvariant.md`.) -- Contrast `strict_cofix_nonempty` (§ I, NO axioms): same phenomenon, different construction, -- opposite footprint. That contrast is the STATEMENT-CARRIED class in one pair: the statement carries -- the choice, and a restatement on a choice-free carrier holds without it @@ -210,20 +234,28 @@ proved about where choice does work. -/ -- (⊥ of `Ordinal` ↦ ε₀) inherits `Classical.choice` from Mathlib's `Ordinal` fixed-point machinery; -- `dnegNucleus` (§ I) is `[propext]`. Both are difference-generators seeded at their carrier's ⊥ — -- negation satisfies `a ⇨ ⊥ = aᶜ` (the class law `himp_bot`), and `HeytingAlgebra` extends `OrderBot`, --- so ⊥ of the Heyting algebra is part of the structure negation lives in. Same role, different carriers, opposite footprints, and +-- so ⊥ of the Heyting algebra is part of the structure negation lives in. Same role, different +-- carriers, opposite footprints, and -- opposite behaviour AT the seed: `dnegNucleus` fixes ⊥ of the Heyting algebra (⊥ is always regular), -- `snapNucleus` provably moves ⊥ of `Ordinal` (`snapNucleus_bot_ne_bot`). On the footprint difference: -- `snapNucleus` is STATEMENT-CARRIED (`ZeroParadox/Category/ChoiceCannotBe.md`): `Nonempty (Nucleus --- Ordinal.{0})` and `snapNucleus ⊥ ≠ ⊥`, each only assumed, already report the choice (statement control, --- measured 2026-10-08), so no proof of these statements can drop it. What ZP-N re-proved is the ordinal +-- Ordinal.{0})` and `snapNucleus ⊥ ≠ ⊥`, with no proof attached, already carry the choice (their statement +-- controls, `#check`ed below and printed in `ZeroParadox/Ordinal/SnapNucleus.lean`'s purity block), so no +-- proof of these statements can drop it. What ZP-N re-proved is the ordinal -- *ascent* (`exp_lt_term`, `omegaPow_no_fixedpoint`, `tower_strictMono` on `ONote`), which is suggestive -- for the nucleus and is not the nucleus. Choice is NOT in the `Ordinal` type: `Ordinal` measures -- `[propext, Quot.sound]`. The choice -- enters through the order instance and the operations (`Ordinal.instLinearOrder`, `nfp`, `omega0`, --- `epsilon`, each `[propext, Classical.choice, Quot.sound]`). The open question is a restatement on a --- notation carrier whose statements are choice-free; its current state is the entry below. +-- `epsilon`, each `[propext, Classical.choice, Quot.sound]`). The remaining question is a restatement on +-- a carrier whose statements are choice-free, with two readings: a defined one, in Lean on `E0Note`, and +-- a derived one, on a well-founded carrier, not located as of 2026-10-13; both, with the search record, +-- are in `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". #check @ZeroParadox.snapNucleus #check @ZeroParadox.snapNucleus_bot_ne_bot +-- Statement: the two statements above as bare propositions, the statement controls. +#check @ZeroParadox.snapNucleusNonemptyStatement +-- Statement: `snapNucleus ⊥ ≠ ⊥` at universe 0, bare. +#check @ZeroParadox.snapNucleusBotStatement -- THE SAME LOCATION FOR `Code`, measured 2026-09-19: -- `Nat.Partrec.Code` is axiom-free and so is `Nat.Partrec.Code.eval`, so the choice is not "in @@ -285,11 +317,42 @@ proved about where choice does work. -/ -- with `Classical.em` and so carries `Classical.choice` IN ITS OWN TERM; `Prop.instHeytingAlgebra` is -- `[propext]`. A `Prop`-scoped statement that does not PIN its instance can silently resolve through the -- Boolean one and acquire choice — which would make every choice-freeness claim about `Prop` vacuous. --- Every `Prop`-scoped statement in `ZeroParadox/Category/ExcludedMiddleBridge.lean` pins `@… Prop Prop.instHeytingAlgebra` --- explicitly for this reason. Pin the instance, or measure nothing. +-- Every `Prop`-scoped statement in `ZeroParadox/Category/ExcludedMiddleBridge.lean` pins +-- `@… Prop Prop.instHeytingAlgebra` explicitly for this reason. Pin the instance, or measure nothing. #check @Prop.instHeytingAlgebra #check @Prop.instBooleanAlgebra +-- STATEMENT-CARRIED IS INSTANCE-RELATIVE — one statement text, two definitionally equal instances, +-- opposite footprints. The same hazard as the entry above, on `WithTop`: Mathlib's order instances +-- there go through `WithTop.le_def`, proved by `grind` (`ZeroParadox/Order/ChoiceFreeWithTop.lean`). +-- Statement: Mathlib's `WithTop` preorder, partial order and least element carry +-- `[propext, Classical.choice, Quot.sound]` (printed next). +#print axioms WithTop.instPreorder +#print axioms WithTop.instPartialOrder +#print axioms WithTop.instOrderBot +-- Statement: the corpus's preorder, partial order and least element over the same `≤` and `<` +-- (`WithTop.instLE`, `WithTop.instLT`) measure no axioms (printed next). +#check @ZeroParadox.withTopPreorderCF +#print axioms ZeroParadox.withTopPreorderCF +#print axioms ZeroParadox.withTopPartialOrderCF +#print axioms ZeroParadox.withTopOrderBotCF +-- Statement: on `WithTop ℕ` the two preorders are definitionally equal. +example : (WithTop.instPreorder : Preorder (WithTop ℕ)) = ZeroParadox.withTopPreorderCF := rfl +-- Statement: `BotCovered (WithTop σ) ↔ BotCovered σ`, elaborated under the corpus's instances; its +-- footprint, no axioms, is printed in `ZeroParadox/Die.lean`'s PurityCheck. +#check @ZeroParadox.botCovered_withTop_iff +-- Statement: the same proof term proves the same statement text elaborated under Mathlib's instances, +-- whose elaborated type names `WithTop.instPartialOrder` and `WithTop.instOrderBot`, printed above. +example {σ : Type} [PartialOrder σ] [OrderBot σ] [NoMaxOrder σ] : + ZeroParadox.BotCovered (WithTop σ) ↔ ZeroParadox.BotCovered σ := + ZeroParadox.botCovered_withTop_iff +-- Reading: both sides, neither denied. Read under Mathlib's instances the statement carries +-- `Classical.choice`, since `#print axioms` walks the type (`_trivialAboutZ2` in +-- `ZeroParadox/Valuation/Scale.lean`), and no proof of it can drop it (STATEMENT-CARRIED, +-- `ZeroParadox/Category/ChoiceCannotBe.md`); read under the corpus's, the same text carries none. So +-- the bin is a property of the elaborated statement, instances included, and neither reading says the +-- mathematics needs choice. + /-! ## § IV. The ESSENTIAL cases — reductions to taboos, and the premise they rest on The arrow runs from each principle (cases 1 to 5 below) to its taboo, so each theorem speaks of the @@ -341,14 +404,16 @@ is essential. -/ -- AND THE ESCAPE, WHICH IS THE HALF THAT MAKES CASE 2 USEFUL RATHER THAN ALARMING. "Essential" scopes -- to the GENERAL principle, quantified over arbitrary `Type`. Restrict the carrier to decidable -- equality and the same statement is choice-free — measured `[propext]`, against the general form's --- `[propext, Classical.choice, Quot.sound]`. `ZeroParadox/Category/DiagonalWitness.lean`'s `no_witnessRel_top_of_nontrivial` +-- `[propext, Classical.choice, Quot.sound]`. `ZeroParadox/Category/DiagonalWitness.lean`'s +-- `no_witnessRel_top_of_nontrivial` -- carries the same audit for the level-set form. **Where a carrier has `DecidableEq`, the essential -- form is not needed** — the taboo makes the general statement non-re-provable constructively, on the -- premise in the header above, and the restriction says it does not have to be *there*. Together they -- localize the classical content rather than obstruct it: they say where it lives and how far it reaches. -- SCOPE: how far the escape reaches is UNSURVEYED. Which carriers in this corpus have `DecidableEq` -- was unmeasured as of 2026-08-02, so "the restriction covers what we need" is unverified in general — and a --- universal over every carrier would be the sentence shape `ZeroParadox/Category/ChoiceCannotBe.md`'s § "No count" warns about. +-- universal over every carrier would be the sentence shape +-- `ZeroParadox/Category/ChoiceCannotBe.md`'s § "No count" warns about. -- The two `#check`ed declarations are what is established; the reach is not. #check @ZeroParadox.fixedPointFree_of_nontrivial_decidable @@ -369,8 +434,11 @@ is essential. -/ -- for every `c` in D, hence `c = False ∨ c ≠ False` (next `example`); an instance of theirs, not a -- generalization. -- Statement: the piece at ⊥ of `Prop` gives some `a ≠ False` on whose down-set `{c | c → a}` every --- `c = False` is decided (`[propext]`). -example (h : ZeroParadox.BotIntervalTwo Prop) : +-- `c = False` is decided (`[propext]`); ⊥ of `Prop` is pinned to `Prop.instHeytingAlgebra` (§ III's +-- instance hazard), since under this file's imports an unpinned `OrderBot Prop` resolves through +-- `Prop.instCompleteLattice` and the statement then measures `[propext, Quot.sound]`. +example (h : @ZeroParadox.BotIntervalTwo Prop _ + (@HeytingAlgebra.toOrderBot Prop Prop.instHeytingAlgebra)) : ∃ a : Prop, a ≠ False ∧ ∀ c : {c : Prop // c → a}, c.1 = False ∨ c.1 ≠ False := by obtain ⟨a, hlt, h2⟩ := h exact ⟨a, hlt.ne', fun c => (h2 c.1 c.2).imp id @@ -418,7 +486,8 @@ example : ∀ (α : Type) [PartialOrder α] (a b : α), a ⋖ b → Set.Icc a b -- Statement: non-vacuity: the framework's classical proof supplies the hypothesis. example : ∀ (β : Type) (M : ZeroParadox.Motion β), M.RegisteredDecidable := fun _ _ => ZeroParadox.Motion.registeredDecidable_of_classical -#check @ZeroParadox.Motion.registeredDecidable_of_classical -- Statement: every motion has a decision of definedness, proved with `classical` +-- Statement: every motion has a decision of definedness, proved with `classical` +#check @ZeroParadox.Motion.registeredDecidable_of_classical -- Statement: the escape: an `Option`-presented UP has one with no axiom of choice (`[propext]`). #check @ZeroParadox.Motion.ofOption_registeredDecidable @@ -430,7 +499,9 @@ example : ∀ (β : Type) (M : ZeroParadox.Motion β), M.RegisteredDecidable := -- 3's, that theorem is a class-level witness no other framework proof names. Neither hypothesis form -- measures any axiom alone (statement control, 2026-10-18). -- Reading (cited, not claimed): PRIOR ART, Diaconescu's argument as in the Rocq standard library, --- `theories/Logic/Diaconescu.v` Part A (`pred_ext_and_rel_choice_imp_EM`), on the same two classes +-- `theories/Logic/Diaconescu.v` Part A, section `PredExt_RelChoice_imp_EM`, which the file marks "kept +-- for backwards compatibility" (`pred_ext_and_rel_choice_imp_EM`; the current Part A theorem +-- `prop_ext_and_rel_choice_imp_EM` uses the pairs `(True, P)`, `(P, True)`), on that section's two classes -- `b = true ∨ p`, `b = false ∨ p`, with a selector given as data; an instance of theirs, not a -- generalization (`ZeroParadox/DieCannotBe.lean` § X). #check @ZeroParadox.Motion.em_of_selectedData @@ -438,10 +509,12 @@ example : ∀ (β : Type) (M : ZeroParadox.Motion β), M.RegisteredDecidable := example : ∀ (β : Type) (M : ZeroParadox.Motion β), M.SelectedData := fun _ _ => ZeroParadox.Motion.selectedData_of_selectedTotal ZeroParadox.Motion.selectedTotal_of_classical -#check @ZeroParadox.Motion.selectedTotal_of_classical -- Statement: every motion has a total selector, proved with `classical` +-- Statement: every motion has a total selector, proved with `classical` +#check @ZeroParadox.Motion.selectedTotal_of_classical -- Statement: the escape: a step given by a function is selected with no axioms. #check @ZeroParadox.Motion.selectedTotal_of_fun -#check @ZeroParadox.Motion.selectedTotal_of_option -- Statement: and one given by an `Option`-valued function, with `[propext]` +-- Statement: and one given by an `Option`-valued function, with `[propext]` +#check @ZeroParadox.Motion.selectedTotal_of_option /-! ## § V. Per instance free, uniform a taboo — pointers @@ -451,15 +524,18 @@ uniform legs proved by anonymous `example` are cited by section. -/ -- Statement: chart selection: free given a point (`chart_selection_is_freeG`, § I); uniform at the -- stipulated pole, the fragment (`uniformChartSelection_iff_choiceFragment`, § III). #check @ZeroParadox.chart_selection_is_freeG -#check @ZeroParadox.uniformChartSelection_iff_choiceFragment -- Statement: uniform selection at the stipulated pole is the fragment, `Iff.rfl` +-- Statement: uniform selection at the stipulated pole is the fragment, `Iff.rfl` +#check @ZeroParadox.uniformChartSelection_iff_choiceFragment -- Statement: pole discrimination: an `Option` decides its own `none` (`registeredDecider`); a total -- test of definedness on `Part Unit` gives excluded middle (`em_of_poleDiscriminator`). #check @ZeroParadox.registeredDecider -#check @ZeroParadox.em_of_poleDiscriminator -- Statement: a total definedness test on `Part Unit` gives excluded middle +-- Statement: a total definedness test on `Part Unit` gives excluded middle +#check @ZeroParadox.em_of_poleDiscriminator -- Statement: Lawvere's fixed-point-free swap: free with `DecidableEq`; over every `Type`, weak excluded -- middle (case 2, § IV). #check @ZeroParadox.fixedPointFree_of_nontrivial_decidable -#check @ZeroParadox.wem_of_fixedPointFree -- Statement: the general fixed-point-free principle gives weak excluded middle +-- Statement: the general fixed-point-free principle gives weak excluded middle +#check @ZeroParadox.wem_of_fixedPointFree -- Statement: the die's piece at ⊥: free with `DecidableEq`; over every partial order with a least -- element on a `Type`, weak excluded middle (case 3, § IV); for every cover, Mathlib's form, excluded -- middle (beside case 3, § IV). diff --git a/ZeroParadox/Category/ChoiceCannotBe.md b/ZeroParadox/Category/ChoiceCannotBe.md index 594fca34..2e901087 100644 --- a/ZeroParadox/Category/ChoiceCannotBe.md +++ b/ZeroParadox/Category/ChoiceCannotBe.md @@ -25,35 +25,49 @@ framework's standing temptation. The literature that separates them: > **Diaconescu (1975)**: in a topos, the axiom of choice implies excluded middle. **Goodman–Myhill > (1978, p. 461)** give the analogue in intuitionistic set theory. Diaconescu's theorem is stated as an -> **equivalence** — a coequalizer of two nonintersecting monomorphisms has a section *iff* subobjects have complements (p. 176); "AC implies complemented -> subobjects" is the corollary (p. 178). The theorem already concerns a two-point shape, since such a +> **equivalence** — a coequalizer of two nonintersecting monomorphisms has a section *iff* subobjects +> have complements (p. 176); the choice direction is +> the corollary, "AC implies that every subobject has a complement" (p. 178). The theorem already +> concerns a two-point shape, since such a > coequalizer has fibres of at most two points; Goodman–Myhill state the restriction explicitly, choice > "for sets B, C of at most two elements". With unique choice into `Bool`, `ChoiceFragment` and excluded -> middle are inter-derivable (the `example` after `em_of_choiceFragment` in -> `ZeroParadox/Category/ExcludedMiddleBridge.lean`). +> middle are inter-derivable (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, the `example` after +> `em_of_choiceFragment`). +> +> **Lawvere (1964/65)**, the antecedent: his author commentary to *An Elementary Theory of the Category +> of Sets (Long Version) with Commentary* (Reprints in TAC 11, 2005, p. 5) says that among the results +> of the 1965 manuscript "is the fact that the axiom of choice implies classical logic", later proved by +> Diaconescu "under the strong hypothesis that the ambient category is a topos", while the manuscript +> derives the topos property from choice as well. Read in the reprint's commentary only; the +> manuscript's own proof was not checked against that description here. > > **Cohen (1963)**, with Fraenkel–Mostowski: *full* AC is strictly stronger than excluded middle. This > is an independence result about ZF, **not** anything Diaconescu proved — do not attribute it to him. So *full* choice is strictly stronger than excluded middle, which is in turn strictly stronger than the constructive base. **The restricted fragment is a different matter, and the distinction matters here.** -`ZeroParadox/Category/ExcludedMiddleBridge.lean`'s `ChoiceFragment` is a choice principle into the two-element `Bool` — a -chooser on every inhabited predicate on `Bool` — so in a topos, which always has unique choice, it is *equivalent* to excluded middle (the standard -Diaconescu–Goodman–Myhill theorem); in Lean the equivalence holds with unique choice into `Bool` as a -hypothesis (the `example` after `em_of_choiceFragment`). In Lean, the natural construction of the -fragment from excluded middle fails to elaborate, dying at `Decidable (S true)`, and closes only under -`classical`. **That failure measures that construction, not the fragment** — a failed elaboration is not -a negative result, and a formal independence claim would -need a metatheoretic argument outside Lean (the home file +`ZeroParadox/Category/ExcludedMiddleBridge.lean`'s `ChoiceFragment` is a choice principle into the +two-element `Bool` — a chooser on every inhabited predicate on `Bool` — so in a topos, which always has +unique choice (E. J. Dubuc and M. Szyld, Tannaka Theory for Topos, arXiv:1510.01775v1, Prop. 1.24, p. 10), it is *equivalent* to excluded middle (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, +the `example` after `em_of_choiceFragment`). +In Lean without unique choice, the natural construction of the fragment from excluded middle alone +fails to elaborate, dying at `Decidable (S true)`, and closes only under `classical`. **That failure +measures that construction, not the fragment** — a failed elaboration is not a negative result, and a +formal independence claim would need a metatheoretic argument outside Lean (the home file `ZeroParadox/Category/ExcludedMiddleBridge.lean` states this limit explicitly). `Reading:` a candidate explanation of the apparent gap between that equivalence and that failed construction is **Lean's `Prop`/`Type` stratification**, not anything in Diaconescu's theorem. The fragment's chooser returns data, a `Bool` (`ChoiceFragment`), while `ExcludedMiddle` is `Prop`-valued, and Lean's stratification does not let `Or` in `Prop` eliminate into `Bool`. A topos also distinguishes its -truth-value object from 1 + 1 (they coincide exactly when it is Boolean); there unique choice holds, so -a decided proposition determines an element of 1 + 1, and without unique choice the equivalence need not carry over to Lean. Whether the fragment is derivable from `ExcludedMiddle` in -Lean is not established here, so this explanation is a candidate, not a finding; the topos theorem is -Diaconescu's. Every evocative reading in the framework's prose — "choice is which way you view the +truth-value object from 1 + 1 (they coincide exactly when it is Boolean); there unique choice holds +(Dubuc and Szyld, cited above), so a decided proposition determines an element of 1 + 1 (this form not +located in a source as of 2026-11-01; searched in topos-theory notes and theses held locally and on the +open web, while the theorem-search and Lean-library queries targeted unique choice, not this form), and +without unique choice the equivalence need not carry over to Lean. Whether the fragment is derivable +from `ExcludedMiddle` in Lean without `Classical.choice` and without a unique-choice hypothesis is not +established here, so this explanation is a candidate, not a finding. The topos-side equivalence of the +fragment with excluded middle, earlier in this paragraph, is Diaconescu's argument; nothing in it is +claimed here. Every evocative reading in the framework's prose — "choice is which way you view the self-dual split", "reading the pole as the floor is an act of choice" — is a **model** of the choice-versus-no-choice distinction, never the axiom itself. Where such a reading has been made precise (`ZeroParadox/Valuation/PoleChartSelection.lean`), the honest result was that the built object **refutes** the naive @@ -65,7 +79,8 @@ every Heyting algebra Boolean; the scope is `Prop`). ### No count is recorded here, deliberately -**`ChoiceCannotBe.lean` and this long form state no figure for how many declarations carry `Classical.choice`, and none should be added +**`ChoiceCannotBe.lean` and this long form state no figure for how many declarations carry +`Classical.choice`, and none should be added to it.** Three reasons, in order of importance. **A count mostly measures Mathlib, not this framework.** Most choice footprints traced so far come from a @@ -74,7 +89,8 @@ Mathlib construction — the `Ordinal` order instance and operations (`Ordinal.i `compl_sup_distrib`, arbitrary-type decidability, a `ℚ` division-ring instance, in one case a single tactic call. **Not all: `ZeroParadox/Category/Lawvere.lean`'s bare `classical` in `fixedPointFree_of_nontrivial` is the framework's own, and § IV classifies it ESSENTIAL, on the -premise stated there** — the cost is in stating the swap over types **whose equality is not decidable** (the swap is `if x = b₀ then b₁ else b₀`; +premise stated there** — the cost is in stating the swap over types **whose equality is not decidable** +(the swap is `if x = b₀ then b₁ else b₀`; decidable equality is exactly what the § IV escape restores), which is the framework's chosen generality, not Mathlib's. `ZeroParadox/Die.lean`'s bare `classical`s in `botCovered_botIntervalTwo_classical`, `Motion.registeredDecidable_of_classical` and @@ -166,13 +182,23 @@ fraction either**; it moves with every commit. fragment is not plain intuitionistic logic, so the § IV premise is what carries that non-provability over to it. Reaching a weaker taboo is a weaker implication and needs a stronger premise. **The located cases, and the premise, are in § IV** (`em_of_wellOrder_comparable`, `wem_of_fixedPointFree`, - `wem_of_botCovered_botIntervalTwo`, `Motion.em_of_registeredDecidable`, `Motion.em_of_selectedData`). Detected by *reducing* — deriving a taboo from the + `wem_of_botCovered_botIntervalTwo`, `Motion.em_of_registeredDecidable`, `Motion.em_of_selectedData`). + Detected by *reducing* — deriving a taboo from the principle — which is the mirror image of the accidental test: accidental is shown by re-proving without choice, essential by showing that re-proving without choice would prove a taboo. Note this is a statement about the PRINCIPLE, not about any one proof of it: `#print axioms` on a proof reports that proof's footprint and can never witness the principle's necessity, which is exactly why the essential side needs a reduction instead of a measurement. -* **STATEMENT-CARRIED** — the statement's own type carries `Classical.choice`: a theorem that only assumes the statement and proves `True` already reports it (the statement control). No proof can remove it, so neither ACCIDENTAL nor ESSENTIAL can be asked of it. What can be asked is whether a restatement, on a carrier whose statements are choice-free, holds without choice. Detected by the statement control; members are listed in § I/§ III where measured. +* **STATEMENT-CARRIED** — the statement's own type carries `Classical.choice`: a theorem that only + assumes the statement and proves `True` already reports it (the statement control). No proof can + remove it, so neither ACCIDENTAL nor ESSENTIAL can be asked of it. What can be asked is whether a + restatement, on a carrier whose statements are choice-free, holds without choice. Detected by the + statement control; members are listed in § I/§ III of `ZeroParadox/Category/ChoiceCannotBe.lean` + where measured there, and otherwise in the file that measures them: `decoration_unique` carries it + through its `[Fintype V]` binder under the instances the pinned Mathlib supplies, with its statement + controls in the `DecorationUniverse` `[ZP-CUSTOM]` line of `ZeroParadox/Settheory/APG.lean` (ZP-J AFA + Addendum, Section V). Membership is relative to those instances (§ III, STATEMENT-CARRIED IS + INSTANCE-RELATIVE). "The statement" in STATEMENT-CARRIED is the term as written, which is what the statement control measures; a definitionally equal respelling whose own statement is choice-free is a restatement in @@ -183,6 +209,8 @@ The same split between a statement's and a proof's reach of `Classical.choice` i by V. Gonzalez, "Where Formal Libraries Spend Their Axioms", Zenodo 2026, doi:10.5281/zenodo.21769846 (page numbers from v1.0.3, doi:10.5281/zenodo.21866855), § 4 (p. 8) and § 8 (p. 14): a theorem whose statement mentions something choice-dependent "cannot be made choice-free however it is proved" (cited, not claimed). +This long form states the same split for its own statements in its own voice: STATEMENT-CARRIED +above ("No proof can remove it"). Prior art for the distinction and its methods: constructive reverse mathematics, which classifies theorems ("to classify [over intuitionistic logic] various theorems … by logical principles") and whose diff --git a/ZeroParadox/Category/CoalgebraForkPlace.lean b/ZeroParadox/Category/CoalgebraForkPlace.lean index b50aec3a..e07211b5 100644 --- a/ZeroParadox/Category/CoalgebraForkPlace.lean +++ b/ZeroParadox/Category/CoalgebraForkPlace.lean @@ -78,8 +78,8 @@ not used here). The three universal-property-flavoured facts (`fix_isFixedPoint` `cofix_corec_commutes`) are *generic* QPF facts — true of every QPF, re-exported from Mathlib — not ZP-specific content; the only ZP-specific non-trivial content is `ZeroParadox/Settheory/Coalgebra.lean`'s strict empty/inhabited fork on `idPF_Coalgebra`, bundled in at the end. Naming this the "μ/ν root" of the framework's -bottom diagram, and identifying it with the diagonal fixed point of the other layers, is the -cross-instance modeling commitment (ZP-P hard fence), not a theorem. +bottom diagram is a reading; it relates to the other layers' diagonal fixed points by a role, not an identity +(`cofix_quine_role_occupied`, `ZeroParadox/Settheory/Coalgebra.lean`; no cross-chart equation, ZP-P hard fence). -/ namespace ZeroParadox diff --git a/ZeroParadox/Category/DiagonalWitness.lean b/ZeroParadox/Category/DiagonalWitness.lean index 1254fc03..fda18fe3 100644 --- a/ZeroParadox/Category/DiagonalWitness.lean +++ b/ZeroParadox/Category/DiagonalWitness.lean @@ -50,11 +50,11 @@ theorem no_witnessRel_of_admissible_fpf {β : Type*} {M : (β → β) → Prop} exact hgf b hb -- Statement: with literal equality the computable endomaps of codes carry no relativized witness: --- `fun c => Code.pair c c` is computable and fixes no code. +-- `fun c => Code.pair c c` is computable and fixes no code (`code_pair_diag_fixedPointFree`, +-- `ZeroParadox/Category/Lawvere.lean`). example : ¬ HasWitnessRel Nat.Partrec.Code Computable := no_witnessRel_of_admissible_fpf (g := fun c => Nat.Partrec.Code.pair c c) - (Nat.Partrec.Code.primrec₂_pair.comp Primrec.id Primrec.id).to_comp - (fun c h => by have := congrArg sizeOf h; simp at this) + code_pair_diag_fixedPointFree.1 code_pair_diag_fixedPointFree.2 /-- **Antitone in the admissible class (the topology spine).** Shrinking the admissible endomap class can only help the witness. So `{M | HasWitnessRel β M}` is downward-closed in `⊆` — a lower set / @@ -113,7 +113,8 @@ theorem hasWitnessRel_of_subsingleton {β : Type u} [Nonempty β] [Subsingleton inclusion), the set of classes carrying a diagonal witness is a **lower set** — downward closed. A lower set is exactly a closed set of the Alexandrov topology on the poset, so this is the topology the diagonal-fixed-point collection sits on: the fork (wall vs floor) is the boundary of one closed - set, crossed as the admissible class shrinks past the fixed-point-free diagonal. Immediate from + set. One way only: the floor can switch on only once the class contains no fixed-point-free map + (`no_witnessRel_of_admissible_fpf`); the converse is not claimed. Immediate from `witnessRel_antitone`. -/ theorem witnessSet_isLowerSet {β : Type u} : IsLowerSet {M : Set (β → β) | HasWitnessRel β M} := by @@ -122,19 +123,23 @@ theorem witnessSet_isLowerSet {β : Type u} : /-! ## § Axis 2 — the genuine floor in the effective category (joining the effective-topos program) -The `HasWitnessRel` topology above is axis 1: the admissible map-class M *within* a fixed category -(raw functions, raw equality). The genuine NONTRIVIAL floor lives one axis out — in the **effective -category**, where "endomap" means computable and "equality" means eval-equality. There the Cantor -obstruction lifts, and the diagonal genuinely closes: Rogers' fixed-point / Kleene's recursion theorem. This is the -recognized **effective-topos / Turing-category** setting (Lawvere 1969; Hyland 1982, "The effective -topos"; Cockett–Hofstra 2008, "Introduction to Turing categories"; van Oosten). Located and cited here, -NOT claimed — the framework joins that program. -/ +The `HasWitnessRel` topology above is axis 1: the admissible map-class M *within* a fixed category (raw functions, +raw equality). The genuine NONTRIVIAL floor lives one axis out — in the **effective category**, where "endomap" +means computable and "equality" means eval-equality. There the Cantor obstruction lifts, and the diagonal genuinely +closes: Rogers' fixed-point / Kleene's recursion theorem. This is the recognized **effective-topos / Turing-category** +setting (Lawvere 1969, TAC reprint § 2 p. 9, only asks about the recursive case; Hyland 1982, "The effective +topos"; Cockett–Hofstra 2008, "Introduction to Turing categories"; van Oosten 2008, *Realizability*, §3.7 (a sketch of what we identify as Bauer 2006), whose Cor. 3.7.7, the recursion +theorem, is derived from the one non-logical axiom that section adds to its standing topos hypotheses; scope in +`ZeroParadox/Category/DiagonalWitness.md`). Located and cited here, NOT claimed — the framework joins that program. -/ /-- **Axis-2 genuine floor.** Every *computable* self-map on codes has an eval-fixed point — **Rogers' fixed-point theorem** (`computability_face_fixedPoint` = Mathlib `Nat.Partrec.Code.fixed_point`). Mathlib reserves the name *Kleene's second recursion theorem* for `fixed_point₂`, and literally derives `fixed_point₂` from `fixed_point`, so the two are - inter-derivable. `ZeroParadox/Category/Lawvere.lean` attaches **both** names to `fixed_point` as a + inter-derivable. The split is Mathlib's naming: in Rogers 1967 `fixed_point` is Theorem 11-I + (p. 180), a special case of Theorem 11-IV, which he notes is sometimes called the second + recursion theorem (p. 196), and the two-place form is "Kleene's version" (Exercise 11-4, p. 214). + `ZeroParadox/Category/Lawvere.lean` attaches **both** names to `fixed_point` as a slash-alias ("Rogers / Kleene's recursion theorem") rather than making this split — compatible, but not the same convention. The fine end of axis 2. -/ theorem effective_floor_fixedPoint {g : Nat.Partrec.Code → Nat.Partrec.Code} (hg : Computable g) : @@ -142,10 +147,10 @@ theorem effective_floor_fixedPoint {g : Nat.Partrec.Code → Nat.Partrec.Code} ( computability_face_fixedPoint hg /-- **Why the wall lifts in the effective category (the axis-2 mechanism).** There is no *computable* - self-map on codes that is eval-fixed-point-free: the recursion theorem forces a fixed point. So the - diagonal swap that refutes the witness at the Set level (`no_witnessRel_of_admissible_fpf`) has NO - computable representative up to `eval`; with literal equality one exists (the `example` after - `no_witnessRel_of_admissible_fpf`). This is why the floor can switch on along axis 2. -/ + self-map on codes that is eval-fixed-point-free, so the Set-level refutation + (`no_witnessRel_of_admissible_fpf`) has no computable instance up to `eval`. Under literal + equality it runs (`fun c => Code.pair c c`, the `example` after that theorem). Hence the floor + can switch on along axis 2. -/ theorem no_computable_evalFixedPointFree {g : Nat.Partrec.Code → Nat.Partrec.Code} (hg : Computable g) : ¬ (∀ c, Nat.Partrec.Code.eval (g c) ≠ Nat.Partrec.Code.eval c) := by intro hfpf @@ -232,7 +237,6 @@ theorem no_witnessRel_evalClass_top : ¬ HasWitnessRel EvalClass (fun _ => True) exact (hd : False) refine no_witnessRel_of_admissible_fpf (g := fun y => if y = ⟦Code.zero⟧ then ⟦cn⟧ else ⟦Code.zero⟧) trivial (fun y hy => ?_) - dsimp only at hy by_cases h : y = ⟦Code.zero⟧ · rw [if_pos h] at hy; exact hne (h ▸ hy.symm) · rw [if_neg h] at hy; exact h hy.symm diff --git a/ZeroParadox/Category/DiagonalWitness.md b/ZeroParadox/Category/DiagonalWitness.md index afdc4866..573f93a3 100644 --- a/ZeroParadox/Category/DiagonalWitness.md +++ b/ZeroParadox/Category/DiagonalWitness.md @@ -3,12 +3,21 @@ Argument and attribution for `ZeroParadox/Category/DiagonalWitness.lean`, moved from its module docstring. The Lean file holds the declarations, the Engineer's Take and the per-declaration glosses. -`ZeroParadox/DiagonalFixedPoint.lean` *collects* the faces of self-reference; the Lean file asks what they **minimally -have in common**, one level beneath the μ/ν fork. The engine is the diagonal argument of **Lawvere +`ZeroParadox/DiagonalFixedPoint.lean` *collects* the faces of self-reference; the Lean file asks what +they **minimally have in common**, one level beneath the μ/ν fork. The engine is the diagonal argument of **Lawvere (1969)**, restated by **Yanofsky (2003)**; that whether the witness exists is *category-relative* is the -recognized effective-topos / Turing-category observation (**Hyland 1982; Cockett–Hofstra 2008; van -Oosten**). The Lean file only *packages* those — `HasWitnessRel` is a formalization lever, not a new -theorem, and its level sets are the per-face verdicts already proven in `ZeroParadox/Category/Lawvere.lean` §V–VI. +recognized effective-topos / Turing-category observation (**Hyland 1982; Cockett–Hofstra 2008**). +Section 3.7 of **van Oosten 2008** (*Realizability: An Introduction to its Categorical Side*) is a +sketch of A. Bauer's ideas (p. 231), from the paper van Oosten cites as [13] (p. 230); we identify that +paper as **Bauer 2006**, "First Steps in Synthetic Computability Theory", ENTCS 155. In that section +Prop. 3.7.1 (p. 231, credited to Lawvere) gives every map `B → B` a fixed point from a surjection +`A → B^A`, and Cor. 3.7.7 (p. 233), "the Recursion theorem", is derived from §3.7's single non-logical +axiom, that `Σ^N` is enumerable (p. 232), `Σ` being the r.e. subobject classifier (p. 231), in a topos +where `N` is projective and internally projective, every ¬¬-stable subobject of an (internally) +projective object is (internally) projective, and Markov's Principle holds (p. 231). +The Lean file only *packages* the Lawvere–Yanofsky diagonal and the category-relative observation — +`HasWitnessRel` is a formalization lever, not a new theorem, and its level sets are the per-face +verdicts already proven in `ZeroParadox/Category/Lawvere.lean` §V–VI. There the bare `HasLawvereWitness β` (a point-surjection `α → (α → β)`) is FALSE for every nontrivial type in **Set** (Cantor), so the lattice and 2-adic faces are *posited* fixed points, while the computability (Kleene) face is *genuine* — in the **effective** category. @@ -22,8 +31,9 @@ that "count" in the ambient category. The face table becomes level sets of ONE p - **M coarse (all endomaps), β nontrivial** — a fixed-point-free swap is admissible ⇒ no witness. Set floor faces are *posited*, wall faces *refuted*. - **M fine (computable endomaps)** — with `HasWitnessRel`'s literal equality the obstruction stays: - `fun c => Code.pair c c` is computable and fixes no code (the `example` after - `no_witnessRel_of_admissible_fpf` in the Lean file). It is removed only up to `eval` (the Lean + `fun c => Code.pair c c` is computable and fixes no code (`code_pair_diag_fixedPointFree`, + `ZeroParadox/Category/Lawvere.lean`; the `example` after `no_witnessRel_of_admissible_fpf` in the Lean + file draws the consequence). It is removed only up to `eval` (the Lean file's § Axis 2, `no_computable_evalFixedPointFree`), and even there its absence does not by itself supply the witness: `fixedPoint_of_witnessRel` runs from a witness to fixed points, one way. The witness itself is built on the quotient of codes by equal `eval`, relative to the maps induced by @@ -31,15 +41,16 @@ that "count" in the ambient category. The face table becomes level sets of ONE p Theorem 5, p. 18); relative to the class of all maps on that quotient there is none (`no_witnessRel_evalClass_top`), and with literal equality on codes there is none either (above). The general diagonal fixed point on this side, with no `eval`-respecting hypothesis, is **Rogers' - fixed-point theorem**, cited rather than derived there (`Nat.Partrec.Code.fixed_point`, aliased as `computability_face_fixedPoint` - in `ZeroParadox/Category/Lawvere.lean`; Mathlib reserves *Kleene's second recursion theorem* for - `fixed_point₂`). + fixed-point theorem**, cited rather than derived there (`Nat.Partrec.Code.fixed_point`, aliased as + `computability_face_fixedPoint` in `ZeroParadox/Category/Lawvere.lean`; Mathlib reserves *Kleene's + second recursion theorem* for `fixed_point₂`). ## The topology (why "underlying level" makes it obvious) `HasWitnessRel β ·` is **antitone** in `M`: shrinking the admissible class can only help the witness. So `{M | HasWitnessRel β M}` is downward-closed in `⊆` — a lower set on the lattice of admissible-map-classes, i.e. a **closed set in the Alexandrov topology** on that lattice. The wall/floor/posited trichotomy is the -level structure of one monotone predicate over that space; the floor can "switch on" only once `M` drops -below every admissible fixed-point-free map (`no_witnessRel_of_admissible_fpf`). That lattice-of-map-classes, with the witness as an Alexandrov-closed -set, is the topology the collection carries. +level structure of one monotone predicate over that space; the floor can "switch on" only once `M` +contains no fixed-point-free map (`no_witnessRel_of_admissible_fpf`, a necessary condition, one way). +That lattice-of-map-classes, with the witness as an Alexandrov-closed set, is the topology the +collection carries. diff --git a/ZeroParadox/Category/DieNucleus.lean b/ZeroParadox/Category/DieNucleus.lean index 77f848bf..652429e5 100644 --- a/ZeroParadox/Category/DieNucleus.lean +++ b/ZeroParadox/Category/DieNucleus.lean @@ -232,10 +232,11 @@ example (s : WithTop Ordinal → WithTop Ordinal → Prop) : `Reading:` measured `[propext]` (printed below). A `Nucleus X` carries `[SemilatticeInf X]` and no `Order.Frame X`, so the `SemilatticeInf Prop` instance in the statement is the one unification reads off the pinned `Prop.instHeytingAlgebra` through `Lattice.toSemilatticeInf`, and that instance is - choice-free; the instance `inferInstance` synthesizes for `SemilatticeInf Prop` under this file's - imports routes through `Prop.instCompleteLinearOrder` and carries `Classical.choice`, as `Order.Frame - Prop` does, and forcing it into this motion carries that footprint (`dnegLandingForcedInstance`, - printed below). -/ + choice-free. The instance `inferInstance` synthesizes for `SemilatticeInf Prop` under this file's + imports routes through `Prop.instCompleteLattice`, and forcing it into this motion gives + `dnegLandingForcedInstance`, `[propext]` (printed below). `Prop.completeLinearOrder` + and `Prop.linearOrder` are definitions, not instances, and carry `Classical.choice`, as the + synthesized `Order.Frame Prop` does. -/ theorem em_iff_ofNucleus_dneg_isLanding (s : Prop → Prop → Prop) : ExcludedMiddle ↔ ∀ p : Prop, (Motion.ofNucleus (@dnegNucleus Prop Prop.instHeytingAlgebra) s).IsLanding p := by @@ -341,8 +342,8 @@ Measured from the build log, 2026-10-21. `toNucleus` depends on no axioms; `ofNu `[propext, Quot.sound]`. `ofNucleus_bot_up` is `rfl`, so its footprint is the statement's, through Mathlib's `⊥ : Nucleus X` (`ofNucleus_top_up`, the same proof at `⊤`, is the control). The bare-`Ordinal` member and `snapNucleusTop_isLanding_iff` are STATEMENT-CARRIED through Mathlib's `Ordinal` fixed-point theory, as for -`snapNucleus` in `ZeroParadox/Ordinal/SnapNucleus.lean`. On `Prop` the statement's `SemilatticeInf` instance is -read off `Prop.instHeytingAlgebra`, `[propext]`; the synthesized one and `dnegLandingForcedInstance` carry choice (all printed below). -/ +`snapNucleus` in `ZeroParadox/Ordinal/SnapNucleus.lean`. On `Prop`, `Prop.instHeytingAlgebra` and +`dnegLandingForcedInstance` measure `[propext]` and `Prop.completeLinearOrder` carries choice (printed below). -/ section PurityCheck open ZeroParadox @@ -364,8 +365,8 @@ open ZeroParadox #print axioms snapNucleusTop_isLanding_iff #print axioms em_iff_ofNucleus_dneg_isLanding #print axioms dnegLandingForcedInstance --- Mathlib, the two `Prop` instances contrasted above: the pinned one and the synthesized one. +-- Mathlib: the pinned `Prop` instance, and `Prop.completeLinearOrder`, a definition, not an instance. #print axioms Prop.instHeytingAlgebra -#print axioms Prop.instCompleteLinearOrder +#print axioms Prop.completeLinearOrder end PurityCheck diff --git a/ZeroParadox/Category/DifferenceGeneratesSystem.lean b/ZeroParadox/Category/DifferenceGeneratesSystem.lean index 26889d38..f726630c 100644 --- a/ZeroParadox/Category/DifferenceGeneratesSystem.lean +++ b/ZeroParadox/Category/DifferenceGeneratesSystem.lean @@ -76,8 +76,9 @@ end /-! ### § The canonical predicated difference — double negation generates the classical (Boolean) core The `example`s below: double negation `a ↦ aᶜᶜ` on a Heyting algebra is a closure whose fixed points, -the regular elements, form a `BooleanAlgebra` (`Heyting.Regular`), so it generates classical logic, not -choice. The Glivenko credit and the logic-versus-choice fence: +the regular elements, form a `BooleanAlgebra` (`Heyting.Regular`): it generates classical logic. That +it does not generate choice is a separate fence, not a consequence of these examples. The Glivenko +credit and that fence: `ZeroParadox/Category/DifferenceGeneratesSystem.md`. No new declarations. -/ section diff --git a/ZeroParadox/Category/DifferenceGeneratesSystem.md b/ZeroParadox/Category/DifferenceGeneratesSystem.md index 5e45877e..4f7ad38e 100644 --- a/ZeroParadox/Category/DifferenceGeneratesSystem.md +++ b/ZeroParadox/Category/DifferenceGeneratesSystem.md @@ -27,8 +27,8 @@ independence, *not* Diaconescu, whose own theorem is an **equivalence** between (p. 176) and already concerns a two-point shape; the analogue in intuitionistic set theory is Goodman–Myhill (1978), who state the restriction explicitly, choice "for sets B, C of at most two elements" (p. 461). With unique choice into `Bool`, `ChoiceFragment` and `ExcludedMiddle` are -inter-derivable (the `example` after `em_of_choiceFragment` in -`ZeroParadox/Category/ExcludedMiddleBridge.lean`). So: double negation is the +inter-derivable (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, the `example` after +`em_of_choiceFragment`). So: double negation is the difference that generates the classical core, and full choice sits above it. See `ZeroParadox/Category/ChoiceCannotBe.lean` for the precise attributions. Stated below with `example`s only (no new declarations) — this file *identifies*, it does not add a result. diff --git a/ZeroParadox/Category/Directed.lean b/ZeroParadox/Category/Directed.lean index 4a5b1581..ba508a4a 100644 --- a/ZeroParadox/Category/Directed.lean +++ b/ZeroParadox/Category/Directed.lean @@ -7,7 +7,7 @@ set_option maxHeartbeats 400000 # The Kleisli snap floor is not isomorphic to any object above it **Proves.** `kleisli_obj_not_iso_bot`: in `KleisliCat PMF`, for `n > 0`, `fC_functor.obj 0` is not -isomorphic to `fC_functor.obj n`. One-line consequence of `fC_no_return` (no morphism back into the floor): +isomorphic to `fC_functor.obj n`. One-line consequence of `fC_no_return` (no morphism into the floor from a stage `n > 0`): an iso would supply one. The content is "no return ⟹ not iso to anything above it", about one domain. **Reaching for (intent, NOT proved here).** This was *aimed at* the NP-complete reframe — testing whether @@ -33,8 +33,8 @@ namespace ZeroParadox open CategoryTheory ZeroParadox /-- **The MC-1 bottom is directed, not mutual (B7).** In `KleisliCat PMF` the snap floor admits no - return morphism from any nonempty object (`fC_no_return`), so it is not isomorphic to any such - object: there is no mutual/equivalence pairing with anything above it. The bottom sits strictly at + morphism into it from any stage `fC_functor.obj n` with `n > 0` (`fC_no_return`), so it is not + isomorphic to any such stage: there is no mutual/equivalence pairing with any stage above it. The bottom sits strictly at the source of a directed structure — the snap's irreversibility *is* the failure of mutuality, so MC-1's bottoms do not form a single mutual (NP-style) degree. -/ theorem kleisli_obj_not_iso_bot {n : ℕ} (hn : 0 < n) : diff --git a/ZeroParadox/Category/DoubleNegationNucleus.lean b/ZeroParadox/Category/DoubleNegationNucleus.lean index bd4f160f..05944101 100644 --- a/ZeroParadox/Category/DoubleNegationNucleus.lean +++ b/ZeroParadox/Category/DoubleNegationNucleus.lean @@ -49,8 +49,8 @@ theorem dneg_inf_distrib {X : Type*} [HeytingAlgebra X] (a b : X) : /-- **The double-negation nucleus** `a ↦ aᶜᶜ` on a Heyting algebra: the canonical predicated difference — the modality that collapses the constructive base toward the classical (Boolean) core. A genuine `Nucleus` (needs only that meets exist): inflationary (`le_compl_compl`), idempotent - (`compl_compl_compl`), meet-preserving (`dneg_inf_distrib`). The double-negation-side parallel of - `snapNucleus`. Axiom footprint `[propext]` — choice-free; see the file header. -/ + (`compl_compl_compl`), meet-preserving (`dneg_inf_distrib`); the parallel of `snapNucleus`. + Axiom footprint `[propext]` — choice-free; see `ZeroParadox/Category/DoubleNegationNucleus.md`. -/ def dnegNucleus (X : Type*) [HeytingAlgebra X] : Nucleus X where toFun a := aᶜᶜ map_inf' := dneg_inf_distrib diff --git a/ZeroParadox/Category/DoubleNegationNucleus.md b/ZeroParadox/Category/DoubleNegationNucleus.md index def45d81..11bdc8d0 100644 --- a/ZeroParadox/Category/DoubleNegationNucleus.md +++ b/ZeroParadox/Category/DoubleNegationNucleus.md @@ -17,7 +17,9 @@ examples were about: the double-negation map `a ↦ aᶜᶜ` as a genuine `Nucle This is the exact parallel to `snapNucleus` (`ZeroParadox/Ordinal/SnapNucleus.lean`). Both are concrete difference-generators — inflationary, idempotent, meet-preserving modalities — of two of the framework's -threads: the **snap** (the ordinal difference `α ↦ ω^α`, generating ε₀) and **double negation** (the +threads: the **snap** (the ordinal difference `α ↦ ω^α`, which from ⊥ of `Ordinal` generates ε₀ +(`epsilon0_eq_nfp_bot`), at once the least fixed point of `α ↦ ω^α` and the supremum of the ω-tower, `epsilon0_min_eq_max` in +`ZeroParadox/Ordinal/Epsilon0MinMax.lean`) and **double negation** (the logical difference `a ↦ aᶜᶜ`, generating the classical core). Applying the modality collapses to the classical core: `aᶜᶜ` is the element after excluded middle has settled it to a definite value. The generated system — the nucleus's closed points — is exactly the **regular elements** `{a | aᶜᶜ = a}`, the @@ -55,12 +57,13 @@ Cohen's 1963 independence result (with Fraenkel–Mostowski), **not** Diaconescu proved is an *equivalence* between two topos properties (p. 176), and it already concerns a two-point shape; the analogue in intuitionistic set theory is Goodman–Myhill (1978), who state the restriction explicitly, choice "for sets B, C of at most two elements" (p. 461). With unique choice into `Bool`, -`ChoiceFragment` and `ExcludedMiddle` are inter-derivable (the `example` after `em_of_choiceFragment` in -`ZeroParadox/Category/ExcludedMiddleBridge.lean`). Attributing "the converse fails" to Diaconescu is a misreading; see -`ZeroParadox/Category/ChoiceCannotBe.lean` for the full statement and for why the restricted fragment -nonetheless comes apart from excluded middle in Lean specifically. The framework's conversational +`ChoiceFragment` and `ExcludedMiddle` are inter-derivable (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, +the `example` after `em_of_choiceFragment`). Attributing "the converse fails" to Diaconescu is a misreading; see +`ZeroParadox/Category/ChoiceCannotBe.lean` for the full statement and for a candidate explanation of +why the natural construction of the restricted fragment from excluded middle fails to elaborate in +Lean. The framework's conversational "choice = which way you view the self-dual split" reading is the looser, informal thread — discussed in -`ZeroParadox/Category/DifferenceGeneratesSystem.lean`, not asserted here; the object built here is the double-negation +`ZeroParadox/Category/ChoiceCannotBe.md` (§ "The headline fence"), not asserted here; the object built here is the double-negation (excluded-middle) nucleus, nothing stronger. **Correction of record: this file once made that error itself.** It was originally titled "Choice as a diff --git a/ZeroParadox/Category/ExcludedMiddleBridge.lean b/ZeroParadox/Category/ExcludedMiddleBridge.lean index 3257ca43..37f65f91 100644 --- a/ZeroParadox/Category/ExcludedMiddleBridge.lean +++ b/ZeroParadox/Category/ExcludedMiddleBridge.lean @@ -75,11 +75,12 @@ chooser bounded only in its codomain, and it is all `em_of_choiceFragment` consu Two things make this the faithful fragment rather than a weakened stand-in. First, the chooser is a *function of the predicate*, so extensionally equal predicates receive equal choices — that is precisely the leverage `em_of_choiceFragment` uses. Second, it is genuinely implied by Lean's `Classical.choice` -(`choiceFragment_of_classical` below), so the hypothesis is not vacuous. +(`choiceFragment_of_classical` below), so the hypothesis is satisfiable. **Faithfulness check (run 2026-07-19).** The worry worth taking seriously is the converse: if -`ExcludedMiddle → ChoiceFragment` were provable, the two would be equivalent and § II would be excluded -middle implying itself in costume, not a choice principle implying it. Measured result: the natural +`ExcludedMiddle → ChoiceFragment` were provable without unique choice into `Bool` (with it as a second +hypothesis it is: the `example` after `em_of_choiceFragment`), the two would be equivalent and § II would +be excluded middle implying itself in costume, not a choice principle implying it. Measured result: the natural construction `fun S => if S true then true else false` under only `ExcludedMiddle` **fails to elaborate** — `failed to synthesize instance of type class Decidable (S true)`. That is the `Prop`→`Bool` elimination barrier: excluded middle supplies a disjunction in `Prop`, which cannot be eliminated to produce data, @@ -90,13 +91,19 @@ choice, not through excluded middle, and the fragment **appears to sit above** ` **Honest limit:** a failed proof attempt is not a proof of unprovability. This is strong evidence — the failure is at the exact structural barrier that separates the two in type theory — not a formal independence result, which would need a metatheoretic argument outside Lean. -**And note what the barrier is and is not.** It is Lean's `Prop`/`Type` stratification: the fragment -yields data (`Bool`), so it is really `∀ p, Decidable p`, while `ExcludedMiddle` is `Prop`-valued and does -not eliminate into data. It is **not** a general fact about choice versus excluded middle — in a topos, -which always has unique choice, this very fragment is *equivalent* to excluded middle (the standard -Diaconescu–Goodman–Myhill theorem); in Lean the equivalence holds with unique choice into `Bool` as a +**And note what the barrier is and is not.** A candidate explanation, not a finding, is Lean's +`Prop`/`Type` stratification: the fragment's chooser yields data (`Bool`), and the fragment is +equivalent to `Nonempty (∀ p, Decidable p)`, while `ExcludedMiddle` is equivalent to +`∀ p, Nonempty (Decidable p)` (the `example`s after this definition), and `Or` in `Prop` does not +eliminate into data. The two differ only in whether `Nonempty` sits outside or inside `∀ p`; each +`Decidable p` has at most one element, so moving `Nonempty` outward is an instance of unique choice. +It is **not** a general fact about choice versus excluded middle — in a topos, +which always has unique choice (E. J. Dubuc and M. Szyld, *Tannaka Theory for Topos*, +arXiv:1510.01775v1, Prop. 1.24, p. 10), this very fragment is *equivalent* to excluded middle (by the +Diaconescu–Goodman–Myhill argument); in Lean the equivalence holds with unique choice into `Bool` as a hypothesis (the `example` after `em_of_choiceFragment`). -The gap measured here is a property of the ambient type theory, not of the two principles. -/ +On that candidate, the gap measured here is a property of the ambient type theory, not of the two +principles. -/ def ChoiceFragment : Prop := ∃ ch : (Bool → Prop) → Bool, ∀ S : (Bool → Prop), (∃ b, S b) → S (ch S) @@ -106,7 +113,49 @@ def ChoiceFragment : Prop := #check_failure (fun h : True ∨ False => (Or.casesOn (motive := fun _ => Bool) h (fun _ => true) (fun _ => false) : Bool)) example : Decidable True → Bool := fun h => - Decidable.casesOn (motive := fun _ => Bool) h (fun _ => false) (fun _ => true) + Decidable.falseTrueCases (motive := fun _ => Bool) (fun _ => false) (fun _ => true) h + +-- Statement: the fragment is equivalent to the propositional truncation of data-valued decidability, +-- `Nonempty (∀ p, Decidable p)`; the chooser decides `p` on the pair of predicates +-- `em_of_choiceFragment` uses. +-- Reading: both sides are theorems of Lean's classical ambient logic, so the content is the +-- construction, not the truth of the biconditional. Credit (cited, not claimed): nLab, +-- "Diaconescu-Goodman-Myhill theorem", lists among the equivalents of excluded middle "Finite sets +-- are choice (in fact, it suffices for 2 to be choice)"; this is a reading across Lean's +-- `Prop`/`Type` split. +example : ChoiceFragment ↔ Nonempty (∀ p : Prop, Decidable p) := by + refine ⟨fun ⟨ch, hch⟩ => ⟨fun p => ?_⟩, fun ⟨dec⟩ => ?_⟩ + · have hA := hch (fun b => b = true ∨ p) ⟨true, Or.inl rfl⟩ + have hB := hch (fun b => b = false ∨ p) ⟨false, Or.inl rfl⟩ + exact if h : ch (fun b => b = true ∨ p) = ch (fun b => b = false ∨ p) then + isTrue (hA.elim (fun hAt => hB.elim (fun hBf => absurd (hAt ▸ hBf ▸ h) (by decide)) id) id) + else + isFalse fun hp => h (by + have : (fun b => b = true ∨ p) = (fun b => b = false ∨ p) := + funext fun b => propext ⟨fun _ => Or.inr hp, fun _ => Or.inr hp⟩ + rw [this]) + · refine ⟨fun S => @decide (S true) (dec _), fun S hS => ?_⟩ + show S (@decide (S true) (dec _)) + generalize dec (S true) = d + cases d with + | isTrue h => exact h + | isFalse hn => + obtain ⟨b, hb⟩ := hS + cases b with + | true => exact absurd hb hn + | false => exact hb + +-- Statement: excluded middle is equivalent to `∀ p, Nonempty (Decidable p)`, `Nonempty` inside. +-- Credit: the forward leg is the `match` inside Lean core's `Classical.propDecidable` +-- (`Init/Classical.lean`), with the hypothesis in place of `Classical.em`; core then applies +-- `Classical.choice` to that `Nonempty`, a step this leg does not take. +example : ExcludedMiddle ↔ ∀ p : Prop, Nonempty (Decidable p) := + ⟨fun h p => (h p).elim (fun hp => ⟨isTrue hp⟩) (fun hn => ⟨isFalse hn⟩), + fun h p => (h p).elim fun d => match d with + | isTrue hp => Or.inl hp + | isFalse hn => Or.inr hn⟩ +-- Statement: each `Decidable p` has at most one element. +example (p : Prop) : Subsingleton (Decidable p) := inferInstance /-- **The fragment is non-vacuous.** Lean's `Classical.choice` supplies it. Footprint is classical by construction — that is the point: this is the *source* end of the § II arrow, and it inhabits the @@ -144,9 +193,10 @@ theorem em_of_choiceFragment (h : ChoiceFragment) : ExcludedMiddle := by have : A = B := funext fun b => propext ⟨fun _ => Or.inr hp, fun _ => Or.inr hp⟩ rw [this] -- `Bool` equality is decidable with no classical input. - rcases Bool.decEq (ch A) (ch B) with hne | heq - · exact Or.inr fun hp => hne (hpAB hp) - · rcases hA with hAt | hp + cases Bool.decEq (ch A) (ch B) with + | isFalse hne => exact Or.inr fun hp => hne (hpAB hp) + | isTrue heq => + rcases hA with hAt | hp · rcases hB with hBf | hp · exact absurd (hAt ▸ hBf ▸ heq) (by decide) · exact Or.inl hp @@ -171,6 +221,20 @@ example (uc : ∀ P : Bool → Prop, (∃! b, P b) → {b : Bool // P b}) : cases b with | true => exact absurd hb hn | false => exact hb +-- Reading (cited, not claimed): the Rocq standard library's `theories/Logic/ChoiceFacts.v` proves the +-- type-theoretic form of the excluded-middle-to-data leg, `constructive_definite_descr_excluded_middle` +-- (constructive definite description, `forall P, (exists! x, P x) -> {x | P x}` at every type, the +-- data-valued form of unique choice that the `uc` hypothesis above takes at `Bool`, with excluded +-- middle gives `forall P:Prop, {P} + {~ P}`), and states that +-- "constructive definite description transports excluded-middle from [Prop] to [Set]", crediting the +-- idea of its proof to L. Chicli, L. Pottier and C. Simpson, "Mathematical Quotients and Quotient +-- Types in Coq", TYPES 2002, LNCS 2646. Read in the authors' preprint (preprint page numbers): § 5, +-- pp. 12-13, shows the axiom of unique choice with values in `Prop` contradicts excluded middle in +-- `Prop` in Coq, completing the proof with the § 4.2 argument, pp. 10-11 (the goal is `False`, so the +-- existence of a map `Prop → bool` can be eliminated to give `{P} + {~P}`); their § 6, p. 13, says the +-- impredicativity of `Set` is essential to that proof. As in `ChoiceFacts.v`, the +-- credit is for that proof idea, not for the transport result. This example, with the one after +-- `ChoiceFragment`, is the `Bool`-chooser instance of that transport. /-! ## § III — Composition -/ diff --git a/ZeroParadox/Category/ExcludedMiddleBridge.md b/ZeroParadox/Category/ExcludedMiddleBridge.md index 9a72185a..e8020e5e 100644 --- a/ZeroParadox/Category/ExcludedMiddleBridge.md +++ b/ZeroParadox/Category/ExcludedMiddleBridge.md @@ -38,15 +38,25 @@ implication and not an identity — would be lost. Every `Prop`-scoped statement instance explicitly** as `@… Prop Prop.instHeytingAlgebra`. The measured footprints of both instances are recorded in the purity-check section at the end of this file. -**Prior art — the framework claims only the packaging.** § II is Diaconescu's theorem (Diaconescu 1975, +**Prior art — the framework claims only the Lean packaging.** § II is Diaconescu's argument (Diaconescu 1975, "Axiom of choice and complementation"; the analogue in intuitionistic set theory is Goodman-Myhill 1978, "Choice implies excluded middle"). It is not a new result and is not claimed as one. A search of Mathlib and the other `.lake` dependencies found **no** hypothesis-form statement of it (no `Diaconescu`, no `em_of_choice`); Lean's own kernel realizes the arrow concretely — `Classical.em` is *derived* from `Classical.choice` (`Init/Classical.lean`, whose docstring calls it "Diaconescu's theorem") by the two-predicate argument § II adapts to `Bool` — but as a derivation of the classical axioms, not as a reusable theorem taking the -choice principle as a hypothesis. This file supplies that hypothesis form so the arrow can be composed -with § I. § I and § IV are elementary and equally not new; the contribution is the assembly. +choice principle as a hypothesis. Outside Lean the hypothesis form exists: the Rocq standard library's +`theories/Logic/Diaconescu.v` states the argument with the choice principle as a hypothesis, in three +variants. Its Part C, `extensional_epsilon_imp_EM`, takes an extensional choice operator as section +hypotheses (`epsilon_spec`, `epsilon_extensionality`) and runs it at `bool` on the predicates +`y = false \/ P` and `y = true \/ P`, the pair § II uses; its Part A, `prop_ext_and_rel_choice_imp_EM`, +takes relational choice and propositional extensionality. Closer still to `ChoiceFragment` is the +file's backward-compatibility section `PredExt_RelChoice_imp_EM`, which chooses through +`AC_bool_subset_to_bool` ("a functional relation which chooses an element in any non empty subset of +bool") on the same pair, in `pred_ext_and_rel_choice_imp_EM`. The file credits Part C to Bell (1993; +not read here). This file supplies the hypothesis form in +Lean, so the arrow can be composed with § I. § I and § IV are elementary and equally not new; the +contribution is the assembly. **A correction to how this file first stated its prior art (2026-07-19).** It originally said Diaconescu proved "choice ⇒ excluded middle, one direction only, converse fails." That is wrong twice over. First, @@ -55,18 +65,39 @@ section *iff* subobjects have complements (1975, p. 176), the choice direction b (p. 178). The theorem already concerns a two-point shape: such a coequalizer has fibres of at most two points, and its proof runs over pp. 176-177. Goodman-Myhill state the restriction explicitly, choice "for sets B, C of at most two elements" (1978, p. 461). With unique choice into `Bool`, `ChoiceFragment` -and `ExcludedMiddle` are inter-derivable (the `example` after `em_of_choiceFragment`). +and `ExcludedMiddle` are inter-derivable (see `ZeroParadox/Category/ExcludedMiddleBridge.lean`, the `example` +after `em_of_choiceFragment`). Second, that *full* AC is strictly stronger than excluded middle is **Cohen 1963** / Fraenkel–Mostowski independence, not Diaconescu. **This matters here because `ChoiceFragment` is a choice principle into the two-element `Bool`** — a -chooser on every inhabited predicate on `Bool` — so in a topos, where unique choice holds, it would be -equivalent to `ExcludedMiddle`, and the -faithfulness check below would have to fail. It does not fail. The reason is that Lean stratifies `Prop` -and `Type`: `ChoiceFragment` selects into `Bool`, making it data-valued excluded middle -(`∀ p, Decidable p`), while `ExcludedMiddle` is the `Prop`-valued form, and `Or` in `Prop` does not -eliminate into `Bool`. A topos has no such split. **So the one-way-ness measured below is a fact about -Lean's stratification, and is this file's own small finding — not, as first written, a restatement of -Diaconescu.** +chooser on every inhabited predicate on `Bool` — so in a topos, where unique choice holds (E. J. Dubuc and M. Szyld, Tannaka Theory for Topos, arXiv:1510.01775v1, Prop. 1.24, p. 10) (see +`ZeroParadox/Category/ExcludedMiddleBridge.lean`, the `example` after `em_of_choiceFragment`), it would be equivalent to `ExcludedMiddle`, and the +faithfulness check below would have to fail. It does not fail. A candidate explanation is that Lean +stratifies `Prop` and `Type`: `ChoiceFragment` is equivalent to `Nonempty (∀ p, Decidable p)` and +`ExcludedMiddle` to `∀ p, Nonempty (Decidable p)` (the `example`s after `ChoiceFragment`; the forward +leg of the second is the `match` inside Lean core's `Classical.propDecidable`, `Init/Classical.lean`, +before core applies `Classical.choice`), and `Or` in +`Prop` does not eliminate into `Bool` (the `#check_failure` after `ChoiceFragment`). The two differ +only in whether `Nonempty` sits outside or inside `∀ p`, and since each `Decidable p` has at most one +element, moving it outward is an instance of unique choice. That unique choice carries excluded middle +from `Prop` to data is standard in type theory: the Rocq standard library's +`theories/Logic/ChoiceFacts.v` proves `constructive_definite_descr_excluded_middle` and states that +"constructive definite description transports excluded-middle from [Prop] to [Set]", crediting the +idea of its proof to L. Chicli, L. Pottier and C. Simpson, "Mathematical Quotients and Quotient Types +in Coq", TYPES 2002, LNCS 2646. Read in the authors' preprint (preprint page numbers): § 5, pp. 12-13, +shows the axiom of unique choice with values in `Prop` contradicts excluded middle in `Prop` in Coq, +completing the proof with the § 4.2 argument, pp. 10-11; their § 6, p. 13, says the impredicativity +of `Set` is essential to it. Following the Rocq file, the credit is for that proof idea, not for the +transport result. In a topos a decided proposition determines an element of 1 + 1 (this form not +located in a source as of 2026-11-01; searched in topos-theory notes and theses held locally and on +the open web, while the theorem-search and Lean-library queries targeted unique choice, not this +form), while Ω itself is 1 + 1 only when the topos is Boolean +(`ZeroParadox/Category/ChoiceCannotBe.md`, § "The headline fence"). A failed elaboration measures one +construction, and neither pole of the converse, `ExcludedMiddle → ChoiceFragment`, is established here +for Lean without `Classical.choice` and without a unique-choice hypothesis: no derivation is given, and +no proof that none exists. **So Lean's stratification is a candidate +explanation of the one-way-ness observed below, not a finding — and not, as first written, a +restatement of Diaconescu.** **No new axioms.** The choice principle in § II is a `def ... : Prop` hypothesis, discharged by the caller. Nothing here is declared `axiom`, and nothing here uses `sorry`. diff --git a/ZeroParadox/Category/GlobalZero.lean b/ZeroParadox/Category/GlobalZero.lean index 5ee08934..d65e69fc 100644 --- a/ZeroParadox/Category/GlobalZero.lean +++ b/ZeroParadox/Category/GlobalZero.lean @@ -13,10 +13,10 @@ set_option maxHeartbeats 400000 terminal (`TopCat.isTerminalPUnit`), the Hilbert and Info components are initial (`fD_zero_isInitial`, `fC_zero_isInitial`). The formal content is a tuple definition plus a conjunction of prior witnesses. -**Reaching for (intent, NOT proved here).** This was *meant to be* the "Global Zero as a section of the -Grothendieck fibration over the domains" — with the discrete index collapsing the fibration to a plain -tuple, and the mixed character (terminal in one fiber, initial in two) read as the "trenchcoat" floor of -the construction (one object, no uniform universal property). +**Reaching for (intent, NOT proved here).** A "Global Zero as a section of the Grothendieck +fibration over the domains", the discrete index collapsing it to a tuple, its mixed character (Top: +terminal; Hilbert: a zero object, `Statement:` COINCIDENCE, `hilbert_bottom_isZero`; Info: initial, +not terminal, `kleisli_bottom_not_terminal`) read as the "trenchcoat" floor: no uniform universal property. **Gap (as far as this reaches).** There is no Grothendieck construction, no fibration, and no section in the Lean — only a 3-field structure. Calling `GlobalZero` "a section of the fibration / the discrete-index diff --git a/ZeroParadox/Category/IgnoranceSeam.lean b/ZeroParadox/Category/IgnoranceSeam.lean index d6c78363..ff109444 100644 --- a/ZeroParadox/Category/IgnoranceSeam.lean +++ b/ZeroParadox/Category/IgnoranceSeam.lean @@ -1,6 +1,8 @@ import ZeroParadox.Category.LawvereTwoAdic +import ZeroParadox.Die import Mathlib.Dynamics.FixedPoints.Basic import Mathlib.Data.Int.Bitwise +import Mathlib.NumberTheory.Padics.RingHoms set_option maxHeartbeats 400000 @@ -143,7 +145,10 @@ def streamVal : List Bool → ℕ /-- `Statement:` the lowest `n` binary digits of an integer, least-significant first. -/ def streamBits : ℕ → ℤ → List Bool | 0, _ => [] - | n + 1, m => (m % 2 == 1) :: streamBits n (m / 2) + | n + 1, m => decide (m % 2 = 1) :: streamBits n (m / 2) + +-- Statement: the digit test is `m % 2 == 1`, definitionally. +example (n : ℕ) (m : ℤ) : streamBits (n + 1) m = (m % 2 == 1) :: streamBits n (m / 2) := rfl /-- `Statement:` `streamBits n m` has length `n`. -/ theorem streamBits_length (n : ℕ) (m : ℤ) : (streamBits n m).length = n := by @@ -201,7 +206,7 @@ theorem eq_streamVal_streamBits_add (n : ℕ) (m : ℤ) : obtain ⟨t, ht⟩ := ih (m / 2) refine ⟨t, ?_⟩ have hm := Int.emod_add_mul_ediv m 2 - have hb : (((m % 2 == 1).toNat : ℕ) : ℤ) = m % 2 := by + have hb : (((decide (m % 2 = 1)).toNat : ℕ) : ℤ) = m % 2 := by rcases Int.emod_two_eq_zero_or_one m with h | h <;> simp [h] simp only [streamBits, streamVal, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, hb] linear_combination hm.symm + 2 * ht @@ -425,8 +430,8 @@ example : ¬ ∃ inst : ZPSemilattice (List Bool), rcases hj : inst.join [false] [true] with _ | ⟨b, t⟩ · rw [hj] at h1; simp at h1 · rw [hj] at h1 h2 - simp [List.cons_prefix_cons] at h1 h2 - exact Bool.noConfusion (h1.symm.trans h2) + rw [List.cons_prefix_cons] at h1 h2 + exact Bool.noConfusion (h1.1.trans h2.1.symm) /-- `Statement:` committing one digit is a cover of the empty stream in the prefix order: strictly above it, with nothing strictly between. -/ @@ -437,7 +442,7 @@ theorem first_digit_covers (d : Bool) : rcases u with _ | ⟨b, t⟩ · exact Or.inl rfl · obtain ⟨s, hs⟩ := h - simp at hs + simp only [List.cons_append, List.cons.injEq, List.append_eq_nil_iff] at hs obtain ⟨rfl, rfl, -⟩ := hs exact Or.inr rfl @@ -623,6 +628,172 @@ example (n : ℕ) : (List.replicate n false).dropLast = (List.replicate n false) -- Reading: local ignorance and local knowledge at `w` are one `w`, least in its up-set and greatest -- in its prefix set; `partialDouble`'s climb from `[]` run backwards is `List.tail`. +/-! ## § VIII. The bend on 2-adic digit tapes is the 2-adic valuation +`Reading:` a standard fact, the lowest nonzero 2-adic digit of `x ≠ 0` sits at its valuation, assembled +from Mathlib's `PadicInt.appr` and `PadicInt.valuation` and read through the bend `NInf.det` and its +section `NInf.negS` (`ZeroParadox/Die.lean` § XXV). -/ + +namespace NInf + +/-- `Statement:` `ofNat n ≤ det r` iff `r` is `false` below `n`. -/ +theorem ofNat_le_det_iff (r : ℕ → Bool) (n : ℕ) : ofNat n ≤ det r ↔ ∀ k < n, r k = false := by + show (∀ i, decide (i < n) = true → detSeq r i = true) ↔ _ + simp only [decide_eq_true_eq, detSeq_eq_true_iff] + constructor + · intro h k hk; exact h k hk k le_rfl + · intro h i hi k hk; exact h k (by omega) + +/-- `Statement:` bit `i` of `y : NInf` is `true` iff `ofNat (i + 1) ≤ y`. -/ +theorem apply_true_iff_ofNat_succ_le (y : NInf) (i : ℕ) : y.1 i = true ↔ ofNat (i + 1) ≤ y := by + constructor + · intro h j hj + simp only [ofNat, decide_eq_true_eq] at hj + exact true_le y h j (by omega) + · intro h; exact h i (decide_eq_true (Nat.lt_succ_self i)) + +end NInf + +section PadicTape +open NInf + +/-- `Statement:` the 2-adic digit tape: digit `k` of `x` is `true` iff `x.appr k ≠ x.appr (k + 1)`. -/ +noncomputable def padicTape (x : ℤ_[2]) : ℕ → Bool := fun k => decide (x.appr k ≠ x.appr (k + 1)) + +/-- `Statement:` `x.appr n = 0` iff `2 ^ n ∣ x`. -/ +theorem appr_two_eq_zero_iff (x : ℤ_[2]) (n : ℕ) : x.appr n = 0 ↔ (2 : ℤ_[2]) ^ n ∣ x := by + have hs := PadicInt.appr_spec n x + rw [Ideal.mem_span_singleton] at hs + constructor + · intro h; rw [h] at hs; simpa using hs + · intro h + have h1 : (2 : ℤ_[2]) ^ n ∣ ((x.appr n : ℕ) : ℤ_[2]) := by + have := dvd_sub h hs; simpa using this + have h2 : (2 : ℤ_[2]) ^ n ∣ (((x.appr n : ℕ) : ℤ) : ℤ_[2]) := by simpa using h1 + have h3 := (PadicInt.pow_p_dvd_int_iff (p := 2) n ((x.appr n : ℕ) : ℤ)).1 (by exact_mod_cast h2) + have h4 : 2 ^ n ∣ x.appr n := by exact_mod_cast h3 + exact Nat.eq_zero_of_dvd_of_lt h4 (PadicInt.appr_lt x n) + +/-- `Statement:` the digits of `x` below `n` are all `false` iff `x.appr n = 0`. -/ +theorem padicTape_low_false_iff (x : ℤ_[2]) : ∀ n, (∀ k < n, padicTape x k = false) ↔ x.appr n = 0 + | 0 => by simp [PadicInt.appr] + | n + 1 => by + have ih := padicTape_low_false_iff x n + constructor + · intro h + have h0 : x.appr n = 0 := ih.1 fun k hk => h k (by omega) + have hb := h n (by omega) + simp only [padicTape, decide_eq_false_iff_not, not_not] at hb + omega + · intro h k hk + have hn : x.appr n = 0 := + Nat.eq_zero_of_le_zero (h ▸ PadicInt.appr_mono x (Nat.le_succ n)) + rcases Nat.lt_succ_iff_lt_or_eq.1 hk with hk | rfl + · exact ih.2 hn k hk + · simp [padicTape, hn, h] + +/-- `Statement:` `ofNat n ≤ det (padicTape x)` iff `2 ^ n ∣ x`. -/ +theorem ofNat_le_det_padicTape (x : ℤ_[2]) (n : ℕ) : + ofNat n ≤ det (padicTape x) ↔ (2 : ℤ_[2]) ^ n ∣ x := by + rw [ofNat_le_det_iff, padicTape_low_false_iff, appr_two_eq_zero_iff] + +/-- `Statement:` `2 ^ n ∣ x` for every `n` iff `x = 0`. -/ +theorem two_pow_dvd_forall_iff (x : ℤ_[2]) : (∀ n, (2 : ℤ_[2]) ^ n ∣ x) ↔ x = 0 := by + constructor + · intro h + by_contra hx + have := (PadicInt.mem_span_pow_iff_le_valuation x hx (x.valuation + 1)).1 + (Ideal.mem_span_singleton.2 (by exact_mod_cast h (x.valuation + 1))) + omega + · rintro rfl n; exact dvd_zero _ + +/-- `Statement:` `det (padicTape x)` is ⊤ of `NInf` (`infty`) iff `x` is 2-adic `0`. -/ +theorem det_padicTape_eq_infty_iff (x : ℤ_[2]) : det (padicTape x) = infty ↔ x = 0 := by + rw [det_eq_infty_iff, ← two_pow_dvd_forall_iff] + constructor + · intro h n; rw [← ofNat_le_det_padicTape, ofNat_le_det_iff]; exact fun k _ => h k + · intro h k + exact (ofNat_le_det_iff _ (k + 1)).1 ((ofNat_le_det_padicTape x (k + 1)).2 (h _)) k (by omega) + +-- Statement: so the all-false tape, ⊥ of `ℕ → Bool`, is the digit tape of 2-adic `0` and of no other `x`. +example (x : ℤ_[2]) : padicTape x = ⊥ ↔ x = 0 := by + rw [← det_padicTape_eq_infty_iff, det_eq_infty_iff, funext_iff]; rfl + +/-- `Statement:` for `x ≠ 0`, `det (padicTape x) = ofNat x.valuation`. -/ +theorem det_padicTape_eq_ofNat_valuation (x : ℤ_[2]) (hx : x ≠ 0) : + det (padicTape x) = ofNat x.valuation := by + apply ext; intro i + have key : ((det (padicTape x)).1 i = true) ↔ ((ofNat x.valuation).1 i = true) := by + rw [apply_true_iff_ofNat_succ_le, apply_true_iff_ofNat_succ_le, ofNat_le_det_padicTape, + ofNat_le_iff, ← PadicInt.mem_span_pow_iff_le_valuation x hx, Ideal.mem_span_singleton] + norm_num + cases h1 : (det (padicTape x)).1 i <;> cases h2 : (ofNat x.valuation).1 i <;> simp_all + +/-- `Statement:` `x.appr n` is the unique natural below `2 ^ n` congruent to `x` modulo `2 ^ n`. -/ +theorem appr_two_eq_of (x : ℤ_[2]) (n m : ℕ) (hm : m < 2 ^ n) + (h : (2 : ℤ_[2]) ^ n ∣ x - (m : ℤ_[2])) : x.appr n = m := by + have hs := Ideal.mem_span_singleton.1 (PadicInt.appr_spec n x) + have hd : (2 : ℤ_[2]) ^ n ∣ (((m : ℤ) - (x.appr n : ℤ) : ℤ) : ℤ_[2]) := by + have := dvd_sub hs h + push_cast + convert this using 1; ring + have hz := (PadicInt.pow_p_dvd_int_iff (p := 2) n _).1 (by exact_mod_cast hd) + rw [Int.subNatNat_eq_coe] at hz + have ha := PadicInt.appr_lt x n + have hm' : (m : ℤ) < ((2 : ℕ) : ℤ) ^ n := by exact_mod_cast hm + have ha' : (x.appr n : ℤ) < ((2 : ℕ) : ℤ) ^ n := by exact_mod_cast ha + have : (m : ℤ) - (x.appr n : ℤ) = 0 := by + apply Int.eq_zero_of_abs_lt_dvd hz + rw [abs_lt]; constructor <;> omega + omega + +/-- `Statement:` the approximations of `-2 ^ n` are `0` for `k ≤ n` and `2 ^ k - 2 ^ n` after. -/ +theorem appr_neg_two_pow (n k : ℕ) : + (-(2 : ℤ_[2]) ^ n).appr k = if k ≤ n then 0 else 2 ^ k - 2 ^ n := by + split_ifs with hk + · apply appr_two_eq_of _ _ _ (by positivity) + simp only [Nat.cast_zero, sub_zero, dvd_neg] + exact pow_dvd_pow 2 hk + · have hlt : 2 ^ n < 2 ^ k := Nat.pow_lt_pow_right (by norm_num) (by omega) + have hpos : 0 < 2 ^ n := by positivity + apply appr_two_eq_of _ _ _ (by omega) + rw [Nat.cast_sub hlt.le]; push_cast + exact ⟨-1, by ring⟩ + +/-- `Statement:` the section `negS` of the bend sends `ofNat n` to the digit tape of `-2 ^ n`. -/ +theorem padicTape_neg_two_pow (n : ℕ) : padicTape (-(2 : ℤ_[2]) ^ n) = negS (ofNat n) := by + funext k + simp only [padicTape, negS, ofNat, appr_neg_two_pow] + by_cases hkn : k < n + · have : k ≤ n := hkn.le + have : k + 1 ≤ n := hkn + simp [*] + · have hk1 : ¬ (k + 1 ≤ n) := by omega + have hp : 2 ^ n < 2 ^ (k + 1) := Nat.pow_lt_pow_right (by norm_num) (by omega) + have hpk : 2 ^ k + 2 ^ k = 2 ^ (k + 1) := by rw [pow_succ]; ring + by_cases hkeq : k = n + · subst hkeq + have hne : (0 : ℕ) ≠ 2 ^ (k + 1) - 2 ^ k := by omega + simp [hne] + · have hk : ¬ k ≤ n := by omega + have hpn : 2 ^ n < 2 ^ k := Nat.pow_lt_pow_right (by norm_num) (by omega) + have hne : 2 ^ k - 2 ^ n ≠ 2 ^ (k + 1) - 2 ^ n := by + rw [← hpk]; generalize 2 ^ k = A at hpn ⊢; generalize 2 ^ n = B at hpn ⊢; omega + simp [hk, hk1, hkn, hne] + +/-- `Statement:` `negS` sends ⊤ of `NInf` (`infty`) to the digit tape of 2-adic `0`. -/ +theorem padicTape_zero : padicTape (0 : ℤ_[2]) = negS infty := by + funext k + have h : ∀ j, (0 : ℤ_[2]).appr j = 0 := fun j => + appr_two_eq_of _ _ _ (by positivity) (by simp) + simp [padicTape, negS, infty, h] + +-- Statement: axioms, every `padicTape` result above `[propext, Classical.choice, Quot.sound]`, as are +-- Mathlib's `PadicInt.appr` and `PadicInt.valuation` (PurityCheck); `NInf.det` carries no `Classical.choice`. +-- Reading: one more chart in which 2-adic `0` reads as infinity; it is not the coincidence witness +-- of the pole, `infinitude_forces_infinite_complexity`. + +end PadicTape + end ZeroParadox /-! ## Axiom Purity Check -/ @@ -666,4 +837,19 @@ open ZeroParadox #print axioms dropLast_iterate_eq_nil #print axioms double_never_forgets #print axioms addOne_forgets_iff +#print axioms NInf.ofNat_le_det_iff +#print axioms NInf.apply_true_iff_ofNat_succ_le +#print axioms padicTape +#print axioms appr_two_eq_zero_iff +#print axioms padicTape_low_false_iff +#print axioms ofNat_le_det_padicTape +#print axioms two_pow_dvd_forall_iff +#print axioms det_padicTape_eq_infty_iff +#print axioms det_padicTape_eq_ofNat_valuation +#print axioms appr_two_eq_of +#print axioms appr_neg_two_pow +#print axioms padicTape_neg_two_pow +#print axioms padicTape_zero +#print axioms PadicInt.appr +#print axioms PadicInt.valuation end PurityCheck diff --git a/ZeroParadox/Category/Lawvere.lean b/ZeroParadox/Category/Lawvere.lean index 0146c1eb..9945924a 100644 --- a/ZeroParadox/Category/Lawvere.lean +++ b/ZeroParadox/Category/Lawvere.lean @@ -40,7 +40,7 @@ set_option maxHeartbeats 400000 /-- An endofunction `g : β → β` "has a Lawvere witness" when the diagonal hypothesis of Lawvere's theorem holds: a point-surjection `α → (α → β)`. This is exactly the hypothesis Cantor's theorem shows is *impossible* for `β` with a fixed-point-free endomap. -/ --- [ZP-CUSTOM] no Mathlib named predicate | reason: Mathlib proves Lawvere's theorem (Function.exists_fixed_point_of_surjective) but exposes no reusable predicate for the diagonal hypothesis (β admits a point-surjection α → (α → β)). Naming it lets the face-split state, per face, whether the hypothesis holds (Set faces refuted by Cantor; computability face genuine). Naming alias (cf. IsComputationalQuine); every theorem reduces to the Mathlib lemma, no new axiomatic content. +-- [ZP-CUSTOM] no Mathlib named predicate | reason: Mathlib proves Lawvere's theorem (Function.exists_fixed_point_of_surjective) but exposes no reusable predicate for the diagonal hypothesis (β admits a point-surjection α → (α → β)). Naming it lets the face-split state, per face, whether the hypothesis holds (Set faces refuted by Cantor; computability face genuine up to eval, its Lawvere form cited: Bauer 2017, multi-valued). Naming alias (cf. IsComputationalQuine); every theorem reduces to the Mathlib lemma, no new axiomatic content. def HasLawvereWitness (β : Type*) : Prop := ∃ (α : Type*) (f : α → α → β), Function.Surjective f @@ -113,13 +113,24 @@ theorem q2_no_witness : ¬ HasLawvereWitness ℚ_[2] := "endomap" means *computable*, and `Nat.Partrec.Code.fixed_point` gives every such map a fixed point **up to `eval`**. ⚠ The qualifier is load-bearing: the literal claim is FALSE here too, since - `fun c => Code.pair c c` is total, computable, and returns its own input for no `c`. The escape + `fun c => Code.pair c c` is total, computable, and returns its own input for no `c` + (`code_pair_diag_fixedPointFree`, below). The escape restricts which MORPHISMS exist, not which codomain `eval` lands in (`no_computable_evalFixedPointFree`). Argument: `ZeroParadox/Category/Lawvere.md`. -/ -/-- `Statement:` a fixed point **up to `eval`**, not a literal one (Rogers / Kleene). - ⚠ `fun c => Code.pair c c` is a total computable endomap fixing no `c`; the escape is fewer - MORPHISMS, not a different codomain (`no_computable_evalFixedPointFree`, § V). -/ +/-- `Statement:` the diagonal pairing `fun c => Code.pair c c` is computable, and fixes no code + (`Code.pair c c` is strictly larger than `c` in `sizeOf`; in Gödel numbers the same gap is + Mathlib's `Nat.Partrec.Code.encode_lt_pair`). The named witness that a literal + fixed point fails in the effective category; cited by name from the sites that state it. -/ +theorem code_pair_diag_fixedPointFree : + Computable (fun c : Nat.Partrec.Code => Nat.Partrec.Code.pair c c) ∧ + ∀ c : Nat.Partrec.Code, Nat.Partrec.Code.pair c c ≠ c := + ⟨(Nat.Partrec.Code.primrec₂_pair.comp Primrec.id Primrec.id).to_comp, + fun c h => by have := congrArg sizeOf h; simp at this⟩ + +/-- `Statement:` a fixed point **up to `eval`**, not a literal one (Rogers / Kleene); no literal + one in general (`code_pair_diag_fixedPointFree`). The escape is fewer MORPHISMS, not another + codomain (`no_computable_evalFixedPointFree`, `ZeroParadox/Category/DiagonalWitness.lean`). -/ theorem computability_face_fixedPoint {f : Nat.Partrec.Code → Nat.Partrec.Code} (hf : Computable f) : ∃ c, Nat.Partrec.Code.eval (f c) = Nat.Partrec.Code.eval c := Nat.Partrec.Code.fixed_point hf @@ -142,5 +153,6 @@ open ZeroParadox #print axioms no_witness_of_nontrivial #print axioms nontrivial_lattice_no_witness #print axioms q2_no_witness +#print axioms code_pair_diag_fixedPointFree #print axioms computability_face_fixedPoint end PurityCheck diff --git a/ZeroParadox/Category/Lawvere.md b/ZeroParadox/Category/Lawvere.md index 5324c19c..715681cf 100644 --- a/ZeroParadox/Category/Lawvere.md +++ b/ZeroParadox/Category/Lawvere.md @@ -8,17 +8,18 @@ the declarations, the Engineer's Take and the per-declaration glosses. | Face | self-map | In **Set** (all endos) | Status | |---|---|---|---| | lattice / abstract (`selfApp`) | `selfApp` | NO witness — posited | `nontrivial_lattice_no_witness` ✓ | -| set theory (Quine atom) | `x ↦ {x}` | (= lattice; metatheoretic literal) | via the lattice ✓ | +| set theory (Quine atom) | `x ↦ {x}` | NO witness: `ZFSet` is nontrivial (∅ ≠ {∅}) | `no_witness_of_nontrivial` ✓ | | 2-adic (`×2` in ℚ₂) | `x ↦ 2x` | NO witness — posited | `q2_no_witness` ✓ | -| computability (Kleene quine) | computable endo | **NO witness — same as the others** | `computability_face_fixedPoint` ✓ (genuine, in the effective category) | +| computability (Kleene quine) | computable endo | **NO witness — same as the others** | `computability_face_fixedPoint` ✓ (genuine, in the effective category, up to `eval`; its Lawvere form cited: Bauer 2017, multi-valued) | ⚠ **ALL FOUR FACES FAIL THE SET TEST IDENTICALLY**, and the computability row is not special in that column. `Code` is a nontrivial total type, so `no_witness_of_nontrivial` forbids the witness there exactly as for the lattice and the 2-adics — checkable in one line: ```lean -example : ¬ HasLawvereWitness Nat.Partrec.Code := - no_witness_of_nontrivial (b₀ := Code.zero) (b₁ := Code.succ) (by simp) +example : ¬ ZeroParadox.HasLawvereWitness Nat.Partrec.Code := + ZeroParadox.no_witness_of_nontrivial (b₀ := Nat.Partrec.Code.zero) (b₁ := Nat.Partrec.Code.succ) + (by simp) ``` What distinguishes the computability row is not its Set verdict but the **second category** it also @@ -28,33 +29,41 @@ lives in. The test is **category-relative**. In **Set** — raw types, all endofunctions — **no** face is a Lawvere fixed point: Cantor forbids the witness for every nontrivial total type (lattice and 2-adic -proven; set theory is the lattice case, its literal ⊥ = {⊥} metatheoretic). +proven; for set theory `no_witness_of_nontrivial` applies to `ZFSet` directly, since ∅ ≠ {∅} (the +`example : ¬ HasLawvereWitness ZFSet` in `ZeroParadox/Settheory/QuineDichotomy.lean`); no +equation between a lattice element and a set is stated; the charts are compared through the die's +Quine-atom role, occupied or not chart by chart, +`ZeroParadox/Settheory/QuineDichotomy.lean`). The computability face is a **genuine** Lawvere/recursion fixed point in the **effective** category, -where the fixed-point-free **diagonal** `fun x => g (e x x)` is not ADMISSIBLE. +up to `eval`, where the fixed-point-free **diagonal** `fun x => g (e x x)` is not ADMISSIBLE. The +recursion fixed point is checked (`computability_face_fixedPoint`); its Lawvere form is cited, in a +multi-valued form (Bauer 2017, Theorem 5.2 and Corollary 5.3), not checked in Lean. ⚠ **That is NOT the claim that no fixed-point-free computable endomap exists.** One does: -`fun c => Code.pair c c` is total, computable, and returns its own input for no `c`. What fails is the -diagonal CONSTRUCTION, not the existence of fixed-point-free maps — and per +`fun c => Code.pair c c` is total, computable, and returns its own input for no `c` +(`code_pair_diag_fixedPointFree`). What fails, up to `eval`, is the diagonal CONSTRUCTION, not the +existence of fixed-point-free maps; under literal equality that same map refutes the witness (the +`example` after `no_witnessRel_of_admissible_fpf` in `ZeroParadox/Category/DiagonalWitness.lean`). Per `ZeroParadox/Category/DiagonalWitness.md`, removing the obstruction **does not by itself supply the witness**; the implication runs one way, and the fixed point on that side is Rogers' theorem, cited rather than derived. ### What the escape IS, and what it is not -The Set refutation of § IV runs a **diagonal built from a fixed-point-free map**. Effectively there is -no such map: `no_computable_evalFixedPointFree` (`ZeroParadox/Category/DiagonalWitness.lean`) shows no -computable self-map on codes is eval-fixed-point-free, so the diagonal has **no computable -representative**. It is not admissible here, and the obstruction cannot fire. **The restriction is on -MORPHISMS.** +The Set refutation of § IV runs a **diagonal built from a fixed-point-free map**. Up to `eval` there +is no such computable map: `no_computable_evalFixedPointFree` (`ZeroParadox/Category/DiagonalWitness.lean`) +shows no computable self-map on codes is eval-fixed-point-free, so up to `eval` the diagonal has **no +computable representative**, is not admissible, and the obstruction cannot fire. Under literal +equality it fires (`fun c => Code.pair c c`, above). **The restriction is on MORPHISMS.** ⚠⚠ **NOT on codomains, and this file said otherwise until it was refuted by elaboration.** The claim was that `eval` lands in `ℕ →. ℕ` rather than `Code → Code`, "so the Set refutation never applied". One line kills it: ```lean -example : ¬ HasLawvereWitness (ℕ →. ℕ) := - no_witness_of_nontrivial (b₀ := fun _ => Part.some 0) (b₁ := fun _ => Part.none) +example : ¬ ZeroParadox.HasLawvereWitness (ℕ →. ℕ) := + ZeroParadox.no_witness_of_nontrivial (b₀ := fun _ => Part.some 0) (b₁ := fun _ => Part.none) (by intro h; have := congrFun h 0; exact Part.some_ne_none 0 this) ``` @@ -71,7 +80,8 @@ in the up-to-`eval` form (φ_{h(n₀)} = φ_{n₀}) — the source itself carrie The keystone unifies a **shape** — the diagonal — not a single mechanism. The total faces carry a *posited* fixed point sharing the diagonal shape; the computability face carries one *genuinely -produced* by the diagonal, in its own category. +produced* by the diagonal, in its own category, up to `eval` (its Lawvere form cited: Bauer 2017, +multi-valued). The cross-face identification is a shared **shape**, confirmed precise. It is: diff --git a/ZeroParadox/Category/LawvereTaboo.md b/ZeroParadox/Category/LawvereTaboo.md index f9f5e545..1037bda9 100644 --- a/ZeroParadox/Category/LawvereTaboo.md +++ b/ZeroParadox/Category/LawvereTaboo.md @@ -44,15 +44,16 @@ keystone (the diagonal engine) rather than on an imported order instance. * **Not full excluded middle.** The taboo landed on is weak excluded middle, which is strictly weaker than `ExcludedMiddle` in intuitionistic logic. No attempt was made here to strengthen it, and the reader should not assume it can be strengthened. -* **The converse is not machine-checked here; in Lean it is left open.** Its scope is univalent - foundations, the setting of de Jong–Escardó, arXiv:2601.12536: there weak excluded middle gives the +* **The converse is not machine-checked here; in Lean it is left open.** It is proved in univalent + foundations, the setting of de Jong–Escardó, arXiv:2601.12536v2: there weak excluded middle gives the general statement back, in two steps. The first step is published, Prop 6.4, p. 24, *"If weak excluded middle holds and the type X has two distinct points, then X has a decomposition"*, proved by sending `x` to 0 if `¬(x ≠ x₀)` and to 1 if `¬¬(x ≠ x₀)`. The second step, decomposition to - fixed-point-free endomap, is the elementary derivation in the prior-art section below, and is ours. + fixed-point-free endomap, is the elementary derivation in the prior-art section below, where the + search for a source stating the fixed-point-free form is recorded (none located as of 2026-10-07). The first step is a case split: under weak excluded middle the two mutually exclusive subobjects `¬(x = b₀)` and `¬¬(x = b₀)` cover, so a map can be glued from them (Prop 6.4's two cases are - these two, swapped, by triple negation). An earlier instance of the same case split is Simpson's + these two, swapped, by triple negation). An earlier instance of the same form of case split is Simpson's proof of Thm 5 of Booij–Escardó–Lumsdaine–Shulman (arXiv:1701.05617), p. 5, in its direction from weak excluded middle to a map: *"define f : U → 2 by f(A) = ff if ¬A and f(A) = tt if ¬¬A"*. Its other direction, from the map to weak excluded middle via *"Z = ¬A × X + ¬¬A × Y"* (p. 6), runs @@ -78,13 +79,16 @@ The mathematics of this genre is not new and is not claimed as new. Lumsdaine–Shulman Thm 3 and Thm 5 (below) are as close, and so is de Jong–Escardó (below) in both directions. De Jong–Escardó Prop 6.4, p. 24, runs from weak excluded middle to a decomposition, opposite to `wem_of_fixedPointFree`; their Lemma 6.6, Lemma 6.7 and Thm 6.10, p. 24, run the same way as - `wem_of_fixedPointFree`, deriving weak excluded middle from a decomposition of the type of - propositions `Ω_U`, of a type with `Ω`-paths, or of an injective type. + `wem_of_fixedPointFree`, each with its universe levels: Lemma 6.6, a decomposition of the type + `Ω_U` of propositions in a universe `U` gives weak excluded middle in `U`; Lemma 6.7, a type + `X : U` with a decomposition and `Ω_V`-paths gives weak excluded middle in the universe `V`; + Thm 6.10, a type `D : U` injective with respect to the universes `V` and `W` gives, from any + decomposition, weak excluded middle in `V`. Decomposability is strictly stronger than what is used in `wem_of_fixedPointFree`: a decomposition `f : X → 𝟚` with witnesses `x₀ x₁` yields the fixed-point-free endomap `x ↦ if f x = 0 then x₁ else x₀` (it changes the value of `f`, so it cannot fix anything). So a fixed-point-free endomap is the *weaker* conclusion, which makes the implication to weak excluded - middle formally the stronger one. That derivation is elementary and is ours, not Escardó's. No + middle formally the stronger one. That derivation is elementary. No source stating the fixed-point-free form was located as of 2026-10-07, searched by phrase in theoremsearch and on the open web and among the sources listed here. * **A. B. Booij, M. Escardó, P. LeFanu Lumsdaine and M. Shulman, "Parametricity, automorphisms of the @@ -92,7 +96,8 @@ The mathematics of this genre is not new and is not claimed as new. (Simpson), p. 5: the statements and the contrast with `wem_of_fixedPointFree` are in the comment above that theorem in `LawvereTaboo.lean`, which also credits Simpson's proof technique. * **T. de Jong and M. Escardó, "Examples and counterexamples of injective types"** - (arXiv:2601.12536, 18 January 2026). Read in full from the held copy; Prop 6.4, p. 24, is quoted + (arXiv:2601.12536v2, 4 September 2026; page numbers are those of v2, the version read). Read in + full from the held copy; Prop 6.4, p. 24, is quoted under "What is NOT claimed" above. From the abstract verbatim (cited, not claimed): *"any type with an apartness relation and two points apart cannot be injective unless weak excluded middle holds"*, and *"injective types have no non-trivial decidable properties, unless weak excluded middle holds, diff --git a/ZeroParadox/Category/LawvereTwoAdic.lean b/ZeroParadox/Category/LawvereTwoAdic.lean index 98cd7980..82dec1c7 100644 --- a/ZeroParadox/Category/LawvereTwoAdic.lean +++ b/ZeroParadox/Category/LawvereTwoAdic.lean @@ -67,8 +67,9 @@ instance of these; the doubling stages have no upper bound under `<+:` (§ II's -- ω-Scott-continuous, `gfp f = ⨅ n, f^[n] ⊤`. #check @fixedPoints.gfp_eq_sInf_iterate --- Reading: the Take's dead zero is the all-zeros tape, in either carrier. Here it is --- `botEnd : End = ℕ → Fin 2`. +-- Reading: the Take's dead zero is the all-zeros tape, in either carrier (`End = ℕ → Fin 2` here, and the +-- all-false tape `ℕ → Bool` of `ZeroParadox/Category/IgnoranceSeam.lean`). Here it is +-- `botEnd : End = ℕ → Fin 2`. `End` and `botEnd` are defined in `ZeroParadox/Valuation/PadicTree.lean`. -- Statement: COINCIDENCE — `botEnd` is ⊥ of `End` under pointwise max and the fixed point of boundary -- doubling (`boundaryDouble_botEnd`, `boundaryDouble_unique_fp`, -- `ZeroParadox/Valuation/PoleCompletion.lean`). The all-false tape ℕ → Bool carries the same diff --git a/ZeroParadox/Category/NextTimeCategorical.lean b/ZeroParadox/Category/NextTimeCategorical.lean index b374f933..258086a5 100644 --- a/ZeroParadox/Category/NextTimeCategorical.lean +++ b/ZeroParadox/Category/NextTimeCategorical.lean @@ -137,12 +137,12 @@ theorem mem_range_pfunctor_map {P : PFunctor.{u, u}} {A : Type u} (i : A → X) obtain ⟨a, g⟩ := z constructor · rintro ⟨⟨a', h⟩, heq⟩ b - rw [PFunctor.map_eq] at heq + change (⟨a', i ∘ h⟩ : P.Obj X) = ⟨a, g⟩ at heq cases heq exact ⟨h b, rfl⟩ · intro hg refine ⟨⟨a, fun b => (hg b).choose⟩, ?_⟩ - rw [PFunctor.map_eq] + show (⟨a, i ∘ fun b => (hg b).choose⟩ : P.Obj X) = ⟨a, g⟩ congr 1 funext b exact (hg b).choose_spec diff --git a/ZeroParadox/Category/NextTimeCategorical.md b/ZeroParadox/Category/NextTimeCategorical.md index f94aee21..3dedf04d 100644 --- a/ZeroParadox/Category/NextTimeCategorical.md +++ b/ZeroParadox/Category/NextTimeCategorical.md @@ -11,7 +11,8 @@ version and proves the two agree, so the concrete predicate is no longer merely ## Prior art — locators, not quotations -Source: `.claude-local/papers/adamek_milius_moss_wellfounded_recursive_coalgebras.pdf`. +Source: Adámek, Milius, Moss, *On Well-Founded and Recursive Coalgebras*, arXiv:1910.09401v2 +(16 Feb 2020). | AMM | what is there | built as | |---|---|---| @@ -25,7 +26,7 @@ next-time operator itself they credit to **Jacobs** `[17]`; and Def 4.3 they giv Taylor [28, Exercise VI.17]"*. ⚠ **`[28]` is Taylor's *Practical Foundations of Mathematics* (CUP 1999), which this project does NOT -hold** — the Taylor PDF in `.claude-local/papers/` is his *Well founded coalgebras and recursion*, a +hold** — the Taylor document on coalgebras this project holds is his *Well founded coalgebras and recursion*, a different document with no Exercise VI.17. The same caveat is stated at `ZeroParadox/Category/WellFoundedCoalgebra.lean`'s overview. @@ -65,8 +66,8 @@ CategoryTheory.MonoOver [propext, Classical.choice, Quot.sound] <- t Subobject.mk / .arrow / .pullback / .lower all the same ``` -`#print axioms` follows the **statement**, so **every result mentioning `Subobject` is choice-carrying -no matter how it is proved.** Per `CLAUDE.md` § *Revalidate, don't redraft*: a type carrying an axiom +`#print axioms` follows the statement and the proof; here the **statement** alone settles it, so +**every result mentioning `Subobject` is choice-carrying no matter how it is proved.** Per `CLAUDE.md` § *Revalidate, don't redraft*: a type carrying an axiom makes "removable" false for every possible proof. This is a fact about Mathlib's subobject machinery, not about anything here. diff --git a/ZeroParadox/Category/Node4Generation.md b/ZeroParadox/Category/Node4Generation.md index 7d5e1296..f9e71015 100644 --- a/ZeroParadox/Category/Node4Generation.md +++ b/ZeroParadox/Category/Node4Generation.md @@ -10,9 +10,18 @@ algebra = colimit of the initial chain `0 → F0 → F²0 → …`; J. Adámek, realizations in the language of categories*, Comment. Math. Univ. Carolin. 15 (1974), 589–602). Mathlib carries the *order-theoretic* engine (`fixedPoints.lfp_eq_sSup_iterate`) and ZP carries the *ordinal* instance (`epsilonZero_eq_nfp`: -ε₀ = nfp(ω^·)0), but the *categorical* Adámek colimit is not located in Mathlib as of 2026-08-08, -searched along three axes: the proper name; the nouns `initial algebra` / `terminal coalgebra` (both -polarities); and the verb `transfinite`. This file builds the canonical instance for node #4's floor. +ε₀ = nfp(ω^·)0), but the *categorical* Adámek theorem (the initial algebra as the colimit of the initial +chain) was not located in the Mathlib then pinned (`5450b53`) as of 2026-10-31. Searched by grep along three +axes, each of which returns material that is near it and is not it: the proper name `Adámek` (citations +of Adámek–Rosický and Adámek–Rosický–Vitale, as bibliography entries and theorem references, in +`CategoryTheory/Presentable/`, `Generator/StrongGenerator.lean` and `Limits/Sifted.lean`, none of them the +initial-chain colimit); the +nouns `initial algebra` / `terminal coalgebra` (`CategoryTheory/Endofunctor/Algebra.lean`, Lambek's +lemma that the structure map of an initial algebra or terminal coalgebra is an isomorphism, and the +polynomial-functor W- and M-types under `Data/PFunctor/` and `Data/QPF/`, with no colimit +construction); and `transfinite` (`Order/TransfiniteIteration.lean`, the order-theoretic transfinite +iterate of `φ : I → I`; `CategoryTheory/SmallObject/Iteration/`, transfinite iteration of a successor +structure for the small object argument, which states no initial-algebra theorem). This file builds the canonical instance for node #4's floor. **The construction.** Take the endofunctor `F X = X + 1` (whose initial algebra is `ℕ`). Its initial chain is `Fⁿ(∅) = Fin n`, with connecting maps the inclusions `Fin n ↪ Fin (n+1)` (`Fin.castSucc`). The diff --git a/ZeroParadox/Category/RootCutBinary.lean b/ZeroParadox/Category/RootCutBinary.lean index 9c87aa15..48bdb533 100644 --- a/ZeroParadox/Category/RootCutBinary.lean +++ b/ZeroParadox/Category/RootCutBinary.lean @@ -133,7 +133,7 @@ theorem arity_collapse : ZeroParadox.idPF_no_seam, binPF_no_seam⟩ section PurityCheck --- Measured footprint (lake build, v4.30.0-rc2) — the same μ-choice-free / ν-choice split as +-- Measured footprint (lake build, v4.35.0) — the same μ-choice-free / ν-choice split as -- ZeroParadox/Settheory/Coalgebra.lean and ZeroParadox/Category/RootCutDegeneracy.lean: -- binFix_isEmpty (μ empty) : [propext, Quot.sound] — CHOICE-FREE -- binCofix_nonempty (ν inhabited) : [propext, Classical.choice, Quot.sound] — Mathlib M-type diff --git a/ZeroParadox/Category/RootCutDegeneracy.lean b/ZeroParadox/Category/RootCutDegeneracy.lean index 0293bcef..2211cca5 100644 --- a/ZeroParadox/Category/RootCutDegeneracy.lean +++ b/ZeroParadox/Category/RootCutDegeneracy.lean @@ -1,6 +1,7 @@ -- EXPERIMENTAL (branch scaffolding): bottom-diagram probe campaign, not a finalized layer. Curated/load-bearing results are indexed in ZeroParadox/BottomCannotBe.lean and classified in ZeroParadox/MANIFEST.md. import Mathlib.Data.QPF.Univariate.Basic import ZeroParadox.Settheory.Coalgebra +import ZeroParadox.Category.WellFoundedCoalgebra /-! # The root-cut degeneracy dichotomy @@ -45,9 +46,8 @@ because `PEmpty → X` is a singleton. Composing the unfold equivalence with thi `fixEquiv` and `cofixEquiv`, and `root_seam := fixEquiv.trans cofixEquiv.symm`. The strict side is imported verbatim from `ZeroParadox.categorical_fork_strict`. -What is PROVED is exactly the equivalences and the dichotomy bundle below. The identification of this -root seam with the diagonal fixed point / the node-#5 zero-object seam is the cross-instance modeling -commitment of ZP-P, not a theorem. +`Reading:` CARRIER — the seam is the die role `∃! y, SelfOnlyAt y` (`ZeroParadox/Die.lean`), occupied per +chart with no equation across: § The seam role in the die; charts indexed in `ZeroParadox/DieCannotBe.lean`. Of the diagonal fixed point's floor faces (`ZeroParadox/DiagonalFixedPoint.lean` § III), the order-floor face `selfApp_isLeastFixedPointFrom` is a chart of this role (`selfApp_seam_role_unique`, same `AbstractSelfApp.selfApp`); the other § III faces are indexed in `ZeroParadox/DieCannotBe.lean` § XV at most by `SelfOnlyAt` occupancy, never by this role's uniqueness. ## Engineer's Take @@ -121,8 +121,9 @@ def cofixMk (a : A) : Cofix (constPF A).Obj := /-- `Cofix.dest (cofixMk a)` has head `a`. -/ theorem cofixMk_head (a : A) : (Cofix.dest (cofixMk a)).1 = a := by - rw [cofixMk, Cofix.dest_corec] - rfl + exact (congrArg (fun z : (constPF A).Obj (Cofix (constPF A).Obj) => z.1) + (Cofix.dest_corec (F := (constPF A).Obj) + (fun a => (⟨a, fun e => e.elim⟩ : (constPF A).Obj A)) a)).trans rfl /-- `Cofix ≃ A`: the final coalgebra of the all-leaf constant functor collapses to `A`. The right inverse `cofixMk (dest x).1 = x` is proved by bisimulation. -/ @@ -138,7 +139,8 @@ def cofixEquiv : Cofix (constPF A).Obj ≃ A where rw [liftr_iff] refine ⟨(Cofix.dest v).1, fun e => e.elim, fun e => e.elim, ?_, ?_, ?_⟩ · -- Cofix.dest (cofixMk (Cofix.dest v).1) = abs ⟨(Cofix.dest v).1, PEmpty.elim⟩ - rw [cofixMk, Cofix.dest_corec] + refine (Cofix.dest_corec (F := (constPF A).Obj) + (fun a => (⟨a, fun e => e.elim⟩ : (constPF A).Obj A)) (Cofix.dest v).1).trans ?_ apply Sigma.ext · rfl · apply heq_of_eq @@ -182,8 +184,116 @@ theorem root_cut_dichotomy : IsEmpty (Fix ZeroParadox.idPF_Coalgebra.Obj ≃ Cofix ZeroParadox.idPF_Coalgebra.Obj) := ⟨⟨(root_seam : Fix (constPF Unit).Obj ≃ _)⟩, idPF_no_seam⟩ +/-! ### The seam role in the die +The chart: UP the identity on `Set X`, OVER the graph of the next-time operator `nextTime α` +(`ZeroParadox/Category/WellFoundedCoalgebra.lean`) of the chart's own coalgebra `α`. -/ + +/-- `Statement:` the next-time operator sends the whole carrier to itself. -/ +theorem nextTime_univ_eq {X : Type u} {P : PFunctor.{u, u}} (α : X → P.Obj X) : + nextTime α Set.univ = Set.univ := by + ext x; simp [nextTime] + +/-- `Statement:` exactly one set steps to itself only under `nextTime α` iff `α` is well-founded + (`IsWellFoundedCoalg`); both directions. + `Reading:` (cited, not claimed) this is Adámek, Milius and Moss's definition of a well-founded + coalgebra (*On Well-Founded and Recursive Coalgebras*, arXiv:1910.09401v2, Def 4.3, p. 15: "`id_A` + is the only fixed point of its next time operator"; they credit the characterisation to Taylor), + in its form for polynomial functors on types, `IsWellFoundedCoalg` (related to their categorical + form by `isWellFoundedCoalgCat_iff`, `ZeroParadox/Category/NextTimeCategorical.lean`), restated in + the die vocabulary through `Motion.selfOnlyAt_ofFun_iff` and `nextTime_univ_eq`; not a new + result. -/ +theorem seam_role_unique_iff_wellFounded {X : Type u} {P : PFunctor.{u, u}} (α : X → P.Obj X) : + (∃! S, (Motion.ofFun (nextTime α)).SelfOnlyAt S) ↔ IsWellFoundedCoalg α := by + constructor + · rintro ⟨S₀, -, hu⟩ S hS + have h1 : S = S₀ := hu S ((Motion.selfOnlyAt_ofFun_iff _ _).2 hS) + have h2 : Set.univ = S₀ := + hu Set.univ ((Motion.selfOnlyAt_ofFun_iff _ _).2 (nextTime_univ_eq α)) + rw [h1, ← h2] + · intro hwf + exact ⟨Set.univ, (Motion.selfOnlyAt_ofFun_iff _ _).2 (nextTime_univ_eq α), + fun S hS => hwf S ((Motion.selfOnlyAt_ofFun_iff _ _).1 hS)⟩ + +/-- `Statement:` on `Cofix (constPF A).Obj`, `nextTime Cofix.dest` is constantly `Set.univ`. -/ +theorem constPF_nextTime (S : Set (Cofix (constPF A).Obj)) : + nextTime (P := constPF A) Cofix.dest S = Set.univ := by + ext x + simp only [Set.mem_univ, iff_true] + intro b + exact b.elim + +/-- `Statement:` on `Cofix (constPF A).Obj`, exactly one set steps to itself only. `Reading:` for `A` + empty the chart has one point and this restates it. -/ +theorem constPF_seam_role_unique (A : Type u) : + ∃! S, (Motion.ofFun (nextTime (P := constPF A) + (Cofix.dest : Cofix (constPF A).Obj → _))).SelfOnlyAt S := + (seam_role_unique_iff_wellFounded _).2 fun S hS => by rw [← hS, constPF_nextTime] + +/-- `Statement:` on `Cofix idPF_Coalgebra.Obj`, not exactly one set steps to itself only (`∅` and + `Set.univ` both do). -/ +theorem idPF_seam_role_not_unique : + ¬ ∃! S, (Motion.ofFun (nextTime (P := idPF_Coalgebra) + (Cofix.dest : Cofix idPF_Coalgebra.Obj → _))).SelfOnlyAt S := by + intro h + have hwf := (seam_role_unique_iff_wellFounded _).1 h + obtain ⟨c⟩ := cofix_nonempty + have h0 : nextTime (P := idPF_Coalgebra) (Cofix.dest : Cofix idPF_Coalgebra.Obj → _) ∅ = ∅ := by + ext x + simp only [Set.mem_empty_iff_false, iff_false] + intro hx + exact hx PUnit.unit + have hc : c ∈ (∅ : Set _) := by rw [hwf ∅ h0]; trivial + exact hc + +/-- `Statement:` the point-level chart, OVER `x → y` when `y` is a child of `x`: on + `Cofix (constPF A).Obj` no point has a step. -/ +theorem constPF_child_noStepAt (x : Cofix (constPF A).Obj) : + (Motion.ofTotal (id : Cofix (constPF A).Obj → _) (fun _ => rfl) + (fun x y => ∃ b, (Cofix.dest x).2 b = y)).NoStepAt x := + fun _ ⟨b, _⟩ => b.elim + +/-- `Statement:` if some point is its own child, not exactly one set steps to itself only under + `nextTime α`; one way. -/ +theorem not_seam_role_unique_of_step_self {X : Type u} {P : PFunctor.{u, u}} (α : X → P.Obj X) + {x : X} (hx : ∃ b, (α x).2 b = x) : + ¬ ∃! S, (Motion.ofFun (nextTime α)).SelfOnlyAt S := by + intro h + have hl : wfPart α = Set.univ := + (isWellFoundedCoalg_iff_wfPart_univ α).1 ((seam_role_unique_iff_wellFounded α).1 h) + have hS : nextTime α {y | ¬ ∃ b, (α y).2 b = y} ≤ {y | ¬ ∃ b, (α y).2 b = y} := by + intro y hy ⟨b, hb⟩ + have := hy b + rw [hb] at this + exact this ⟨b, hb⟩ + have hle : wfPart α ≤ {y | ¬ ∃ b, (α y).2 b = y} := OrderHom.lfp_le (nextTimeHom α) hS + rw [hl] at hle + exact hle (Set.mem_univ x) hx + +-- Statement: CONTROL, the converse fails: on `Bool` with each point's one child its negation, no +-- point is its own child and not exactly one set steps to itself only. +example : + let α : Bool → idPF_Coalgebra.Obj Bool := fun b => ⟨PUnit.unit, fun _ => !b⟩ + (∀ x, ¬ ∃ b, (α x).2 b = x) ∧ ¬ ∃! S, (Motion.ofFun (nextTime α)).SelfOnlyAt S := by + intro α + refine ⟨fun x ⟨_, h⟩ => by cases x <;> simp [α] at h, fun h => ?_⟩ + have h0 : nextTime α ∅ = ∅ := by + ext x; simp only [Set.mem_empty_iff_false, iff_false]; intro hx; exact hx PUnit.unit + have : true ∈ (∅ : Set Bool) := by + rw [(seam_role_unique_iff_wellFounded α).1 h ∅ h0]; trivial + exact this + +-- Statement: CONTROL: OVER always true on `Unit` has exactly one point stepping to itself only, and +-- on `Bool` OVER the identity does not have exactly one (both points step to themselves only). +example : (∃! y, (Motion.ofTotal (id : Unit → Unit) (fun _ => rfl) (fun _ _ => True)).SelfOnlyAt y) ∧ + ¬ ∃! y, (Motion.ofFun (id : Bool → Bool)).SelfOnlyAt y := by + refine ⟨⟨(), ⟨trivial, fun _ _ => rfl⟩, fun _ _ => rfl⟩, ?_⟩ + rintro ⟨y, -, hu⟩ + have h1 := hu true ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl) + have h2 := hu false ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl) + exact absurd (h1.trans h2.symm) (by decide) + section PurityCheck --- Measured footprint (lake build, v4.30.0-rc2): +-- Measured footprint (lake build, v4.35.0): -- objEquiv : [Quot.sound] — the action collapse -- fixEquiv (μ side) : [propext, Quot.sound] — CHOICE-FREE -- cofixEquiv (ν side) : [propext, Classical.choice, Quot.sound] — choice-carrying @@ -205,6 +315,16 @@ section PurityCheck #print axioms root_seam #print axioms idPF_no_seam #print axioms root_cut_dichotomy +-- The seam role in the die (measured 2026-11-01): `nextTime_univ_eq` and +-- `seam_role_unique_iff_wellFounded` are [propext, Quot.sound]; the rest carry Classical.choice, +-- through `QPF.Cofix` in the statement or, for `not_seam_role_unique_of_step_self`, `OrderHom.lfp`. +#print axioms nextTime_univ_eq +#print axioms seam_role_unique_iff_wellFounded +#print axioms constPF_nextTime +#print axioms constPF_seam_role_unique +#print axioms idPF_seam_role_not_unique +#print axioms constPF_child_noStepAt +#print axioms not_seam_role_unique_of_step_self end PurityCheck end ZeroParadox diff --git a/ZeroParadox/Category/SeamComparisonMap.lean b/ZeroParadox/Category/SeamComparisonMap.lean index e25d50e8..b69ca3a3 100644 --- a/ZeroParadox/Category/SeamComparisonMap.lean +++ b/ZeroParadox/Category/SeamComparisonMap.lean @@ -5,8 +5,7 @@ import ZeroParadox.Category.RootCutDegeneracy import ZeroParadox.Category.SeamArrowLevel /-! -# The canonical μ→ν comparison map at the root seam, and the honest -fence on "root-seam ≅ node-seam" +# The canonical μ→ν comparison map at the root seam, and the root seam beside the node seam ## Engineer's Take @@ -26,7 +25,7 @@ equivalence (it factors through `A` on both sides). It does **not** identify the **μ→ν comparison map** — the map that recursion theory actually means by "the comparison from the initial algebra to the final coalgebra" — nor prove that *that* map is the iso. -This file closes that gap and then fences the keystone honestly. +This file closes that gap and then sets the root seam beside the node seam, each under its own condition. **GO (the genuinely new edge).** For any QPF `F`, the canonical comparison `Fix F → Cofix F` is the unique initial-algebra homomorphism into `Cofix F` regarded as an `F`-algebra via the inverse of @@ -48,9 +47,9 @@ So the *canonical* μ→ν comparison — the one defined by recursion, with its statement — is an isomorphism for the no-recursive-position functor. That is strictly more than `ZeroParadox/Category/RootCutDegeneracy.lean` (existence of an equiv): it pins down *which* map and proves the comparison itself invertible. -**NO-GO / honest fence (the load-bearing deflation, IN the statements).** The pre-registered risk was -that "root-seam ≅ node-seam" is a loose analogy, not a structural identity. It is. Two facts make this -decisive and they are stated in Lean: +**NO-GO (the deflation, IN the statements).** The pre-registered question was whether +"root-seam ≅ node-seam" is a structural identity. An equation between the two settings is ill-typed; +two facts, stated in Lean, show that each seam has its own governing condition: 1. `seam_iff_no_recursive_position` — the canonical comparison is an iso for `constPF` (no recursive position) and is *not* even a bijection for `idPF_Coalgebra` (one recursive position): there `Fix` is empty @@ -64,11 +63,10 @@ decisive and they are stated in Lean: The two governing conditions live in different settings (a QPF / coalgebra condition on a functor vs a universal-property condition on an object) and there is **no map between the settings** in this file. -`root_node_seam_no_identity` packages the conclusion: the root-seam iso and the node-seam arrow -collapse are recorded side by side as *distinct* phenomena, both true, neither derivable from the -other here — so "the polynomial-functor seam and the zero-object seam are the SAME phenomenon" is a -**cross-setting modeling commitment / analogy**, not a Lean theorem. The honest new content is the -canonical-comparison iso (GO); the unification is fenced. +`root_node_seam_no_identity` records the root-seam iso and the node-seam arrow collapse side by side, +both true, neither derived from the other. `Reading:` CARRIER — what they share is a die role, occupied +per chart with no equation across (`constPF_seam_role_unique`, `moduleCat_seam_role_unique_iff_isZero`; +indexed in `ZeroParadox/DieCannotBe.lean`). -/ namespace ZeroParadox @@ -142,7 +140,7 @@ theorem canonicalCmp_bijective : rw [canonicalCmp_eq_root_seam] exact (root_seam : Fix (constPF A).Obj ≃ _).bijective -/-! ## The honest fence: root-seam vs node-seam are distinct phenomena -/ +/-! ## Root-seam and node-seam: each governed by its own condition -/ /-- **The root-seam is governed by absence of a recursive position.** For `constPF` (no recursive position) the canonical comparison is a bijection; for `idPF_Coalgebra` (one recursive position) NO function @@ -172,19 +170,19 @@ theorem node_seam_arrow_collapse_is_generic : = 𝟙 (ZeroParadox.fC_functor.obj 0) := ZeroParadox.collapse_fires_off_seam -/-- **The honest fence (capstone, content IN the statement).** The root-level seam (canonical μ→ν -comparison is an iso, governed by absence of a recursive position) and the node-#5 seam (arrow -coincidence at a zero object, governed by the zero-object universal property and itself generic) are -recorded side by side as DISTINCT phenomena in DISTINCT settings: +/-- **Capstone (content IN the statement).** The root-level seam (canonical μ→ν comparison is an iso, +governed by absence of a recursive position) and the node-#5 seam (arrow coincidence at a zero object, +governed by the zero-object universal property and itself generic) are recorded side by side, each in +its own setting: * root: `Function.Bijective canonicalCmp` for `constPF Unit`; * node: the zero-object arrow coincidence `to = from`, which equals `to = 𝟙 = from` (`ZeroParadox/Category/SeamArrowLevel.lean`), a collapse that is generic to bare initial / bare terminal objects. Both are true; neither is derived from the other in this file, and there is no map between the QPF -setting and the categorical setting here. Therefore "the polynomial-functor seam and the zero-object -seam are the SAME phenomenon" is a cross-setting modeling commitment / analogy, NOT a theorem. The -genuine new Lean content is the canonical-comparison iso; the unification is fenced. -/ +setting and the categorical setting here. What the two seams share is the die role of exactly one +point stepping to itself only, occupied per chart (`constPF_seam_role_unique`, +`moduleCat_seam_role_unique_iff_isZero`); no equation across the two settings is stated. -/ theorem root_node_seam_no_identity : -- root-seam: canonical comparison is an iso for the no-recursive-position functor Function.Bijective (canonicalCmp : Fix (constPF Unit).Obj → Cofix (constPF Unit).Obj) @@ -202,8 +200,77 @@ theorem root_node_seam_no_identity : ZeroParadox.initial_endo_is_id (ZeroParadox.hilbert_bottom_isZero).isInitial⟩ +/-! ## The seam role in the die: the zero-object chart +The chart: the elements of a module `X`, UP the identity, OVER the graph of an endomorphism of `X`. -/ + +universe v + +/-- `Statement:` for a module `X`, every endomorphism `f` has exactly one point stepping to itself + only in `ofFun f` iff `X` is a zero object; both directions. -/ +theorem moduleCat_seam_role_unique_iff_isZero {R : Type u} [Ring R] (X : ModuleCat.{v} R) : + (∀ f : X ⟶ X, ∃! y, (Motion.ofFun f.hom).SelfOnlyAt y) ↔ Limits.IsZero X := by + constructor + · intro h + obtain ⟨y₀, -, hu⟩ := h (𝟙 X) + haveI : Subsingleton X := ⟨fun a b => by + rw [hu a ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl), + hu b ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl)]⟩ + exact ModuleCat.isZero_of_subsingleton X + · intro hz f + haveI : Subsingleton X := ModuleCat.subsingleton_of_isZero hz + exact ⟨0, (Motion.selfOnlyAt_ofFun_iff _ _).2 (map_zero f.hom), + fun _ _ => Subsingleton.elim _ _⟩ + +/-- `Statement:` the same with `f` the identity alone: exactly one point steps to itself only in + `ofFun (𝟙 X)` iff `X` is a zero object; both directions. -/ +theorem moduleCat_id_seam_role_unique_iff_isZero {R : Type u} [Ring R] (X : ModuleCat.{v} R) : + (∃! y, (Motion.ofFun (𝟙 X : X ⟶ X).hom).SelfOnlyAt y) ↔ Limits.IsZero X := by + constructor + · rintro ⟨y₀, -, hu⟩ + haveI : Subsingleton X := ⟨fun a b => by + rw [hu a ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl), + hu b ((Motion.selfOnlyAt_ofFun_iff _ _).2 rfl)]⟩ + exact ModuleCat.isZero_of_subsingleton X + · intro hz + exact (moduleCat_seam_role_unique_iff_isZero X).2 hz (𝟙 X) + +/-- `Statement:` at the Hilbert zero object `fD_functor.obj 0`, every endomorphism has exactly one + point stepping to itself only. `Reading:` the carrier has one point, so this restates `IsZero`. -/ +theorem hilbert_zero_seam_role_unique (f : fD_functor.obj 0 ⟶ fD_functor.obj 0) : + ∃! y, (Motion.ofFun f.hom).SelfOnlyAt y := + (moduleCat_seam_role_unique_iff_isZero _).2 hilbert_bottom_isZero f + +-- Statement: CONTROL: at `fD_functor.obj 1`, not a zero object, some endomorphism does not have +-- exactly one point stepping to itself only. +example : ¬ ∀ f : fD_functor.obj 1 ⟶ fD_functor.obj 1, ∃! y, (Motion.ofFun f.hom).SelfOnlyAt y := + fun h => by + have hs := ModuleCat.subsingleton_of_isZero ((moduleCat_seam_role_unique_iff_isZero _).1 h) + have : (EuclideanSpace.single (0 : Fin 1) (1 : ℂ) : StateSpace 1) = 0 := + @Subsingleton.elim (StateSpace 1) hs _ _ + simpa using congrArg (fun v => v (0 : Fin 1)) this + +-- Statement: CONTROL: at node #4, `fC_functor.obj 0` (initial, not a zero object), the carrier is +-- empty, so no motion on it has a point stepping to itself only. +example (M : Motion (fC_functor.obj 0)) : ¬ ∃ y, M.SelfOnlyAt y := by + rintro ⟨y, -⟩ + exact Fin.elim0 y + +-- Statement: the other variant, carrier the endomorphisms `fC_functor.obj 0 ⟶ fC_functor.obj 0`: +-- every self-map of it has exactly one point stepping to itself only. Reading: on endomorphisms the +-- carrier has one point at node #4 (`fC_zero_isInitial`) and at node #5 (`hilbert_bottom_isZero`), so +-- the role is occupied at both and restates that each hom-set is a singleton. On elements the carrier is +-- empty at node #4 (an object of `KleisliCat PMF`, not a module) and has one point at node #5, so the +-- element carriers separate the two nodes by cardinality alone; `moduleCat_seam_role_unique_iff_isZero` +-- applies at node #5, whose object is a module; node #4's is not. +example (g : (fC_functor.obj 0 ⟶ fC_functor.obj 0) → (fC_functor.obj 0 ⟶ fC_functor.obj 0)) : + ∃! y, (Motion.ofFun g).SelfOnlyAt y := by + haveI : Subsingleton (fC_functor.obj 0 ⟶ fC_functor.obj 0) := + ⟨fun a b => fC_zero_isInitial.hom_ext a b⟩ + exact ⟨𝟙 _, (Motion.selfOnlyAt_ofFun_iff _ _).2 (Subsingleton.elim _ _), + fun _ _ => Subsingleton.elim _ _⟩ + section PurityCheck --- Measured footprint (lake build, v4.30.0-rc2): every result is +-- Measured footprint (lake build, v4.35.0): every result is -- [propext, Classical.choice, Quot.sound] -- the expected library-choice footprint. The `Classical.choice` enters through `ZeroParadox/Category/RootCutDegeneracy.lean`'s ν-side -- (`cofixMk` / `root_seam`, the Mathlib M-type corecursion artifact) and the categorical seam @@ -219,6 +286,9 @@ section PurityCheck #print axioms seam_iff_no_recursive_position #print axioms node_seam_arrow_collapse_is_generic #print axioms root_node_seam_no_identity +#print axioms moduleCat_seam_role_unique_iff_isZero +#print axioms moduleCat_id_seam_role_unique_iff_isZero +#print axioms hilbert_zero_seam_role_unique end PurityCheck end ZeroParadox diff --git a/ZeroParadox/Category/SeamFrameChange.lean b/ZeroParadox/Category/SeamFrameChange.lean index c7bef47e..d9689e94 100644 --- a/ZeroParadox/Category/SeamFrameChange.lean +++ b/ZeroParadox/Category/SeamFrameChange.lean @@ -43,7 +43,7 @@ the zero object the coincidence fails (`generic_object_empty_lim_ne_colim`, `Sea `0` on the sphere — the frame-change fixes only the bottom. **Fences.** Category point-of-view's shape of the frame-change; the abstract cross-domain "snap = frame -change" stays conjectural (type boundary; see `.claude-local/notes/frame_change_across_domains_2026-07-11.md`). +change" stays conjectural (type boundary). The content is a bundling of `hilbert_bottom_isZero` with Mathlib's `op`-duality; no mathematical novelty. Prior art (cited, not reproved): that a zero object stays zero under `op` is Mathlib's diff --git a/ZeroParadox/Category/TreeSeam.lean b/ZeroParadox/Category/TreeSeam.lean index e6ecea44..3d369e08 100644 --- a/ZeroParadox/Category/TreeSeam.lean +++ b/ZeroParadox/Category/TreeSeam.lean @@ -1,4 +1,3 @@ --- EXPERIMENTAL (branch scaffolding): bottom-diagram probe campaign, not a finalized layer. Curated/load-bearing results are indexed in ZeroParadox/BottomCannotBe.lean and classified in ZeroParadox/MANIFEST.md. import ZeroParadox.State.HilbFunctor import ZeroParadox.Multihomed.InfoFunctor import ZeroParadox.Multihomed.TreeObstructions @@ -28,16 +27,16 @@ Hilbert bottom `fD_functor.obj 0 = StateSpace 0`, **straddles**: it is a *zero o sits AT the μ/ν seam (the μ=ν coincidence, the [[project_diagonal_fixed_point]]) or it is a defect. **Resolution: #5 is the seam, not a defect — the only both-sided node among the three categorical -bottoms** (a three-way separation, not a uniqueness claim over all objects). The others sit strictly -on one side: +bottoms** (the three full positions are stated together in `floor_positions_full`; not a uniqueness +claim over all objects). The others sit strictly on one side: - `hilbert_bottom_isZero` — #5 `fD_functor.obj 0` is a **zero object** (initial ∧ terminal): the μ=ν coincidence, the seam node. - `kleisli_bottom_not_terminal` — #4 `fC_functor.obj 0 = Fin 0` is **initial but NOT terminal** (a terminal object would need a morphism *into* it from every object, but `fC_no_return` proves the hom-set from any nonempty object into `Fin 0` is empty). So #4 is strictly on the μ side. -- (#3, the p-adic floor, is strictly on the ν side: `padic_bottom_not_initial` - — not initial.) +- (#3, the p-adic floor, is strictly on the ν side: `padic_bottom_isTerminal` and + `padic_bottom_not_initial` — terminal and not initial.) So the μ/ν fork is genuinely populated: #4 strictly μ, #3 strictly ν, #5 the (among-these-three) seam where they coincide. That `StateSpace 0` is special this way is exactly what the zero object means — the place @@ -45,8 +44,8 @@ the two universal properties collapse into one — which is the diagonal-fixed-p at a node, not a bug in the tree. **Honest fence.** "This seam IS the diagonal fixed point / the keystone" is the framework's -interpretation, not a Lean claim; the Lean content is precisely: #5 is a zero object, #4 is initial -and not terminal, #3 is not initial. The seam reading is the meaning we attach to that pattern. +interpretation, not a Lean claim; the Lean content is precisely `floor_positions_full`. The seam +reading is the meaning we attach to that pattern. -/ namespace ZeroParadox @@ -101,16 +100,37 @@ example : { default := fun _ => PMF.pure () uniq := fun _ => funext fun _ => Subsingleton.elim (α := PMF Unit) _ _ })⟩⟩ -/-- The three categorical bottoms sit at **distinct positions of the μ/ν fork**, all in one statement: - #5 is a zero object (μ ∧ ν — the seam); #4 is not terminal (strictly μ); #3 is not initial - (strictly ν). So among these three, #5 is the only both-sided (seam) node. NOTE: this is a - three-way separation of the *named* bottoms, NOT a uniqueness claim quantified over all objects. -/ +/-- `Statement:` the `ModuleCat ℂ` floor is a zero object, the `KleisliCat PMF` floor is not + terminal, the `TopCat` floor `{0}` is not initial. This separates the zero object from each + one-sided floor; the two one-sided floors are told apart only with their positive halves, in + `floor_positions_full`. Named floors only, not a claim over all objects. -/ theorem fork_positions_distinct : Limits.IsZero (fD_functor.obj 0) ∧ IsEmpty (Limits.IsTerminal (fC_functor.obj 0)) ∧ IsEmpty (Limits.IsInitial (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) := ⟨hilbert_bottom_isZero, kleisli_bottom_not_terminal, padic_bottom_not_initial⟩ +/-- `Statement:` the three full positions: a zero object in `ModuleCat ℂ`; initial and not terminal + in `KleisliCat PMF`; terminal and not initial in `TopCat`. -/ +theorem floor_positions_full : + Limits.IsZero (fD_functor.obj 0) + ∧ (Nonempty (Limits.IsInitial (fC_functor.obj 0)) + ∧ IsEmpty (Limits.IsTerminal (fC_functor.obj 0))) + ∧ (Nonempty (Limits.IsTerminal (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) + ∧ IsEmpty (Limits.IsInitial (TopCat.of (↥({(0 : Q₂)} : Set Q₂))))) := + ⟨fork_positions_distinct.1, ⟨⟨fC_zero_isInitial⟩, fork_positions_distinct.2.1⟩, + ⟨padic_bottom_isTerminal, fork_positions_distinct.2.2⟩⟩ + +-- `Statement:` the three clauses of `floor_positions_full` are pairwise exclusive for any object of +-- any category, so the three floors occupy three distinct positions. +example {C : Type*} [Category C] (X : C) : + ¬ (Limits.IsZero X ∧ IsEmpty (Limits.IsTerminal X)) + ∧ ¬ (Limits.IsZero X ∧ IsEmpty (Limits.IsInitial X)) + ∧ ¬ ((Nonempty (Limits.IsInitial X) ∧ IsEmpty (Limits.IsTerminal X)) + ∧ (Nonempty (Limits.IsTerminal X) ∧ IsEmpty (Limits.IsInitial X))) := + ⟨fun ⟨hz, ht⟩ => ht.false hz.isTerminal, fun ⟨hz, hi⟩ => hi.false hz.isInitial, + fun ⟨⟨⟨hi⟩, _⟩, _, hni⟩ => hni.false hi⟩ + end ZeroParadox /-! ## Axiom Purity Check -/ @@ -121,5 +141,6 @@ open ZeroParadox #print axioms hilbert_bottom_isZero #print axioms kleisli_bottom_not_terminal #print axioms fork_positions_distinct +#print axioms floor_positions_full end PurityCheck diff --git a/ZeroParadox/Category/WellFoundedCoalgebra.lean b/ZeroParadox/Category/WellFoundedCoalgebra.lean index 682d8360..2ebb27ef 100644 --- a/ZeroParadox/Category/WellFoundedCoalgebra.lean +++ b/ZeroParadox/Category/WellFoundedCoalgebra.lean @@ -49,12 +49,12 @@ Recursive Coalgebras*, § 4. They credit the characterization to **Taylor** and ⚠ **Where to verify the Taylor credit.** AMM cite it as their ref [28, Exercise VI.17], and their [28] is **Taylor, *Practical Foundations of Mathematics* (CUP 1999)** — which this project does **not** -hold. The Taylor PDF that *is* in `.claude-local/papers/` is his *Well founded coalgebras and -recursion*, a **different document, which does not contain Exercise VI.17**; do not send a reader -there for it. +hold. The Taylor document this project does hold is Paul Taylor, *Well founded coalgebras and +recursion* (a preprint; the copy consulted carries no publication details), a **different document, +which does not contain Exercise VI.17**; do not send a reader there for it. -Source PDF for every quotation below: -`.claude-local/papers/adamek_milius_moss_wellfounded_recursive_coalgebras.pdf`. Their statements — +Source for every quotation below: Adámek, Milius, Moss, *On Well-Founded and Recursive Coalgebras*, +arXiv:1910.09401v2 (16 Feb 2020). Their statements — the bulleted ones in quote marks are verbatim; Def 4.1 is their notation transcribed: * **Def 4.1** — every coalgebra `α : A → F A` induces `⃝ : Sub(A) → Sub(A)`, `⃝(s) = α⁻¹(F s)`. @@ -75,8 +75,7 @@ Thm 7.6, their coreflection, or recursive coalgebras.** This paragraph previously also said *"no claim is made that the framework's categories satisfy their hypotheses"*, which § V made false and which sat here contradicting it. **Scope the two apart:** § V covers `Type u` with `ofTypeFunctor P.Obj` only, and **says nothing about the MC-1 carriers** -(`TopCat`, `ModuleCat ℂ`, `KleisliCat PMF`) — those remain unchecked, and that is what -`.claude-local/notes/future-research/amm_coreflection_requirements_gap_2026-08-04.md` tracks. +(`TopCat`, `ModuleCat ℂ`, `KleisliCat PMF`) — those remain unchecked. **What this file adds over restating the definitions:** the two `Statement:` results in § III/§ IV place the corpus's own W- and M-types on the fork **intrinsically**, so the μ/ν split stops depending @@ -242,8 +241,8 @@ built.** Ambient hypotheses: see the table below, all four. Subject: `wtypeFixed `ZeroParadox/Category/NextTimeCategorical.lean`'s `isWellFoundedCoalgCat_iff` transports the predicate. ⚠ **AND THAT IS STILL NOT A PROOF OF Thm 7.6, so read what it does license carefully.** Thm 7.6 is -**not formalized** anywhere in this corpus, and Mathlib has no well-founded-coalgebra machinery to -formalize it with. What is now available is its **conclusion, by citation**, for this setting — because +**not formalized** anywhere in this corpus, and no well-founded-coalgebra machinery to formalize it +with was located in the Mathlib pin (search record in § V). What is now available is its **conclusion, by citation**, for this setting — because its assumptions are discharged and its subject is connected. That is what "instance of" means here and it is strictly weaker than a Lean derivation. **Do not write "we proved Thm 7.6."** @@ -265,8 +264,7 @@ monomorphisms" as a single proposition — the paragraph above is the argument t written in prose and checkable by reading, not a theorem. **(2)** The whole table is about **`Type u` with `ofTypeFunctor P.Obj`** and says nothing -about the MC-1 carriers (`TopCat`, `ModuleCat ℂ`, `KleisliCat PMF`), which remain unchecked — see -`.claude-local/notes/future-research/amm_coreflection_requirements_gap_2026-08-04.md`. Both smoothness +about the MC-1 carriers (`TopCat`, `ModuleCat ℂ`, `KleisliCat PMF`), which remain unchecked. Both smoothness theorems also take `{J : Type u}`, so they reach λ-chains for `Type u`-small λ; AMM quantify over every ordinal. @@ -317,8 +315,8 @@ second attempt named `IsStableUnderTransfiniteComposition` plus cofinality of th real route, and longer than the one actually used. **Do not restore either citation.** ⚠ **Verified hypotheses are not a formalized theorem, and what the citation buys is narrow.** AMM -Thm 7.6 is **not** proved in Lean here, and Mathlib has no well-founded-coalgebra machinery to prove it -with. What Thm 7.6 would deliver, given its hypotheses, is that a well-founded fixed point **is the +Thm 7.6 is **not** proved in Lean here, and no well-founded-coalgebra machinery to prove it with was +located in the Mathlib pin (search record in § V). What Thm 7.6 would deliver, given its hypotheses, is that a well-founded fixed point **is the initial algebra** — i.e. it *concludes* initiality rather than assuming it, which is why the `fork_is_intrinsic` fence above ("not proved: that either carrier is initial/final") is consistent with citing it. That conclusion is available **by citation only**. Do not upgrade this to "we proved @@ -333,8 +331,7 @@ was an unverified negative**: `WellPowered (Type 0)` fails on an unimported name universe parameter; `PreservesMonomorphisms` "does not synthesize" is true of the *instance database* and false of the *fact*; and smooth monomorphisms is **assembled from** pieces in the pin though no declaration bears the name. A failed `#synth` is evidence about the probe. See `CLAUDE.md` -§ *"NOT IN THE LIBRARY" IS A CLAIM*, and -`.claude-local/notes/future-research/amm_coreflection_requirements_gap_2026-08-04.md` § 4b. -/ +§ R-NOTINLIB. -/ theorem fork_is_intrinsic : IsWellFoundedCoalg (P := idPF_Coalgebra) W.dest ∧ ¬ IsWellFoundedCoalg (P := idPF_Coalgebra) M.dest := @@ -360,17 +357,17 @@ theorem natPF_wtype_wellFounded_and_inhabited : /-! ### § V. AMM Thm 7.6's hypotheses, VERIFIED for this setting -**What this section is for.** Thm 7.6 holds in *"a complete and well-powered category with smooth -monomorphisms"* for *"F preserving monomorphisms."* Earlier versions of this file recorded that count -wrong **four times, in both directions** — see the ⚠ block in the overview for the measured sequence -and the commits. Most were unverified **negatives** (`CLAUDE.md` § *"NOT IN THE LIBRARY" IS A CLAIM*); -one was an unverified positive. **All four are now discharged**: complete and well-powered are Mathlib instances, and the -three theorems below supply `F`-preservation plus smoothness clauses (b) and (c) — clause (a) being -`Types.hasColimitsOfShape`, and AMM's trailing *"every morphism from 0 is monic"* immediate in `Type u`. +**What this section is for.** Thm 7.6 holds in *"a complete and well-powered category with smooth monomorphisms"* +for *"F preserving monomorphisms."* Earlier versions of this file recorded that count wrong **four times, in both +directions** (the ⚠ block in the overview); most were unverified **negatives** (`CLAUDE.md` § R-NOTINLIB), one an +unverified positive. **All four are now discharged**: complete and well-powered are Mathlib instances, and the three +theorems below supply `F`-preservation plus smoothness clauses (b) and (c) — clause (a) being `Types.hasColimitsOfShape`, +and AMM's trailing *"every morphism from 0 is monic"* immediate in `Type u`. -⚠ **Verifying the hypotheses is NOT proving the theorem.** AMM Thm 7.6 is **not formalized here** and -Mathlib has no well-founded-coalgebra machinery. What § V establishes is that this setting **satisfies -the theorem's assumptions**, so its conclusion applies *by citation* — never as a Lean derivation. +⚠ **Verifying the hypotheses is NOT proving the theorem.** AMM Thm 7.6 is **not formalized here**, and no +well-founded-coalgebra machinery was located in the Mathlib pin as of 2026-11-03 (grep: `Mathlib/` for `WellFounded`/"well-founded" +within 40 characters of "coalg", "recursive coalgebra", `IsRecursive`; `Mathlib/CategoryTheory/Endofunctor/` for +`WellFounded`, `Acc`, "recursive": no hits). Its conclusion applies here *by citation* — never as a Lean derivation. ⚠ **And satisfying the hypotheses is not, by itself, the whole instance-of claim either.** Thm 7.6 is about **fixed points** and **initial algebras**; connecting to that *subject* is a separate axis, closed @@ -501,8 +498,8 @@ end ZeroParadox /-! ## Axiom Purity Check -**Measured 2026-08-04, not inferred.** `#print axioms` follows the STATEMENT, so read the split by -what each statement mentions: +**Measured 2026-08-04, not inferred.** `#print axioms` follows the statement and the proof: read the +split first by what each statement mentions, which a proof can add to and never remove: ``` nextTime no axioms -- the operator itself diff --git a/ZeroParadox/ClaimsMirror.lean b/ZeroParadox/ClaimsMirror.lean index a6365265..024ed499 100644 --- a/ZeroParadox/ClaimsMirror.lean +++ b/ZeroParadox/ClaimsMirror.lean @@ -8,6 +8,8 @@ import ZeroParadox.Ordinal.ProofFloorCanonical import ZeroParadox.Algebra.Wheel import ZeroParadox.Multihomed.MC1Bridge import ZeroParadox.Multihomed.TopNumEdge +import ZeroParadox.Multihomed.TreeObstructions +import ZeroParadox.Order.PadicLimitCone import ZeroParadox.Category.Category import ZeroParadox.Category.LinFunctor import ZeroParadox.Reals.PerronFrobenius @@ -74,8 +76,8 @@ theorem claim_node_order {L : Type*} [ZPSemilattice L] (x : L) : le bot x := bot_le x /-- Claim `node-set-theory` (proved). Statement: "In set theory, ⊥ is realized as the Quine atom - ⊥ = {⊥}, the self-membered singleton (ZF+AFA)." Exact representation: ⊥ is the unique self-membered - element, i.e. a Quine atom. Backing: `bot_is_quine_atom`. -/ + ⊥ = {⊥}, the self-membered singleton (ZF+AFA)." Exact representation: ⊥ alone satisfies `selfMem` + (`IsQuineAtom`), read in ZF+AFA as x = {x}, not bare x ∈ x (`selfMem`'s note). Backing: `bot_is_quine_atom`. -/ theorem claim_node_set_theory {L : Type*} [ZPSemilattice L] [AFAStructure L] : IsQuineAtom (bot : L) := bot_is_quine_atom @@ -101,8 +103,13 @@ theorem claim_T_SNAP : c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ join c₀ c₁ = c₁ /-! ## § II. Floor domains (information, valuation) -/ /-- Claim `node-information` (proved). Statement: "In information theory, L-INF gives unbounded - surprisal: for every bound M some ball depth n has surprisal I(n) = n > M." Exact representation: the surprisal is unbounded - (no finite bound holds), the L-INF divergence (`l_inf`: ∀ M, ∃ n, M < surprisal n). Backing: `info_bottom_diverges`. -/ + surprisal: for every bound M some ball depth n has surprisal I(n) = n > M." (the claim graph adds: + n is a natural number, the ball-depth reading a design identification, `surprisal_eq_binary_info`; + and the second, point-mass reading, `pmf_subsingleton_isPure`). Exact representation: the surprisal is unbounded + (no finite bound holds), the L-INF divergence (`l_inf`: ∀ M, ∃ n, M < surprisal n). Backing: `info_bottom_diverges`. + Measure-theoretic home of the depth reading: the depth-n ball of ℤ_[p] has Haar measure p⁻ⁿ + (`haarZp_ball`, `ZeroParadox/Valuation/PadicHaar.lean`), and the balls of ℚ₂ meet in `{0}` + (`topfloor_singleton`, `ZeroParadox/Valuation/PadicAttractor.lean`). -/ theorem claim_node_information : ∀ M : ℝ, ∃ n : ℕ, M < surprisal n := info_bottom_diverges @@ -132,13 +139,28 @@ theorem claim_node_algebra : zpwMul (.fin 0) .inf = .bot := theorem claim_node_state : Nonempty (Limits.IsInitial (fD_functor.obj 0)) := ⟨fD_zero_isInitial⟩ -/-! ## § IV. MC-1 correspondence (each domain bottom is its category's categorical bottom) -/ - -/-- Claim `MC-1-correspondence` (corr). Statement: "Each domain bottom is the categorical bottom of its - own real category (MC-1, correspondence half — formally realized)." Exact representation: the bundled - three-realization witness exists. Backing: `mc1_correspondence`. -/ -theorem claim_MC1_correspondence : Nonempty MC1Correspondence := - ⟨mc1_correspondence⟩ +/-! ## § IV. MC-1 correspondence (each domain floor characterized in its own category, differently) -/ + +/-- Claim `MC-1-correspondence` (corr). Statement: "MC-1, correspondence half (formally realized), + characterized per real Mathlib category and differing by category: the state floor is a zero object + (initial and terminal) in ModuleCat ℂ; the information floor is initial and not terminal in + KleisliCat PMF, with no morphism into it from any later stage of the functor; the p-adic floor + {0} ⊆ ℚ₂ is terminal in TopCat (it has one point) and not initial, and separately the limit of the + ball tower." Exact representation: the bundled witness (two initial objects, no morphism from a + stage `n > 0` into stage 0 of `fC_functor`, the set equation), the `TopCat` limit cone, + terminal-not-initial for `{0}`, the `ModuleCat ℂ` floor terminal, the `KleisliCat PMF` floor not + terminal. Backing: `mc1_correspondence`, `floorConeIsLimit`, `padic_bottom_isTerminal`, + `padic_bottom_not_initial`, `fD_zero_isTerminal`, `fC_no_return`; the three full positions are + stated together in `floor_positions_full` (`ZeroParadox/Category/TreeSeam.lean`). -/ +theorem claim_MC1_correspondence : + Nonempty MC1Correspondence ∧ Nonempty (Limits.IsLimit floorCone) ∧ + Nonempty (Limits.IsTerminal (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) ∧ + IsEmpty (Limits.IsInitial (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) ∧ + Nonempty (Limits.IsTerminal (fD_functor.obj 0)) ∧ + IsEmpty (Limits.IsTerminal (fC_functor.obj 0)) := + ⟨⟨mc1_correspondence⟩, ⟨floorConeIsLimit⟩, padic_bottom_isTerminal, padic_bottom_not_initial, + ⟨fD_zero_isTerminal⟩, + ⟨fun h => (fC_no_return (by norm_num : 0 < 1)).false (h.from (fC_functor.obj 1))⟩⟩ /-- Claim `MC1-cat-state` (corr). Statement: "the state/Hilbert bottom is the initial object of its real category (fD zero is initial)." Backing: `fD_zero_isInitial`. -/ @@ -151,9 +173,11 @@ theorem claim_MC1_cat_information : Nonempty (Limits.IsInitial (fC_functor.obj 0 ⟨fC_zero_isInitial⟩ /-- Claim `MC1-cat-valuation` (corr). Statement: "the p-adic (valuation) bottom is the inverse limit of - the ball system in the category realization (⋂ balls = {0})." Backing: `fB_bottom_is_limit`. -/ -theorem claim_MC1_cat_valuation : (⋂ n, q2Ball n) = {(0 : Q₂)} := - fB_bottom_is_limit + the ball system in the category realization (⋂ balls = {0})." Exact representation: the `TopCat` limit + cone over the ball tower, and the set equation. Backing: `floorConeIsLimit`, `fB_bottom_is_limit`. -/ +theorem claim_MC1_cat_valuation : + Nonempty (Limits.IsLimit floorCone) ∧ (⋂ n, q2Ball n) = {(0 : Q₂)} := + ⟨⟨floorConeIsLimit⟩, fB_bottom_is_limit⟩ /-! ## § V. Category bottom and the floor-reaching correspondence (E-series, Perron) -/ diff --git a/ZeroParadox/Computability/ChoicePurityInvariant.lean b/ZeroParadox/Computability/ChoicePurityInvariant.lean index 8b4d013b..465b9d22 100644 --- a/ZeroParadox/Computability/ChoicePurityInvariant.lean +++ b/ZeroParadox/Computability/ChoicePurityInvariant.lean @@ -13,6 +13,7 @@ while the ν side (`cofix_nonempty`, the final coalgebra / non-well-founded clos `Classical.choice`. The question here: can that split be lifted into a **theorem-level, in-statement invariant** — a witnessed result — rather than a measured comment? Long form, beside this file: `ZeroParadox/Computability/ChoicePurityInvariant.md`. + ## Engineer's Take This file is one of a series of iterative attempts on this branch to build a map of how the various @@ -56,8 +57,9 @@ M-type machinery — recorded in PurityCheck, NOT asserted as a necessity. Measu FORMER and constructors are axiom-free while its DESTRUCTOR (`M.children`/`M.dest`) is NOT — that is where the axiom originates, and `Cofix` inherits it through the congruence it quotients by. What makes the footprint a *quotient-layer* artifact is that `strict_cofix_nonempty` witnesses the same -inhabitation with no axioms, by only BUILDING and never destructing (see the header for why Veltri is -background, not support). -/ +inhabitation with no axioms, by only BUILDING and never destructing (see +`ZeroParadox/Computability/ChoicePurityInvariant.md`, the Veltri entry under Prior art, for why Veltri +is background, not support). -/ theorem cofix_nonempty' : Nonempty (Cofix ZeroParadox.idPF_Coalgebra.Obj) := ZeroParadox.cofix_nonempty @@ -80,7 +82,7 @@ theorem root_purity_split : example (p : Prop) (P : p → Prop) (h₁ h₂ : p) : P h₁ ↔ P h₂ := Iff.rfl section PurityCheck --- Measured footprint (lake build, v4.30.0-rc2): +-- Measured footprint (lake build, v4.35.0): -- w_isEmpty : (no axioms) — bare WType eliminator -- fix_isEmpty_constructive : (no axioms) — FULLY AXIOM-FREE -- cofix_nonempty' : [propext, Classical.choice, Quot.sound] — choice-carrying (ν) @@ -93,7 +95,7 @@ section PurityCheck -- (strictly tighter than the existing `fix_isEmpty`'s [propext, Quot.sound]) and witnesses Fix-emptiness -- through the bare inductive `WType.recOn`, not through Fix.ind/Liftp/quotient machinery. That is a real -- new term, not a re-export. --- The ν side CANNOT be upgraded: Lean has no object-level proposition asserting "this term uses +-- The ν side is not upgraded here, and choice is not claimed load-bearing: Lean has no object-level proposition asserting "this term uses -- Classical.choice", and the strongest honest statement (`cofix_nonempty'`) is exactly Mathlib's -- corecursion inhabitant. That choice is a quotient-layer artifact, MEASURED: `QPF.Cofix` carries -- it in the type (so no proof of a Cofix-mentioning statement is clean), inheriting it from diff --git a/ZeroParadox/Computability/ChoicePurityInvariant.md b/ZeroParadox/Computability/ChoicePurityInvariant.md index 38d310cc..4ab3b3e6 100644 --- a/ZeroParadox/Computability/ChoicePurityInvariant.md +++ b/ZeroParadox/Computability/ChoicePurityInvariant.md @@ -1,18 +1,18 @@ # ChoicePurityInvariant — ride-along documentation -Moved from `ZeroParadox/Computability/ChoicePurityInvariant.lean`. ⚠ **This content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED. Moving it changes that by exactly nothing.** Its claims are unverified until a claim review says otherwise. +Moved from `ZeroParadox/Computability/ChoicePurityInvariant.lean` on 2026-10-13. ⚠ **At the move this content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED, and moving it changed that by exactly nothing.** The text has been edited since the move; this banner records its state on 2026-10-13 and does not record whether any review has taken place since. In the sections below, "this file" and "here" refer to `ZeroParadox/Computability/ChoicePurityInvariant.lean`. ## The honest answer, and what the Lean witnesses -A proposition about a proof cannot see that proof's axiom footprint: a predicate on the proofs of one -proposition takes the same value at every proof (proof irrelevance; measured 2026-10-14 by the `example` -just before this file's `PurityCheck` section, which closes by `Iff.rfl`), so no proposition about the -proof can say "this proof term omits `Classical.choice`"; so "μ is choice-free" cannot be made -*directly* load-bearing in a statement; the footprint is read at the meta level (`#print axioms`), not -by a proposition about the proof. The only way to put constructive content IN the statement is to +A proposition about a proof cannot see that proof's axiom footprint. Two facts combine here. First, a +predicate on the proofs of one proposition takes the same value at every proof (proof irrelevance; +measured 2026-10-14 by the `example` just before this file's `PurityCheck` section, which closes by +`Iff.rfl`), so no such predicate separates a proof that uses `Classical.choice` from one that does not. +Second, the footprint is computed at the meta level, by `#print axioms`, outside the statement +language. Together they are why no statement here carries "μ is choice-free" *directly*. The only way to put constructive content IN the statement is to exhibit the μ-witness through a genuinely constructive proxy. That is what this file does, and it is the load-bearing new content over `fix_isEmpty`: @@ -74,8 +74,9 @@ content over `fix_isEmpty`: The bundle `root_purity_split` packages both honest halves: the μ-witness is propositionally derivable from a purely structural eliminator AND the ν-inhabitant is a concrete corecursion term, in one statement. The *content* that is genuinely new is `w_isEmpty` / `fix_isEmpty_constructive`: a μ-witness -inhabiting the constructive (choice-and-propext-free, then choice-free) namespace, derived without any -choice-dependent or quotient-quotient-collapse lemma. +inhabiting the constructive namespace — both recorded with no axioms at all, not even `propext` or +`Quot.sound` (`ZeroParadox/Computability/ChoicePurityInvariant.lean`, `PurityCheck`) — derived without any +choice-dependent or quotient-collapse lemma. ## Formal Overview diff --git a/ZeroParadox/Computability/CodeDataFrameChange.lean b/ZeroParadox/Computability/CodeDataFrameChange.lean index aa9bcc9e..77dfeee5 100644 --- a/ZeroParadox/Computability/CodeDataFrameChange.lean +++ b/ZeroParadox/Computability/CodeDataFrameChange.lean @@ -1,4 +1,4 @@ --- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the computability-frame realization of the POLE EXCHANGE (the snap-as-instance reading is ZP-Q's conjecture, not established here) — the code↔data (Gödel) involution swaps a configuration's program-role and data-role (both Gödel-numbered as ℕ); its fixed locus is the self-application diagonal (code = data), where the Kleene/Rogers quine lives. The computability analog of RiemannSphere's rInv (0↔∞) and Category's op (initial↔terminal). Curated results indexed in ZeroParadox/MANIFEST.md. +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the computability-frame realization of the POLE EXCHANGE (the snap-as-instance reading is ZP-Q's conjecture, not established here) — the code↔data (Gödel) involution swaps a configuration's program-role and data-role (both Gödel-numbered as ℕ); its fixed locus is the self-application diagonal (code = data), on which every code's self-configuration lies, the Kleene/Rogers quine's included. The computability analog of RiemannSphere's rInv (0↔∞) and Category's op (initial↔terminal). Curated results indexed in ZeroParadox/MANIFEST.md. import ZeroParadox.Computability.Kleene import Mathlib.Tactic @@ -6,7 +6,7 @@ import Mathlib.Tactic set_option maxHeartbeats 400000 /-! -# The frame-change in the computability frame: the code↔data involution and the quine on its fixed locus +# The frame-change in the computability frame: the code↔data involution, whose fixed locus holds every code's self-application Experimental probe in the bottom-diagram mapping campaign — not a finalized layer. Curated results are indexed in ZeroParadox/MANIFEST.md. @@ -31,34 +31,27 @@ object — its **fixed locus is the self-application diagonal**: `codeDataSwap p (`codeDataSwap_fixed_iff`), i.e. the configurations where a program's code equals its datum, a program run on its own code. -The Kleene/Rogers quine lives on that fixed locus. Every code's self-application configuration -`(encode c, encode c)` is swap-fixed (`selfConfig_on_fixedLocus`), and Rogers' fixed-point theorem -(`roger_fixed_point_exists`, Mathlib `Nat.Partrec.Code.fixed_point`) supplies, for any computable -transformation `f`, a fixed-point code `c` with `eval (f c) = eval c` whose self-configuration sits on -the diagonal. `codedata_is_frameflip` bundles the three faces: the frame-change is an involution, its -fixed locus is exactly the self-application diagonal, and the self-reproducing quine lies on it — the -computability realization of the POLE EXCHANGE. - `Statement:` INVERSION — the code/data involution exchanges the two roles, and its fixed locus is the -self-application diagonal (`codedata_is_frameflip`). +self-application diagonal (`codedata_is_frameflip`). Every code's self-configuration lies on it +(`selfConfig_on_fixedLocus`, for every `c : Code`), so face (iii) adds the existence of a Rogers +fixed-point code (`roger_fixed_point_exists`), not its position. `Reading:` INVERSION — the framework reads the snap as an instance of this exchange. Conjectural: no snap transition appears in these statements. See `Multihomed/SnapFrameChange.lean`'s declaration docstring. -Content: a bundling of Mathlib's `Prod.swap` involution with Rogers' fixed-point theorem and the -`quine_period_is_goedel` / `IsComputationalQuine` infrastructure of ZP-K; no mathematical novelty. The -pure swap facts are choice-free — `codeDataSwap_involutive` is axiom-free and `codeDataSwap_fixed_iff` is -`propext`-only; the faces that mention codes and the quine (`selfConfig_on_fixedLocus`, -`codedata_is_frameflip`) carry `Classical.choice`, inherited from the Mathlib `Code` / Rogers fixed-point -infrastructure, as documented in `Computability/Kleene.lean`. (Axiom footprints only — the KIND and -status of the claim itself are the `Statement:` / `Reading:` INVERSION labels above.) +Content: a bundling of Mathlib's `Prod.swap` involution with Rogers' fixed-point theorem; no +mathematical novelty. +Footprints: `codeDataSwap_involutive` axiom-free, `codeDataSwap_fixed_iff` `propext`-only; the two +results whose statements mention `Encodable.encode` on `Code` carry `Classical.choice`, which enters +through `Nat.Partrec.Code.instDenumerable` (`ZeroParadox/Category/ChoiceCannotBe.lean` § III; printed in +`ZeroParadox/Computability/Kleene.lean`'s `PurityCheck`). The bundle's proof also calls Rogers' theorem, +not separated here. **Fences.** Computability point-of-view's shape of the frame-change; the abstract cross-domain -"snap = frame-change" stays conjectural (type boundary; see -`.claude-local/notes/frame_change_across_domains_2026-07-11.md`). +"snap = frame-change" stays conjectural (type boundary). ## Structure - § I The code↔data involution: `codeDataSwap`, involutive, fixed locus = the self-application diagonal -- § II The quine on the fixed locus: `selfConfig_on_fixedLocus`, `codedata_is_frameflip` +- § II Self-application configurations, and the bundled three-face result -/ namespace ZeroParadox @@ -86,7 +79,7 @@ theorem codeDataSwap_fixed_iff (p : ℕ × ℕ) : codeDataSwap p = p ↔ p.1 = p simp only [Prod.fst_swap, Prod.snd_swap] exact ⟨fun h => h.2, fun h => ⟨h.symm, h⟩⟩ -/-! ## § II — The quine on the fixed locus -/ +/-! ## § II — Every code's self-configuration on the fixed locus -/ /-- Every code's **self-application configuration** `(encode c, encode c)` lies on the fixed locus (the diagonal) of the frame-change. -/ @@ -95,13 +88,12 @@ theorem selfConfig_on_fixedLocus (c : Code) : = (Encodable.encode c, Encodable.encode c) := (codeDataSwap_fixed_iff (Encodable.encode c, Encodable.encode c)).mpr rfl -/-- **The code↔data frame-flip (computability frame).** The frame-change is (i) an involution - (self-inverse, like `rInv`/`op`); (ii) its fixed locus is exactly the self-application diagonal - (code = datum); and (iii) the Rogers/Kleene quine — the self-reproducing fixed point — lives on that - locus: for any computable transformation `f` there is a fixed-point code `c` (`eval (f c) = eval c`) - whose self-application configuration is swap-fixed. The computability realization of the POLE EXCHANGE; - the snap-as-instance reading is ZP-Q's conjecture, not established here (no snap transition appears in - this statement). -/ +/-- `Statement:` INVERSION — the code↔data frame-change is (i) an involution; (ii) its fixed locus is + exactly the self-application diagonal; (iii) for any computable `f` some code `c` has + `eval (f c) = eval c` and a swap-fixed self-configuration, as every code's is + (`selfConfig_on_fixedLocus`): (iii)'s content is the existence of `c`, not its position. + `Reading:` INVERSION — the computability realization of the POLE EXCHANGE; the snap-as-instance + reading is ZP-Q's conjecture, not established here (no snap transition appears in this statement). -/ theorem codedata_is_frameflip : Function.Involutive codeDataSwap ∧ (∀ p : ℕ × ℕ, codeDataSwap p = p ↔ p.1 = p.2) diff --git a/ZeroParadox/Computability/ComputableCrossing.lean b/ZeroParadox/Computability/ComputableCrossing.lean index 86c2d70f..d3c9a587 100644 --- a/ZeroParadox/Computability/ComputableCrossing.lean +++ b/ZeroParadox/Computability/ComputableCrossing.lean @@ -31,7 +31,7 @@ open Nat.Partrec Nat.Partrec.Code /-! ## § I. The obstruction is absent in the computable world -/ /-- `Statement:` a fixed point **up to `eval`** — `∃ c, eval (f c) = eval c` (Rogers). - ⚠ NOT literal: `fun c => Code.pair c c` fixes nothing, so this is not the dual of + ⚠ NOT literal: `Code.pair c c` fixes nothing (`code_pair_diag_fixedPointFree`), so this is not the dual of `reflexive_object_refuted`. Argument: `ZeroParadox/Computability/ComputableCrossing.md`. -/ theorem computable_fixedpoint_up_to_eval {f : Code → Code} (hf : Computable f) : ∃ c : Code, eval (f c) = eval c := diff --git a/ZeroParadox/Computability/ComputableCrossing.md b/ZeroParadox/Computability/ComputableCrossing.md index 7101e9ae..86039888 100644 --- a/ZeroParadox/Computability/ComputableCrossing.md +++ b/ZeroParadox/Computability/ComputableCrossing.md @@ -14,7 +14,7 @@ function space — and Set refutes it (`reflexive_object_refuted`, complete lattices the monotone/domain regime has no fixed-point-free MONOTONE endomap (Knaster–Tarski), which removes the monotone witness only. This records a regime where the obstruction is absent up to `eval`, which the framework already contains: the **computable** regime -(literally fixed-point-free computable maps still exist, `Code.pair c c` below). +(literally fixed-point-free computable maps still exist, `Code.pair c c` below, `code_pair_diag_fixedPointFree`). ## Why the computable regime crosses it @@ -25,15 +25,16 @@ The universal machine `eval : Code → (ℕ →. ℕ)` is point-surjective onto ⚠ **THAT IS WEAKER THAN "no fixed-point-free total computable endomap", AND THE STRONG FORM IS FALSE.** `fun c => Code.pair c c` is total, computable, and has no fixed point anywhere — pairing a code with -itself always makes it structurally larger. Rogers is an equality **under the `eval` quotient**: two +itself always makes it structurally larger (`code_pair_diag_fixedPointFree`, +`ZeroParadox/Category/Lawvere.lean`). Rogers is an equality **under the `eval` quotient**: two different programs computing the same function. ⚠ **So this is NOT the exact dual of `reflexive_object_refuted`**, which consumes *literal* `f x ≠ x` — a precondition the witness above satisfies. The conclusion (Lawvere fires in the computable category) still holds, for a reason about **which maps exist**, not about which types they land in: `no_computable_evalFixedPointFree` shows no computable self-map on codes is eval-fixed-point-free, so -the diagonal that would refute the witness has no computable representative and the obstruction cannot -fire. The obstruction is absent **at the level of `eval`**, which is the level the reflexive object +up to `eval` the diagonal that would refute the witness has no computable representative and the +obstruction cannot fire (under literal equality it fires, by `Code.pair c c` above). The obstruction is absent **at the level of `eval`**, which is the level the reflexive object lives at. ⚠ **NOT because `eval` lands in a different codomain.** That reading is refuted in one line — diff --git a/ZeroParadox/Computability/ComputationCannotBe.lean b/ZeroParadox/Computability/ComputationCannotBe.lean index 77ac7dd1..45ad50c4 100644 --- a/ZeroParadox/Computability/ComputationCannotBe.lean +++ b/ZeroParadox/Computability/ComputationCannotBe.lean @@ -36,8 +36,9 @@ section ComputationCannotBeIndex -- Statement: for any `g : A → (A → Bool)`, `¬ Function.Surjective g`. Proved from -- `lawvere_fixedpoint` and `bool_not_no_fixedpoint` — the Cantor/Lawvere no-surjection fact. --- Reading: the halting wall. Turing (1936) enters at the NEXT entry, --- `self_halting_undecidable`; this declaration mentions no machine and no halting. +-- Reading: the halting wall. The halting problem, conventionally credited to Turing (1936; that +-- paper was not consulted here), enters at the NEXT entry, `self_halting_undecidable`; this +-- declaration mentions no machine and no halting. #check @ZeroParadox.no_self_decider -- Statement: `fun c => (eval c (encode c)).Dom` is not a ComputablePred. @@ -49,7 +50,8 @@ section ComputationCannotBeIndex -- Statement: no computable map is EVAL-fixed-point-free — `eval (g c) ≠ eval c` cannot hold for -- every c. ⚠ LITERAL fixed-point-freeness is a different property and DOES occur on codes: --- `fun c => Code.pair c c` fixes nothing. The qualifier is in the declaration's own name. +-- `fun c => Code.pair c c` fixes nothing (`code_pair_diag_fixedPointFree`, +-- `ZeroParadox/Category/Lawvere.lean`). The qualifier is in the declaration's own name. #check @ZeroParadox.no_computable_evalFixedPointFree -- Statement: on `List Bool`, `partialAddOne w = w ↔ w = []` (`ZeroParadox/Category/LawvereTwoAdic.lean`); @@ -139,7 +141,8 @@ example (k : ℕ) : ZeroParadox.IsComputationalQuine (Nat.Partrec.Code.const k) #check @ZeroParadox.selfPrints_universal_address -- Statement: a disjunctive tape `ℕ → Bool` equals its own shift by no `a > 0`: no full copy of --- itself at any offset. +-- itself at any offset. "Copy" here is a tape equal to its own shift, not a `SelfCopyRef` +-- map (§ IX). -- Reading: the ⊥-role commitment this bears on, with both sides stated, is -- `ZeroParadox/Information/Disjunctive.lean` § VI. #check @ZeroParadox.disjunctive_not_periodic @@ -157,25 +160,52 @@ example (k : ℕ) : ZeroParadox.IsComputationalQuine (Nat.Partrec.Code.const k) -- Statement: under `[KleeneStructure L]`, any Quine atom `q : L` equals `bot` of the `ZPSemilattice L`. -- No `Code` and no Kleene clause appear; the `[KleeneStructure]` hypothesis is inert on the proof --- route — though NOT absent from the axiom footprint, since `#print axioms` follows the statement. --- Reading: the tie of the Kleene quine to `bot` of `L` is the `KleeneStructure` commitment, and not --- a Lean `=` (`Code` versus `L`). +-- route — though NOT absent from the axiom footprint: `#print axioms` follows the statement as +-- well as the proof, and the hypothesis reaches `Nat.Partrec.Code.instDenumerable` through +-- `IsComputationalQuine` (`ZeroParadox/Computability/Kleene.md`, Axiom footprint). +-- Reading: the Kleene quine and `bot` of `L` are compared through the die's Quine-atom role +-- (`ZeroParadox/Computability/Kleene.lean` § II, § IX), and not through a Lean `=` (`Code` versus `L` +-- for a generic `L`; the `example`s after `botCode_is_quine`). #check @ZeroParadox.kleene_quine_is_bot -- Statement: the class field — the instance's `botCode` satisfies `IsComputationalQuine`, which the -- constant codes also satisfy (§ III). No field of `KleeneStructure` relates `botCode` to `bot`. --- Reading: that `botCode` is the computational face of `bot` is the `KleeneStructure` commitment. No --- theorem states it, and no `=` can: `botCode` is a `Code` and `bot` an element of `L`. +-- Reading: that `botCode` is the computational face of `bot` was the reading `KleeneStructure` was +-- built for; its identity half is retired and its running half is the occurrence commitment +-- (`ZeroParadox/Computability/Kleene.lean` § II). No theorem states the identity half. For a +-- generic carrier `L` no `=` can: `botCode` is a `Code` and `bot` an element of `L` (the first +-- `example` below). At `L := Code`, under an assumed instance (none is +-- declared in this corpus), the `=` typechecks (the second). #check @ZeroParadox.KleeneStructure.botCode_is_quine +-- Statement: for a generic `L`, `botCode = bot` is a type mismatch; this fails to compile if it elaborates. +/-- +error: Type mismatch + bot +has type + L +but is expected to have type + Nat.Partrec.Code +-/ +#guard_msgs in +open ZeroParadox ZeroParadox.ZPSemilattice in +example (L : Type) [ZPSemilattice L] [KleeneStructure L] : Prop := + KleeneStructure.botCode (L := L) = (bot : L) + +-- Statement: at `L := Nat.Partrec.Code`, given `ZPSemilattice` and `KleeneStructure` instances on `Code` +-- as hypotheses, the same `=` is a well-typed proposition. +open ZeroParadox ZeroParadox.ZPSemilattice in +example [ZPSemilattice Nat.Partrec.Code] [KleeneStructure Nat.Partrec.Code] : Prop := + KleeneStructure.botCode (L := Nat.Partrec.Code) = (bot : Nat.Partrec.Code) + -- Statement: `IsQuineAtom (bot : MachinePhase)` — c₀, ⊥ of `MachinePhase`, is its unique -- self-containing state. Mentions no `Code` and no execution. `machinePhaseAFA` defines -- `selfMem x := x = bot`, so the statement holds by definition (the term `⟨rfl, fun _ h => h⟩` proves it), and the -- `example` after this theorem in -- `ZeroParadox/Computability/Kleene.lean` proves the same type with no Kleene instance. -- Reading: that c₀ is self-EXECUTING is DA-1's claim. DA-1's precondition is the occurrence --- commitment, which DA-1 consumes; the `KleeneStructure` commitment adds only that `botCode` --- names ⊥ of `MachinePhase`. +-- commitment, which DA-1 consumes; no code is read as naming ⊥ of `MachinePhase` (the identity +-- reading is retired, `ZeroParadox/Computability/Kleene.lean` § II). #check @ZeroParadox.da1_closed_concrete -- Statement: c₀ is a Quine atom of `MachinePhase` AND a state sequence in that carrier starts at c₀ @@ -263,7 +293,9 @@ example {σ : Type*} (f : σ → Option σ) {s t : σ} (h : f s = Option.none) -- Reading: `Occurs` is a static property of a (code, input) pair. #check @ZeroParadox.zero_occurs --- Statement: `fun c => Occurs c n` is not a ComputablePred. Turing (1936) via Mathlib. +-- Statement: `fun c => Occurs c n` is not a ComputablePred, via Mathlib's +-- `ComputablePred.halting_problem`. The halting problem's undecidability is conventionally +-- credited to Turing (1936; that paper was not consulted here). #check @ZeroParadox.occurrence_undecidable -- Statement: occurrence is an REPred; non-occurrence is not. @@ -380,8 +412,8 @@ example {σ : Type*} (f : σ → Option σ) {s t : σ} (h : f s = Option.none) -- onto, with exactly one fixed point. The infinite-to-map direction is proved with -- `Classical.choice` and is not provable in set theory without choice (the `PurityCheck` note in -- `ZeroParadox/Computability/SelfCopyReference.lean`). --- Reading: SCOPE. This is the existence of such a map, not that one is applied. That ⊥ on an --- infinite carrier performs one is a commitment (`ZeroParadox/Computability/SelfCopyReference.lean` +-- Reading: SCOPE. This is the existence of such a map, not that one is applied. That ⊥ of a +-- `ZPSemilattice` whose carrier is infinite performs one is a commitment (`ZeroParadox/Computability/SelfCopyReference.lean` -- § IV); `MachinePhase`, which carries `machinePhaseKleene`, admits none -- (the `example` below). #check @ZeroParadox.infinite_iff_exists_selfCopyRef diff --git a/ZeroParadox/Computability/ComputationCannotBe.md b/ZeroParadox/Computability/ComputationCannotBe.md index f1380fca..32c20aa1 100644 --- a/ZeroParadox/Computability/ComputationCannotBe.md +++ b/ZeroParadox/Computability/ComputationCannotBe.md @@ -33,9 +33,15 @@ load-bearing, the commitment carrying it is named. ## The commitments the glosses name -* **`KleeneStructure`** — that the class's `botCode` is the computational face of `bot`, the bottom of - the `ZPSemilattice L`. The field `botCode_is_quine` supplies only a periodicity condition, which - constant codes meet. +* **`KleeneStructure`** — its identity reading (that `botCode` is the computational face of ⊥ of `L`) is + retired; that ⊥ runs is the occurrence commitment, not a theorem. The field `botCode_is_quine` supplies + only a periodicity condition, which constant codes meet. +* **The self-loop commitment** — whether ⊥ of a `ZPSemilattice`, read as a configuration, self-loops: the + `Reading:` above `loop_unfolds_to_infinity` in `ZeroParadox/Computability/ComputationCannotBe.lean`. +* **The self-copy commitment** — that ⊥ of a `ZPSemilattice` on an infinite carrier performs a self-copy + map: the `Reading:` above `infinite_iff_exists_selfCopyRef`; `ZeroParadox/Computability/SelfCopyReference.lean` § IV. +* **The tape commitment** — the ⊥-role reading of a disjunctive tape: the `Reading:` above + `disjunctive_not_periodic`; `ZeroParadox/Information/Disjunctive.lean` § VI. * **The occurrence commitment** (instantiation occurs) — as stated in `ZeroParadox/Order/Snap.lean`'s Formal Overview, from which, together with DA-1, the snap occurs. T-SNAP holds with nothing moving (`tsnap_holds_but_nothing_moves`). In the computational face the framework reads occurrence as diff --git a/ZeroParadox/Computability/GroundZero.lean b/ZeroParadox/Computability/GroundZero.lean index 7b81554d..eadccdfa 100644 --- a/ZeroParadox/Computability/GroundZero.lean +++ b/ZeroParadox/Computability/GroundZero.lean @@ -34,7 +34,7 @@ variable {σ : Type} (f : σ → Option σ) /-- The step function read as a coalgebra for `X ↦ 1 + X`: halted is a leaf, stepping is a successor whose unique child is the next configuration. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: the connector between Mathlib's `StateTransition`-style step function `σ → Option σ` and the framework's own `natPF_NatListRegime` presentation of the `1 + X` functor. Mathlib carries both sides and no map between them; this is the bridge, and it is where the framework's operational and coalgebraic faces meet. +-- [ZP-CUSTOM] no Mathlib analog | reason: the connector between Mathlib's `StateTransition`-style step function `σ → Option σ` and the framework's own `natPF_NatListRegime` presentation of the `1 + X` functor. Mathlib carries both sides, and a map between them was not located in the Mathlib then pinned (`5450b53`) as of 2026-10-31 (searched: Mathlib files mentioning `StateTransition` together with `PFunctor`, `QPF` or `Coalgebra`, none; `Option` under `Data/PFunctor` and `Data/QPF`, none; one LeanExplore query; nearest neighbour `Computation.corec`, into `Computation α` rather than the QPF `Cofix`); this is the bridge, and it is where the framework's operational and coalgebraic faces meet. def stepCoalg : σ → natPF_NatListRegime.Obj σ := fun s => match f s with | none => ⟨false, fun e => e.elim⟩ @@ -81,8 +81,8 @@ theorem notEL_dest {x : Cofix natPF_NatListRegime.Obj} (h : ¬ EventuallyLeaf x) is a Lean `=` within one type rather than a reading across types. **Prior art:** Escardó's `not-finite-is-∞'` (TypeTopology), proved there from function - extensionality alone; Rutten, TCS 249 (2000) §12 pp. 51–52 for the same bisimulation on the - same carrier. Also `Miniature.lean`'s `enat_fp_iff` in the `WithTop ℕ` presentation. Cited, + extensionality alone; Rutten, TCS 249 (2000), supplies the carrier and the bisimulation + technique (§12 pp. 51–52, applied there to arithmetic laws, not to this uniqueness). Also `Miniature.lean`'s `enat_fp_iff` in the `WithTop ℕ` presentation. Cited, not claimed. -/ theorem notEL_unique (x : Cofix natPF_NatListRegime.Obj) (h : ¬ EventuallyLeaf x) : x = natInfinity := by @@ -162,8 +162,10 @@ theorem tri_idle_never_starts (s : Unit) : simp [TriStepping] at hstep /-- **The gauge, both halves in one statement.** Two-valued: the unstarted state is absent from - the type. Three-valued: it is inhabited. So what makes execution forced is the CLEANNESS OF - THE SPLIT, not the dynamics. -/ + the type. Three-valued: it is inhabited. So what removes the unstarted state is the + CLEANNESS OF THE SPLIT, not the dynamics. Nothing here forces execution: a configuration + with no unstarted state still halts or steps, and a self-loop counts as stepping while + changing nothing (`loop_is_a_trap`, `ZeroParadox/Computability/Occurrence.lean`). -/ theorem forcing_needs_the_binary_split : (∀ (σ : Type) (f : σ → Option σ) (s : σ), ¬ (f s ≠ none ∧ ¬ ∃ s', f s = some s')) ∧ (∃ (g : Unit → TriStep Unit) (s : Unit), ¬ TriHalted g s ∧ ¬ TriStepping g s) := @@ -179,7 +181,7 @@ point of the next-time operator is everything). `stepCoalg` above already reads **⚠ PRIOR ART — AMM DO THIS CASE THEMSELVES. The delta here is the FORMALIZATION, not the specialization.** An earlier draft credited only their Ex 4.5(1) (powerset/graph) and called § V "the deterministic specialization of that". That understated them. **Read the paper, not a copy of it** — -`.claude-local/papers/adamek_milius_moss_wellfounded_recursive_coalgebras.pdf`, at these locators: +Adámek, Milius and Moss, *On Well-Founded and Recursive Coalgebras*, arXiv:1910.09401v2, at these locators: | AMM | what is there | what it covers here | |---|---|---| diff --git a/ZeroParadox/Computability/GroundZero.md b/ZeroParadox/Computability/GroundZero.md index 03eec75a..4a1a5193 100644 --- a/ZeroParadox/Computability/GroundZero.md +++ b/ZeroParadox/Computability/GroundZero.md @@ -1,6 +1,6 @@ # GroundZero — ride-along documentation -Moved from `ZeroParadox/Computability/GroundZero.lean`. ⚠ **This content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED. Moving it changes that by exactly nothing.** Its claims are unverified until a claim review says otherwise. +Moved from `ZeroParadox/Computability/GroundZero.lean` on 2026-10-13. ⚠ **At the move this content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED, and moving it changed that by exactly nothing.** The text has been edited since the move; this banner records its state on 2026-10-13 and does not record whether any review has taken place since. In the sections below, "this file", "here" and every bare § number refer to `ZeroParadox/Computability/GroundZero.lean`. @@ -15,8 +15,8 @@ which is cited there to Jacobs & Rutten (EATCS Bulletin 62, 1997). **What it establishes.** Reading a step function as a coalgebra, every configuration is a leaf (halted) or a successor (stepping) — the head is `Bool`, so "exists but has not begun" is not merely unproved, it is *not expressible* (§ I, axiom-free). And the behaviour that never reaches -a leaf is **unique**: it is `natInfinity` (§ II, `notEL_unique`). So that non-terminating behaviour, `natInfinity`, -is pinned by a purely negative description — by what it never does — with no element-hood in any +a leaf is **unique**: it is `natInfinity` (§ II, `notEL_unique`). So that non-terminating +behaviour is pinned by a purely negative description — by what it never does — with no element-hood in any machine carrier assumed. A self-looping configuration unfolds to exactly that point (§ III). **Why this shape matters.** The framework's other apophatic characterization with uniqueness is @@ -35,17 +35,21 @@ itself and hence never terminates"*; Ex. 10.2(4) p. 44 for `(ℕ̄, pred)` final **bisimulation technique on that carrier** at §12 pp. 51–52, where it is applied to arithmetic laws (addition of naturals and its commutativity), *not* to this uniqueness statement. (Corrected 2026-07-29: an earlier revision said §12 ran "this exact bisimulation on this exact carrier" — the -technique and carrier are his, the application is not.) Mathlib itself has no `Conat` and no such -lemma, so the Lean formalization is a genuine small addition — the mathematics is not. +technique and carrier are his, the application is not.) No `Conat` type and no such uniqueness +lemma on one were located in the Mathlib then pinned (`5450b53`) as of 2026-10-31, searched as follows: grep +of Mathlib for `Conat`, `CoNat` and `coNat` (none), and one LeanExplore query for coinductive naturals +with infinity as the successor's fixed point (none). So the Lean formalization is a small addition; the +mathematics is not new. **And the framework already had it, in another dress:** `Miniature.lean`'s `enat_fp_iff : x + 1 = x ↔ x = ⊤` is this same fact in the `ℕ∞ = WithTop ℕ` presentation. **What is NOT claimed.** That ⊥ of a `ZPSemilattice`, read as a configuration of a step function, -*is* such a behaviour remains a modelling commitment (the reading is glossed at the -`loop_unfolds_to_infinity` entry of `ZeroParadox/Computability/ComputationCannotBe.lean` § VIII) — -the results here are conditional on non-termination, and say nothing about whether that ⊥ -non-terminates. Nothing here makes the snap occur: occurrence is still +self-loops, and so unfolds to `natInfinity`, the behaviour that never reaches a leaf (§ II), remains +a modelling commitment (glossed at the `loop_unfolds_to_infinity` entry of +`ZeroParadox/Computability/ComputationCannotBe.lean` § VIII). The self-loop is the stronger of +the two: a self-loop implies non-termination, not conversely. The results here are conditional +on non-termination, and say nothing about whether that ⊥ non-terminates. Nothing here makes the snap occur: occurrence is still the halting problem (`occurs_iff_halts`, `occurrence_undecidable`). And the mathematics is not new — the final coalgebra of `X ↦ 1 + X` being `ℕ ∪ {∞}` is standard (Jacobs, *Introduction to Coalgebra*, Ex. 2.4.1 p. 66). **Note the scope of that citation:** Jacobs supports the *object*, @@ -65,3 +69,4 @@ coalgebra. - § II The apophatic characterization, and its UNIQUENESS - § III The bridge: a self-looping configuration unfolds to `natInfinity` - § IV NO-GO gauge: the forcing needs the binary split (a three-valued counter-model) +- § V The well-founded coalgebra is the halting condition diff --git a/ZeroParadox/Computability/Kleene.lean b/ZeroParadox/Computability/Kleene.lean index 0820539c..f0a6d00d 100644 --- a/ZeroParadox/Computability/Kleene.lean +++ b/ZeroParadox/Computability/Kleene.lean @@ -29,8 +29,10 @@ why I keep coming back to it. ## Formal Overview For `q` in a `ZPSemilattice L` with `KleeneStructure L`, T-COMP (`t_comp`, proof term `t_exec_triple_iff`): Quine atom ↔ (`q = bot` ∧ join identity); `da2_bottom_characterization` makes the last two equivalent. -`botCode_is_quine` is a requirement; reading `botCode` as the computational face of ⊥ of `L` is the -commitment. Footprints: `ZeroParadox/Computability/Kleene.md`. +`botCode_is_quine` is a requirement. No code is equated with ⊥ of `L`: under the `eval` step no +single code occupies the die's Quine-atom role, and for computable `eval`-respecting maps a class of +codes up to equal `eval` does (§ IX-b); that ⊥ executes is the +occurrence commitment. Footprints: `ZeroParadox/Computability/Kleene.md`. -/ namespace ZeroParadox @@ -123,9 +125,10 @@ theorem computational_quine_exists : ∃ c : Code, IsComputationalQuine c := identification unstatable. Uniqueness in ZP-K is inherited from ZP-J (set-theoretic side via T-EXEC): any element satisfying IsQuineAtom equals ⊥ — this is kleene_quine_is_bot. - The framework reads the computational witnesses (botCode) as naming ⊥. That reading - is the KleeneStructure commitment; it is not established by behavioral equality of - codes, and it is not a Lean identity — see the type-boundary note above. -/ + No code (botCode included) is read as naming ⊥: each code chart has its own + occupancy of the die's Quine-atom role, step by step (§ IX, § IX-b), and no Lean identity between a code and + ⊥ is stated — see the type-boundary note above. That ⊥ executes is the occurrence + commitment, not established by behavioral equality of codes. -/ /-! ## § II. KleeneStructure — Bridging Computation and AFA -/ @@ -133,21 +136,26 @@ theorem computational_quine_exists : ∃ c : Code, IsComputationalQuine c := What the class's fields assert, and that none relates `botCode` to `bot`: the `KleeneStructure.botCode_is_quine` entry of `ZeroParadox/Computability/ComputationCannotBe.lean` § IV. -The `example` after `machinePhaseKleene` (§ V) is an instance with `botCode := Code.const 0`. So the -identification is the KleeneStructure commitment, not data the class carries, and -`da1_closed_concrete`, which proves `IsQuineAtom (bot : MachinePhase)` and nothing computational, does -not establish it. The form for carrying a commitment as an explicit hypothesis: `CLAUDE.md` § R-COMMIT. -/ +The `example` after `machinePhaseKleene` (§ V) is an instance with `botCode := Code.const 0`. So the class carries no +identification, and none is committed to: the identity reading is retired in favour of per-chart +occupancy (§ IX), and `da1_closed_concrete`, which proves `IsQuineAtom (bot : MachinePhase)` and nothing +computational, does not supply one. The form for carrying a commitment as an explicit hypothesis: +`CLAUDE.md` § R-COMMIT. -/ /-- A ZP-A semilattice has KleeneStructure if it carries an AFAStructure and additionally names a `Code` satisfying `IsComputationalQuine`. - **The identification it is built for is the framework's COMMITMENT, and no field - asserts it:** that the AFA Quine atom and the Kleene computational quine name the same - structural property — the reading "botCode is the code that IS its own program, - the universal Turing machine in ground state, and this is the computational - expression of `bot_self_mem`". Nothing in this file derives that identification, - and nothing could state it as an equation: `botCode` is a `Code` and `bot` is an - element of `L`, so no `=` exists between them. + **The reading it was built for splits in two, and no field asserts either half:** that + `botCode` is ⊥'s computational witness — "botCode is the code that IS its own program, the + universal Turing machine in ground state, and this is the computational expression of + `bot_self_mem`". Its IDENTITY half is retired: no code is equated with ⊥, and each code chart + has its own occupancy of the die's Quine-atom role `Motion.SelfOnlyAt`, step by step — no single + code under `evalStepMotion F` for any `F` (`evalStepMotion_not_selfOnlyAt`), a class of codes up + to equal `eval` in the quotient, for computable `eval`-respecting maps (`codes_vs_classes`). Its RUNNING + half stays a commitment: that ⊥ actually executes is the occurrence commitment. + For a generic `L` no Lean `=` between `botCode` (a `Code`) and `bot` (an element of `L`) + typechecks; at `L := Code` one does: the `example`s after `KleeneStructure.botCode_is_quine` + in `ZeroParadox/Computability/ComputationCannotBe.lean` § IV. Three things to keep in view when relying on this class: * `botCode_is_quine` requires only `IsComputationalQuine`, a *periodicity* @@ -158,39 +166,41 @@ not establish it. The form for carrying a commitment as an explicit hypothesis: no content beyond the inherited field. * The AFA side has exactly one self-containing element (`quine_unique`); the computational side has infinitely many fixed points (`infinite_quine_family`). - The commitment relates a unique element to a family, and § VI says what that - family is. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: Bridges AFAStructure (set-theoretic self-containment) with Mathlib's computability library (Nat.Partrec.Code). No Mathlib typeclass connects AFA and Code. KleeneStructure is built for the reading that the AFA Quine atom and the Kleene computational Quine (∃ c, eval c = f c) name the same structural property — this identification is the motivating commitment, not a derived theorem, and no field asserts it. + No identity relates the unique element to the family; § VI says what that family + is. -/ +-- [ZP-CUSTOM] no Mathlib analog | reason: Bridges AFAStructure (set-theoretic self-containment) with Mathlib's computability library (Nat.Partrec.Code). A Mathlib typeclass connecting AFA and Code was not located in the Mathlib then pinned (5450b53) as of 2026-11-05, searched by grep of Mathlib/ for "AFA", "anti-foundation", "Aczel" and "hyperset" (no AFA development found at all). KleeneStructure was built for the reading that botCode is ⊥'s computational witness; no field asserts it, its identity half is retired (no code is equated with ⊥), and its running half, that ⊥ executes, is the occurrence commitment. The AFA Quine atom and the Kleene computational Quine (`IsComputationalQuine`, § I) are compared through the die's Quine-atom role (§ IX), not through an identity: no single code occupies it under `evalStepMotion F` for any F (`evalStepMotion_not_selfOnlyAt`); a class of codes up to equal eval does, for computable eval-respecting maps (`codes_vs_classes`); and a self-printing universal code does under `selfPrintsStepMotion selfPrintOrDelegate` (`exists_selfPrintsStepMotion_selfOnlyAt`). class KleeneStructure (L : Type*) [ZPSemilattice L] extends AFAStructure L where - /-- The code the framework nominates as ⊥'s computational witness. Nothing here - distinguishes it: it is whatever code the instance supplies. -/ + /-- A code the instance supplies. Nothing here distinguishes it, and no equation relates it + to ⊥ of `L` (the identity reading is retired, class docstring). -/ botCode : Code /-- botCode satisfies `IsComputationalQuine` — a periodicity condition, which constant codes also satisfy (`hconst_quine`, a `have` inside `infinite_quine_family`, § VI). Reading it as "the computational - expression of bot_self_mem" is the KleeneStructure commitment, not a consequence of this - field. -/ + expression of bot_self_mem" is not a consequence of this field, and the identity half of + that reading is retired (class docstring). -/ botCode_is_quine : IsComputationalQuine botCode /-- Restates the inherited `AFAStructure` field `bot_self_mem`; it records the intent of the bridge and adds no content beyond what `extends AFAStructure L` already supplies. - The intended reading — ⊥ = {⊥} in set theory alongside - eval botCode = selfApply botCode in computation — is the commitment. The two are - not equated and cannot be: one is about an element of `L`, the other about a - `Code`. -/ + The intended reading set `selfMem bot` beside `eval botCode = selfApply botCode`; + the two are not equated: one is about an element of `L`, the other about a `Code` (when an `=` + between them typechecks: `ZeroParadox/Computability/ComputationCannotBe.lean` § IV). -/ bot_self_mem_from_kleene : AFAStructure.selfMem (bot : L) -/-! ## § III. T-COMP — the three-way equivalence, and where the fourth face sits -/ +/-! ## § III. T-COMP and `da2_bottom_characterization` — the three-way equivalence, and where the +fourth face sits -/ /-- T-COMP (Computational Grounding Theorem): - In any KleeneStructure lattice, **three** characterisations of the null ground - element are proved equivalent: + In any KleeneStructure lattice, **three** characterisations of ⊥ of `L` are proved + equivalent by this theorem together with `da2_bottom_characterization`: (1) Quine atom — IsQuineAtom q (AFA self-containment, set-theoretic) (2) Bottom — q = ⊥ (order-theoretic minimum) (3) Join identity — ∀ x, q ∨ x = x (algebraic generator) - **Honest fence.** Lean proves (1) ↔ (2) ↔ (3), and that is the whole content of - this statement — the proof term is literally `t_exec_triple_iff`, a ZP-J result - that does not mention computation. The fourth characterisation, + **Honest fence.** This statement is (1) ↔ ((2) ∧ (3)), and the proof term is literally + `t_exec_triple_iff`, a ZP-J result that does not mention computation. (2) ↔ (3) is a + second theorem, `da2_bottom_characterization` (`ZeroParadox/Order/Snap.lean`); the + three-way equivalence is the two together (the `example` after this theorem). The fourth + characterisation, (4) Kleene fixed point — computational self-reference, @@ -211,16 +221,23 @@ theorem t_comp {L : Type*} [ZPSemilattice L] [KleeneStructure L] (q : L) : IsQuineAtom q ↔ q = bot ∧ ∀ x : L, join q x = x := t_exec_triple_iff q +-- `Statement:` the three-way equivalence, pairwise: (1) ↔ (2) is `t_exec_iff`, (3) ↔ (2) is +-- `da2_bottom_characterization`; `t_comp` alone gives (1) ↔ ((2) ∧ (3)). +example {L : Type*} [ZPSemilattice L] [KleeneStructure L] (q : L) : + (IsQuineAtom q ↔ q = bot) ∧ ((∀ x : L, join q x = x) ↔ q = bot) := + ⟨t_exec_iff q, da2_bottom_characterization q⟩ + /-- Any element satisfying the AFA Quine-atom property equals ⊥. **Honest fence.** The statement quantifies over elements of `L` and mentions no computational fixed point; the proof term is `t_exec`, a pure ZP-J result. The `KleeneStructure` hypothesis is inert *on this proof route* — it supplies the `AFAStructure` this inherits from, and nothing else is used. It is not absent from - the axiom footprint, which follows the statement (see the footprint note in - `ZeroParadox/Computability/Kleene.md`). That the Kleene fixed point and the AFA Quine atom - "identify the same element" is the class's motivating commitment (header, § II), - not what this theorem shows. -/ + the axiom footprint, which follows the statement as well as the proof (see the footprint note in + `ZeroParadox/Computability/Kleene.md`). No equation relates `botCode` to this + element (the identity reading is retired, § II); under the `eval` step no single code + occupies the die's Quine-atom role, and for computable `eval`-respecting maps a class of + codes does (`codes_vs_classes`, § IX-b). -/ theorem kleene_quine_is_bot {L : Type*} [ZPSemilattice L] [KleeneStructure L] (q : L) (hq : IsQuineAtom q) : q = bot := t_exec q hq @@ -244,7 +261,7 @@ theorem roger_fixed_point_exists (f : Code → Code) (hf : Computable f) : them. Nothing computational appears in the statement or the proof. The reading "if ⊥ executes at all, it is its own executor" (ZP-E, DA-1 Path 1) is the - framework's interpretation of `bot_self_mem` under the KleeneStructure commitment. + framework's interpretation of `bot_self_mem`. That the configuration reaching P₀ is running is the occurrence commitment, which DA-1 consumes (ZP-E). Neither is a separate Lean theorem. -/ theorem da1_computational {L : Type*} [ZPSemilattice L] [KleeneStructure L] : @@ -290,22 +307,22 @@ theorem description_instantiation_gap_closed {L : Type*} [ZPSemilattice L] /-! ## § V. MachinePhase — the Concrete Lean Counterpart of DA-1's Path 1 -Provides AFAStructure and KleeneStructure instances for ZP-E's MachinePhase type, -the Lean counterpart of DA-1's Path 1 for ZP-E's MachinePhase model. - -selfMem is modelled as equality with bot — the CIC-compatible expression of AFA -self-containment ⊥ = {⊥}. Anti-foundation is not required at the typeclass level: -the relevant structural fact (bot is the unique self-containing element) is -captured by the definition selfMem x := x = bot, proved axiom-free. -/ +AFAStructure and KleeneStructure instances for ZP-E's MachinePhase model. `Reading:` CARRIER — +selfMem x := x = bot is the shadow of the Quine atom (CC-2) on a two-element carrier, not the +literal x = {x}, which is refuted in Mathlib's `ZFSet` (the `example` after `no_quine_atom` in +`ZeroParadox/Settheory/Wall.lean`; `zfset_selfOnlyAt_mem_iff` makes it the die's Quine-atom role), and +the role's two charts are `zfset_quine_role_unoccupied` (no set occupies the role) and `cofix_quine_role_occupied` (occupied in the coalgebra chart, +`ZeroParadox/Settheory/Coalgebra.lean`). Anti-foundation is not required at the typeclass level: +the definition makes ⊥ of `MachinePhase` the unique element satisfying `selfMem`, axiom-free. -/ open ZeroParadox ZeroParadox /-- AFAStructure instance for MachinePhase. selfMem x := x = bot (bot = .initial = c₀). - The unique self-containing element is the initial state — the bottom of the - semilattice. This is the CIC encoding of ⊥ = {⊥}: bot is self-containing - and is the only element with this property. -/ --- [ZP-CUSTOM] instance: AFAStructure MachinePhase | reason: selfMem x := x = bot is the CIC-compatible encoding of AFA self-containment (⊥ = {⊥} cannot be stated in Lean's well-founded type theory). Quine uniqueness and bot_self_mem are provable by rfl. This is the concrete Lean counterpart of Path 1 for ZP-E's machine model; DA-1 itself is closed given DP-2 (da1_minimal_path). + The unique element satisfying `selfMem` is the initial state, ⊥ of `MachinePhase`. + This is the shadow of the Quine atom (CC-2), not the literal x = {x}; the Quine-atom + role's two charts are in the § V header. -/ +-- [ZP-CUSTOM] instance: AFAStructure MachinePhase | reason: selfMem x := x = bot is the shadow of AFA self-containment on MachinePhase. The literal x = {x} is statable in Mathlib's well-founded ZFSet and refuted there (no set occupies the die's Quine-atom role, zfset_quine_role_unoccupied, ZeroParadox/Settheory/Wall.lean); the coalgebra chart Cofix idPF_Coalgebra.Obj occupies it (cofix_quine_role_occupied, ZeroParadox/Settheory/Coalgebra.lean). Quine uniqueness and bot_self_mem are provable by rfl. This is the concrete Lean counterpart of Path 1 for ZP-E's machine model; DA-1 itself is closed given DP-2 (da1_minimal_path). instance machinePhaseAFA : AFAStructure MachinePhase where selfMem x := x = bot quine_unique _ _ hx hy := hx.trans hy.symm @@ -317,8 +334,8 @@ instance machinePhaseAFA : AFAStructure MachinePhase where `kleene_fixed_point_exists` (Kleene's second recursion theorem). It is not a distinguished code, and the predicate it satisfies is a periodicity condition that constant codes also meet (§ VI). Reading it as "the code that IS its own program, - the computational expression of ⊥ = {⊥}" is the KleeneStructure commitment, which no - field asserts, not a property this instance establishes. -/ + the computational expression of `bot_self_mem`" is not a property this instance + establishes, and that reading's identity half is retired (§ II). -/ -- [ZP-CUSTOM] instance: KleeneStructure MachinePhase (noncomputable) | reason: botCode chosen via Classical.choose — it names SOME computational quine and not a distinguished one. isComputationalQuine_undecidable says the MEMBERSHIP PREDICATE is not a ComputablePred, which is why nothing can pin down which code was chosen — it does NOT say no algorithm names a witness, and the constant codes are witnesses. The noncomputable marker comes from this instance's choice of botCode; a computable instance with a constant code also satisfies the class, so the noncomputable marker belongs to the instance, not to DA-1's computational path. noncomputable instance machinePhaseKleene : KleeneStructure MachinePhase where botCode := Classical.choose computational_quine_exists @@ -412,7 +429,8 @@ theorem self_halting_undecidable : have φ_eval : ∀ (c : Code) (k : ℕ), eval (Code.comp c (Code.const 0)) k = eval c 0 := by intro c k change eval (Code.const 0) k >>= eval c = eval c 0 - simp [eval_const] + rw [eval_const] + exact Part.bind_some 0 _ -- Compose h (deciding self-halting) with φ to get ComputablePred for halting-at-0 -- Use the same DecidablePred instance w that h carries, composed with φ obtain ⟨w, hdec⟩ := h @@ -462,7 +480,8 @@ theorem isComputationalQuine_undecidable : -- inner comp evaluates to Part.none have hc : eval (Code.comp c (Code.const (Encodable.encode c))) n = Part.none := by show eval (Code.const (Encodable.encode c)) n >>= eval c = Part.none - simp [eval_const, h] + rw [eval_const] + exact (Part.bind_some _ _).trans h -- pair with Part.none first arg evaluates to Part.none have hp : eval (Code.pair (Code.comp c (Code.const (Encodable.encode c))) (Code.pair Code.left Code.right)) n = Part.none := by @@ -479,7 +498,8 @@ theorem isComputationalQuine_undecidable : rw [h, Part.bind_some] have hc : eval (Code.comp c (Code.const (Encodable.encode c))) n = Part.some v := by show eval (Code.const (Encodable.encode c)) n >>= eval c = Part.some v - simp [eval_const, h] + rw [eval_const] + exact (Part.bind_some _ _).trans h -- eval (pair left right) n = Part.some n (definitional: ↑f applies to give Part.some) have h_lr : eval (Code.pair Code.left Code.right) n = Part.some n := by show Nat.pair <$> (Part.some n.unpair.1) <*> (Part.some n.unpair.2) = Part.some n @@ -500,7 +520,8 @@ theorem isComputationalQuine_undecidable : -- outer comp: Part.bind (eval pair n) (eval right) = Part.some n show Part.bind (eval (Code.pair (Code.comp c (Code.const (Encodable.encode c))) (Code.pair Code.left Code.right)) n) (eval Code.right) = Part.some n - rw [hp, Part.bind_some] + rw [hp] + refine (Part.bind_some _ _).trans ?_ show Part.some (Nat.pair v n).unpair.2 = Part.some n simp [Nat.unpair_pair] -- Encoding: encode (φ c) ≠ 0 for all c @@ -639,7 +660,7 @@ theorem fixed_point₂_unbounded {F : Code → ℕ →. ℕ} (hF : Partrec₂ F) have hL : L.getD (Encodable.encode c) Code.zero = d (Encodable.encode c) := by simp [L, List.getD_eq_getElem?_getD, Nat.lt_succ_of_le hN] have hev : eval c = eval (d (Encodable.encode c)) := by - rw [hc]; funext x; simp only [F', hN, decide_true, cond_true, hL] + rw [hc]; funext x; simp only [F', hN, decide_true, Bool.cond_true, hL] have h0 := congrFun hev 0 by_cases hz : eval c 0 = Part.some 0 · have : d (Encodable.encode c) = Code.const 1 := by @@ -860,6 +881,47 @@ theorem exists_selfPrintsStepMotion_selfOnlyAt : have h := selfPrints_universal_of_fixedPoint c hc exact ⟨⟨c, h.1⟩, selfPrintsStepMotion_selfOnlyAt_of_step _ _ hc, h.2⟩ +-- Statement: on codes with UP the identity and OVER `a → b` when `eval a` halts on input `⌜b⌝`, `b`'s +-- Gödel number, `c` steps to itself and to nothing else iff `eval c` halts on input `⌜c⌝` and on +-- no other input; both directions. Reading: OVER is the converse of Rogers' relation `E` +-- (`m E n` iff `m ∈ W_n`) read on codes, `a → b` iff `⌜b⌝ E ⌜a⌝`, and the right side is his unit +-- set `W_m = {m}` in Mathlib's numbering of codes (Rogers 1967, § 11.4, p. 185; prior art, cited). +example (c : Code) : + (Motion.ofTotal id (fun _ => rfl) + (fun a b : Code => (eval a (Encodable.encode b)).Dom)).SelfOnlyAt c ↔ + ∀ n, (eval c n).Dom ↔ n = Encodable.encode c := by + constructor + · rintro ⟨hc, hu⟩ n + refine ⟨fun hn => ?_, fun hn => hn ▸ hc⟩ + have hb := hu (Denumerable.ofNat Code n) (by + show (eval c (Encodable.encode (Denumerable.ofNat Code n))).Dom + rwa [Denumerable.encode_ofNat]) + rw [← hb, Denumerable.encode_ofNat] + · intro h + exact ⟨(h _).2 rfl, fun b hb => Encodable.encode_injective ((h _).1 hb)⟩ + +-- Statement: in that motion infinitely many codes step to themselves only (`fixed_points_infinite`). +-- Reading: Rogers has such a code from the recursion theorem (Rogers 1967, § 11.2, p. 181). Here the +-- occupants are many, where `zfset_quine_role_unoccupied` and `cofix_subsingleton` give none and at +-- most one. +example : {c : Code | (Motion.ofTotal id (fun _ => rfl) + (fun a b : Code => (eval a (Encodable.encode b)).Dom)).SelfOnlyAt c}.Infinite := by + let F : Code → ℕ →. ℕ := fun c n => cond (n == Encodable.encode c) (Part.some 0) Part.none + have hF : Partrec₂ F := + Partrec.cond (Primrec.beq.comp Primrec.snd (Primrec.encode.comp Primrec.fst)).to_comp + (Partrec.const' _) Partrec.none + refine (fixed_points_infinite hF).mono fun c (hc : eval c = F c) => ⟨?_, fun b hb => ?_⟩ + · show (eval c (Encodable.encode c)).Dom + rw [hc]; simp [F] + · have hb' : (eval c (Encodable.encode b)).Dom := hb + rw [hc] at hb' + by_contra hne + have : (Encodable.encode b == Encodable.encode c) = false := by + simpa using fun h => hne (Encodable.encode_injective h) + change (cond (Encodable.encode b == Encodable.encode c) (Part.some 0) Part.none).Dom at hb' + rw [this] at hb' + exact hb' + /-- `Statement:` on inputs, UP `n ↦ n % ⌜c⌝` and OVER `n ↦ ⌜c⌝ + n`, where `⌜c⌝` is `c`'s Gödel number. `Reading:` OVER is the shift in `quine_period_is_goedel`; UP is a choice of this encoding, not forced by it. -/ @@ -1040,7 +1102,8 @@ def padId (c : Code) : Code := Code.comp c Code.id theorem eval_padId (c : Code) : eval (padId c) = eval c := by funext n show eval Code.id n >>= eval c = eval c n - simp [Code.eval_id] + rw [Code.eval_id] + exact Part.bind_some n _ /-- `Statement:` `padId c ≠ c`. -/ theorem padId_ne (c : Code) : padId c ≠ c := by @@ -1103,6 +1166,14 @@ theorem constEnc_two_successors : ⟨Code.zero, _, rfl, rfl, rfl⟩, ⟨padId Code.zero, _, rfl, Quotient.sound haa, rfl⟩, fun h => eval_const_ne hne (Quotient.exact h)⟩ +-- `Statement:` instance search's `Primcodable (Code × ℕ)` is `Primcodable.prod` over +-- `Primcodable.ofDenumerable Code`, whose `Denumerable` argument is `Nat.Partrec.Code.instDenumerable` +-- (by `rfl`): the route `ZeroParadox/Computability/Kleene.md` § VIII describes. The footprints of +-- both are printed below. +example : (inferInstance : Primcodable (Nat.Partrec.Code × ℕ)) = + @Primcodable.prod Nat.Partrec.Code ℕ + (@Primcodable.ofDenumerable Nat.Partrec.Code Nat.Partrec.Code.instDenumerable) _ := rfl + end ZeroParadox /-! ## Axiom Purity Check -/ diff --git a/ZeroParadox/Computability/Kleene.md b/ZeroParadox/Computability/Kleene.md index 5926715c..6b936ef5 100644 --- a/ZeroParadox/Computability/Kleene.md +++ b/ZeroParadox/Computability/Kleene.md @@ -16,12 +16,23 @@ Relates four structural roles of ⊥, of which three are proved equivalent: (3) Join identity — algebraic generator (ZP-A A4) (4) Kleene fixed point — computational self-reference (Mathlib: fixed_point₂) -The central result (T-COMP) establishes (1) ↔ (2) ↔ (3) via T-EXEC. Its proof term is -`t_exec_triple_iff`, a ZP-J result that does not mention computation; ⊥ is then the -element those three pick out. **(4) is not a clause of that theorem** — it is present -by typeclass requirement, as the class field `botCode_is_quine`. Reading (1)–(4) -as naming the same structural role in four formal languages is the motivating commitment -of the KleeneStructure typeclass; no field asserts it, and no theorem derives it. Note the two +The central result (T-COMP) establishes (1) ↔ ((2) ∧ (3)) via T-EXEC. Its proof term is +`t_exec_triple_iff`, a ZP-J result that does not mention computation; (3) ↔ (2) is a second +theorem, `da2_bottom_characterization` (`ZeroParadox/Order/Snap.lean`), and the two together make +the three pairwise equivalent (the `example` after `t_comp`); ⊥ is then the element those three +pick out. **(4) is not a clause of that theorem** — it is present +by typeclass requirement, as the class field `botCode_is_quine`. The KleeneStructure typeclass +was motivated by reading (1)–(4) as naming the same structural role in four formal languages. That +reading splits in two. Its identity half is retired: no code is equated with ⊥, and (4) is compared +with (1)–(3) through the die's Quine-atom role, which under the `eval` step no single code occupies +and, for computable `eval`-respecting maps, a class of codes does (Key insight, below). Its running +half stays a commitment: that ⊥ actually executes is the occurrence commitment. No field asserts +either half, and no theorem in this corpus relates `botCode` to `bot` (not located as of +2026-11-01, searched as follows: `ZeroParadox/**/*.lean` for `botCode`, for `KleeneStructure`, and +for "computational face" / "same structural"; no hit states a relation between `botCode` and +`bot`). For a generic carrier `L` no Lean `=` between them typechecks, since `botCode` is a `Code` +and `bot` an element of `L`; at `L := Code`, under an assumed instance (none is declared in this +corpus), one does (`ZeroParadox/Computability/ComputationCannotBe.lean` § IV, the two `example`s). Note the two sides also differ in shape: (1)–(3) pick out a unique element, while the computational fixed points form an infinite family (§ VI). @@ -38,26 +49,77 @@ fixed points form an infinite family (§ VI). ## Key insight (April 26, 2026) -This is the framework's reading, and it is a commitment throughout — no theorem in this -file establishes it. On that reading, ⊥ in the computational instantiation (ZP-C D7) is -not a state OF a Turing machine: ⊥ IS the universal Turing machine in its ground state, -and U is not a description awaiting an external executor but IS the executor. +The reading this insight recorded was that ⊥ in the computational instantiation (ZP-C D7) is +not a state OF a Turing machine but the universal Turing machine U in its ground state, and that +U is not a description awaiting an external executor but its own executor. No theorem in this +file establishes it, and it splits in two. Its identity half (that ⊥ IS a particular machine or +code) is retired, below. Its running half splits again: that ⊥ actually executes is the +occurrence commitment; that, if it executes, nothing outside it is the executor is DA-1's Path 1 +reading (ZP-E § IV), which rules out an external executor and not an inert ⊥. What Lean supplies underneath: Kleene's second recursion theorem (Mathlib: Nat.Partrec.Code.fixed_point₂) guarantees a fixed point exists for any partially -computable transformation. The KleeneStructure typeclass is built for the reading that the AFA -Quine atom (⊥ = {⊥}) and the Kleene computational quine (∃ c, eval c = f c) are the same -structural property. That identification is the motivating commitment, asserted by no field -of the class and not a theorem proved here, and it is ill-typed as an equation — `Code` and `L` are different -types. +computable transformation. The AFA Quine atom (CC-2, a set x = {x}) and the Kleene computational +quine (`IsComputationalQuine c`, that is `eval c = selfApply c`) are compared through a role, not +an identity: the die's Quine-atom role `Motion.SelfOnlyAt` (`ZeroParadox/Die.lean`), a point that +steps to itself and to nothing else, occupied or provably empty chart by chart. On codes, with OVER `a → b` when `eval b = F a`, no +code occupies it for any `F : Code → ℕ →. ℕ` (`evalStepMotion_not_selfOnlyAt`); on classes of +codes up to equal `eval`, in the quotient of `evalStepMotion (eval ∘ G)`, some class does for +computable `eval`-respecting `G : Code → Code` (`codes_vs_classes`); restricted to +self-printing codes, with `F` the map `selfPrintOrDelegate`, some self-printing universal code does +(`exists_selfPrintsStepMotion_selfOnlyAt`). +The set-side charts are in `ZeroParadox/Settheory/Wall.lean` (no `ZFSet` occupies it) and +`ZeroParadox/Settheory/Coalgebra.lean` (a coalgebra point does). No equation across `Code` and `L` +is stated; one would be ill-typed. So the reading that the class's `botCode` is ⊥'s computational +witness keeps no identity half: each code chart has its own occupancy, step by step, as above. What stays a +commitment is that ⊥ actually executes, the occurrence commitment. + +**Prior art for relating hyperset fixed points to self-application** (closest located as of +2026-11-03). Barwise & Moss 1996, *Vicious Circles*, § 3.4, pp. 42-43: they review Kleene's +recursion theorem (Theorem 3.2, p. 43), derive from it a program of no inputs that outputs itself +(Proposition 3.3, p. 43), and write that "there may be applications of the techniques of this book to +the semantical issues raised by self-application" (p. 42). They write that computability theory does +not depend on set theory "in any essential way" (p. 42), footnote 5 excepting the semantics of +computation, where one might choose non-well-founded sets. In Chapter 20 (Proposition 20.1 and the application +after it, pp. 313-314), in a setting that assumes a strongly inaccessible cardinal κ (p. 312), they use +a version of the Recursion Theorem, for self-sufficient sets of formulas (their Theorem 5.1, p. 62), +then the uniqueness part of AFA, to show that each set has a name, a code in the class notation +system of a self-sufficient set of formulas (p. 313). On those pages they state no comparison of a set-side occupant with a +code-side one, so the role comparison above is not credited to them. Searched as follows: the book's +index and contents, § 3.4 and Chapter 20 pp. 311-315 (scans), theoremsearch (three phrasings), +LeanExplore, GitHub code search and the open web. + +**Prior art for a code-side self-singleton** (cited, not claimed). Rogers 1967, § 11.4, "First +Illustration", p. 185: with `m E n` when `m ∈ W_n` (`W_n` the set of inputs on which code `n` halts), he notes +"a rough analogy" between `E` and set membership and asks whether a unit set `W_m = {m}` exists, +answered yes from § 11.2 (the example after Corollary I, p. 181, by the recursion theorem). The same +page builds an infinite ascending chain of unit sets; his Theorem 11-VII, p. 186, gives an infinite +descending one, distinct `m_0, m_1, ...` with `W_{m_i} = {m_{i+1}}`; and his Exercise 11-24, p. 215, asks for +distinct `m`, `n` with `m ∈ W_n` and `n ∈ W_m`. His footnote, p. 185: for `E`, pairing, sum, choice +and infinity hold, and power, extensionality and foundation fail; the non-recursive-enumerability of +the complement of `K` "can be viewed as a counterpart to the Russell paradox". This is a further code +chart beside those above, with OVER `a → b` when `eval a` halts on input `⌜b⌝`, `b`'s Gödel number, the converse +of `E` (`a → b` iff `⌜b⌝ E ⌜a⌝`): there a code steps to itself only exactly when it is Rogers' unit +set `W_m = {m}` (read in Mathlib's numbering of codes), and infinitely many codes +do (the two `example`s after `exists_selfPrintsStepMotion_selfOnlyAt`). Prior art for the infinitely +many, cited: Rogers' Theorem 11-IV (Kleene), p. 182, whose fixed-point function is one-one and +which combines his strengthenings (1)-(3) of p. 181, the third being "for any `f`, an infinite set of +fixed-point values can be recursively enumerated"; applied to the `f` of his example on p. 181, +`W_{f(x)} = {x}`, it gives infinitely many `m` with `W_m = {m}`. That application is ours; we did not +locate it in Rogers (Ch. 11 pp. 179-189, 192-196 and Exercises pp. 213-215 read, 2026-11-03). That +chart is not the `eval`-step chart, where no single code occupies the role, nor the class chart. ## Dependencies -ZP-J (T-EXEC: IsQuineAtom q ↔ q = ⊥, bot_self_mem). +ZP-J (T-EXEC, `t_exec`: IsQuineAtom q → q = ⊥, one direction; the biconditional is `t_exec_iff`, +`ZeroParadox/Settheory/SetTheoryAFA.lean`; bot_self_mem). Mathlib: Nat.Partrec.Code.fixed_point₂ (Kleene's second recursion theorem). Mathlib: Nat.Partrec.Code.fixed_point (Rogers' fixed-point theorem). -## Axiom footprint (measured 2026-10-09) +## Axiom footprint + +This section's footprints were measured 2026-10-09 (§ VIII dates its own, 2026-10-04); the live record is +the `PurityCheck` section of `ZeroParadox/Computability/Kleene.lean`. Not every proved theorem here carries `Classical.choice`: `encodeCode_self` has no axioms. A carried footprint is a fact about the statement or proof as written, never evidence that @@ -113,18 +175,20 @@ distinct — `infinite_quine_family` and `quine_goedel_injective` prove it — w set-theoretic side has exactly one self-containing element (`quine_unique`). A unique element and an infinite indexed family are different shapes, so the correspondence here is between the *succession* of instantiations and the family, not an identification of -one element with one code. The framework's reading of that correspondence is in § II; -no theorem in this file identifies a `Code` with an element of a lattice, and the type -boundary makes such an identification unstatable. +one element with one code. That identity reading is retired (§ II); no theorem in this file +identifies a `Code` with an element of a lattice, and the type boundary makes such an +identification unstatable. **Prior art, and a distinction that must not be collapsed.** That a computational object is named by many indices rather than one is standard: the **Padding Lemma** — every partial recursive function has infinitely many indices — is its classical home, and an external computability reader mentioned it as possibly related when asked about ZP-K. It is the right reference for the direction it actually gives: **a function does not -determine an index**, since infinitely many indices compute it. (Stated as a named lemma -without individual attribution; it appears as a hypothesis of Rogers' isomorphism theorem -rather than as a result of his, so do not attach a name to it.) +determine an index**, since infinitely many indices compute it. (Rogers 1967 states it as +Theorem 1-III, p. 22, "Each partial recursive function has ℵ₀ distinct indices", proved by +adding to a machine instructions for states it can never enter; his Exercise 2-10(d), p. 41, +gives it for every numbering meeting his condition 2, which by Exercise 2-10(c) is the +condition for an s-m-n theorem. On p. 83 he calls the technique "padding".) It is **not** what `infinite_quine_family` proves, and the two must not be conflated: padding supplies infinitely many indices for the *same* function, whereas this family is witnessed by the constant codes, and `Code.const 0` and `Code.const 1` compute *different* @@ -174,7 +238,10 @@ every `n`. `SelfPrints c` says `c` returns its own Gödel number on channel `0`; `selfref_universal_exists` and `selfref_universal_infinite` get both at once from fixed points of `selfPrintOrDelegate`. These are statements about the partial function `eval c`, equalities of `Part ℕ` values; they state presence and existence of such codes, and nothing -here says a code is run. +here says a code is run. The self-printing half has a textbook form: Barwise & Moss 1996, +Proposition 3.3, p. 43, a program of no inputs that outputs itself, obtained from the recursion +theorem (their Theorem 3.2, Kleene's). Here the code instead returns its own Gödel number on every +input of channel `0`, and is also universal; Proposition 3.3 states no universal half. **Where `Classical.choice` enters `selfref_universal_exists`, measured 2026-10-04.** For the statement of `selfref_universal_exists` as written, the choice is not removed: that statement @@ -196,7 +263,8 @@ importing this one. triple. Its instance `Primcodable (Code × ℕ)` is `Primcodable.prod` over `Primcodable.ofDenumerable Code`, and both `Primcodable.prod` and that instance's `Denumerable Code` argument, `Nat.Partrec.Code.instDenumerable`, measure the triple (the - `PurityCheck` section of `ZeroParadox/Computability/Kleene.lean`), while `Partrec` measures + `example` before the `PurityCheck` section of `ZeroParadox/Computability/Kleene.lean` checks the + route by `rfl`; that section prints the footprints), while `Partrec` measures `[propext]` and `Nat.Partrec` none. `exists_code`, `eval_part`, `eval_curry`, `primrec₂_curry` and `evaln` each carry it. Mathlib's other recursion theorem, `fixed_point : Computable f → ∃ c, eval (f c) = eval c` for `f : Code → Code`, avoids @@ -215,8 +283,16 @@ importing this one. the choice enters with the pair instance (`Primcodable.prod`, `Encodable.Prod.encodable`), not with having two arguments (`stmtPartrec₂Hyp`, `stmtPartrecHyp`, `stmtPartrecProdHyp`, § V of `ZeroParadox/Computability/KleeneChoiceFree.lean`). - The measurements above are footprints of named Mathlib declarations; the pin was not searched - for a universal code whose correctness is proved without `eval_part`. One is built in this + The measurements above are footprints of named Mathlib declarations. A universal code whose + correctness is proved without `eval_part` was not located in the Mathlib pin as of 2026-11-03, + searched as follows: `Mathlib/Computability/` for `universal` (three hits: the `Halting.lean` + header, the docstring calling `eval` a universal partial recursive function in + `PartrecCode.lean`, and an unrelated line in `Primrec/List.lean`) and for `eval_part` and + `exists_code` (the codes obtained there come from `exists_code.1` applied to a `Partrec` proof + built with `eval_part`, as in `Halting.lean`); the nearest object located, + `Turing.PartrecToTM2.tr` (`Mathlib/Computability/TuringMachine/ToPartrec.lean`), is one fixed + `TM2` machine interpreting `Turing.ToPartrec.Code`, proved correct by `Turing.PartrecToTM2.tr_eval` + without `eval_part`; it is not a `Nat.Partrec.Code`. Such a universal code is built in this corpus, `universal_code_cf` in `ZeroParadox/Computability/UniversalChoiceFree.lean` (footprint in its `PurityCheck` section). Every proof of the statement of `selfref_universal_exists`, as written, carries choice. @@ -226,9 +302,10 @@ importing this one. construction is Kleene's own and constructive versions are already machine-checked, in Coq and, over an axiomatised naming system, in Lean 4 (prior-art pointers at the end of § V of that file); this corpus proves the s-m-n step (`cf_eval_curry`) and the diagonal of Kleene's ψ-form - (`cf_eval_diag`) on Mathlib's `Code`, and adds the measurement there; Close's - `diag_closure_spec` presupposes a universal code, which `KleeneChoiceFree.lean` does not build; - one is built in `ZeroParadox/Computability/UniversalChoiceFree.lean` (`universal_code_cf`). + (`cf_eval_diag`) on Mathlib's `Code`, and adds the measurement there. Close's + `diag_closure_spec` is an assumed field; its counterpart on Mathlib's `Code`, which evaluates the + code `e_f` returns, needs a universal code, which `KleeneChoiceFree.lean` does not build; one is + built in `ZeroParadox/Computability/UniversalChoiceFree.lean` (`universal_code_cf`). - As of 2026-10-25, `ofNatCodeCF` and both inverse laws (`cf_encodeCode_ofNatCodeCF`, `cf_ofNatCodeCF_encodeCode`) carry no `Classical.choice`, and `ofNatCodeCF_eq_ofNatCode` proves `ofNatCodeCF = ofNatCode` (§ VI of `ZeroParadox/Computability/KleeneChoiceFree.lean`, footprints @@ -274,8 +351,9 @@ control beside it shows that `Universal` carries the first half: `Code.zero` is and not universal, and it disagrees with a self-printing universal code on a channel `e + 1`. `Reading:` replicas share everything but the address; the next instance adds only the address. That is a claim about relative complexity, and it stays a reading while Kolmogorov complexity is -not in Lean (not located in the Mathlib pin as of 2026-10-04; search record in -`ZeroParadox/Information/Disjunctive.md`). +not formalized in this corpus, a scope decision (not located in the Mathlib pin as of 2026-10-04, +search record in `ZeroParadox/Information/Disjunctive.md`; Lean developments outside Mathlib define +it, named in the `ZPSurprisal` entry of `LEAN_CUSTOM_REGISTRY.md`). **Occurrence controls.** `Occurs` (`ZeroParadox/Computability/Occurrence.lean`) is `(eval c n).Dom` by `occurs_iff_halts`. `selfprints_occurs` and `zero_occurs` show it holding diff --git a/ZeroParadox/Computability/KleeneChoiceFree.lean b/ZeroParadox/Computability/KleeneChoiceFree.lean index 8b33b7e0..5ec6847a 100644 --- a/ZeroParadox/Computability/KleeneChoiceFree.lean +++ b/ZeroParadox/Computability/KleeneChoiceFree.lean @@ -49,7 +49,7 @@ theorem cf_amgm (a b : ℕ) : 4 * (a * b) ≤ (a + b) * (a + b) := by theorem cf_sq_succ (s : ℕ) : (s + 1) * (s + 1) = s * s + s + s + 1 := by simp only [Nat.add_mul, Nat.mul_add, Nat.mul_one, Nat.one_mul]; omega -/-- `Statement:` same type as Mathlib's `Nat.sqrt.iter_sq_le`, choice-free proof. -/ +/-- `Statement:` same type as Lean core's (private) `Nat.sqrt.iter_sq_le`, choice-free proof. -/ theorem cf_sqrt_iter_sq_le (n : ℕ) : ∀ g, Nat.sqrt.iter n g * Nat.sqrt.iter n g ≤ n := by intro g induction g using Nat.strong_induction_on with @@ -67,7 +67,7 @@ theorem cf_sqrt_iter_sq_le (n : ℕ) : ∀ g, Nat.sqrt.iter n g * Nat.sqrt.iter omega exact (Nat.le_div_iff_mul_le hg).1 h3 -/-- `Statement:` same type as Mathlib's `Nat.sqrt.lt_iter_succ_sq`, choice-free proof. -/ +/-- `Statement:` same type as Lean core's (private) `Nat.sqrt.lt_iter_succ_sq`, choice-free proof. -/ theorem cf_sqrt_lt_iter_succ_sq (n : ℕ) : ∀ g, n < (g + 1) * (g + 1) → n < (Nat.sqrt.iter n g + 1) * (Nat.sqrt.iter n g + 1) := by intro g @@ -203,12 +203,13 @@ theorem cf_bodd_add_div2 : ∀ n, (Nat.bodd n).toNat + 2 * Nat.div2 n = n | 0 => rfl | n + 1 => by have ih := cf_bodd_add_div2 n - rw [Nat.bodd_succ, Nat.div2_succ] + rw [Nat.div2_val] at ih + rw [Nat.bodd_succ, Nat.div2_val] cases hb : Nat.bodd n <;> rw [hb] at ih - · show 1 + 2 * Nat.div2 n = n + 1 + · show 1 + 2 * ((n + 1) / 2) = n + 1 have : (false : Bool).toNat = 0 := rfl rw [this] at ih; omega - · show 0 + 2 * (Nat.div2 n + 1) = n + 1 + · show 0 + 2 * ((n + 1) / 2) = n + 1 have : (true : Bool).toNat = 1 := rfl rw [this] at ih; omega @@ -250,7 +251,8 @@ theorem cf_eval_pair {cf cg : Code} {n a b : ℕ} (h1 : eval cf n = Part.some a) theorem cf_eval_comp {cf cg : Code} {n a : ℕ} (h : eval cg n = Part.some a) : eval (comp cf cg) n = eval cf a := by show eval cg n >>= eval cf = _ - rw [h, Part.bind_eq_bind, Part.bind_some] + rw [h] + exact Part.bind_some a _ /-- `Statement:` `comp cf cg` on two total stages returns the second stage's value. -/ theorem cf_eval_comp_some {cf cg : Code} {n a b : ℕ} (h : eval cg n = Part.some a) @@ -447,19 +449,22 @@ def stmtPartrecHyp : Prop := ∀ f : ℕ →. ℕ, Partrec f → True /-- `Statement:` CONTROL: a unary `Partrec` hypothesis at the pair carrier `ℕ × ℕ →. ℕ`, as a `Prop`. -/ def stmtPartrecProdHyp : Prop := ∀ f : ℕ × ℕ →. ℕ, Partrec f → True --- Statement: `stmtPartrec₂Hyp` carries `Classical.choice`, with no `Code` in it, and `stmtPartrecHyp` --- measures `[propext, Quot.sound]` (`PurityCheck`): the choice enters with the pair, through --- `Primcodable.prod`, before any recursion theorem is stated. --- Statement: `stmtPartrecProdHyp` carries `Classical.choice` too (`PurityCheck`), so the choice comes --- with the pair instance `Primcodable.prod`, not with having two arguments. +-- Statement: `stmtPartrec₂Hyp` and `stmtPartrecProdHyp` carry `Classical.choice`, with no `Code` in +-- either, and `stmtPartrecHyp` measures `[propext, Quot.sound]` (`PurityCheck`): the choice enters +-- with the pair instance `Primcodable.prod`, before any recursion theorem is stated, and the unary +-- `stmtPartrecProdHyp` shows it comes with that instance, not with having two arguments. --- Statement: each `cf_` lemma of § I and § II named after a Mathlib constant has exactly its type. +-- Statement: each `cf_` lemma of § I and § II named after a Mathlib or Lean core constant has exactly +-- its type; the two `Nat.sqrt.iter` twins are private in Lean core, so their type is written out. example : type_of% @Nat.unpair_pair := @cf_unpair_pair example : type_of% @Nat.pair_unpair := @cf_pair_unpair example : type_of% @Nat.sqrt_le := fun n => (cf_sqrt_isSqrt n).1 example : type_of% @Nat.lt_succ_sqrt := fun n => (cf_sqrt_isSqrt n).2 -example : type_of% @Nat.sqrt.iter_sq_le := @cf_sqrt_iter_sq_le -example : type_of% @Nat.sqrt.lt_iter_succ_sq := @cf_sqrt_lt_iter_succ_sq +example : ∀ (n guess : Nat), Nat.sqrt.iter n guess * Nat.sqrt.iter n guess ≤ n := + @cf_sqrt_iter_sq_le +example : ∀ (n guess : Nat), n < (guess + 1) * (guess + 1) → + n < (Nat.sqrt.iter n guess + 1) * (Nat.sqrt.iter n guess + 1) := + @cf_sqrt_lt_iter_succ_sq example : type_of% @Nat.sqrt_le_self := @cf_sqrt_le_self example : type_of% @Nat.unpair_left_le := @cf_unpair_left_le example : type_of% @Nat.unpair_right_le := @cf_unpair_right_le @@ -469,11 +474,12 @@ example : type_of% @Nat.Partrec.Code.eval_curry := @cf_eval_curry example : type_of% @Nat.Partrec.Code.eval_prec_zero := @cf_eval_prec_zero example : type_of% @Nat.Partrec.Code.eval_prec_succ := @cf_eval_prec_succ --- Statement: the Mathlib constants named above, and `stmtFixedPoint₂` / `stmtFixedPoint`, carry --- `Classical.choice`; the `cf_` lemmas, `fpCF`, `kleene_cf`, `kleene_cf_fixed₂` and `stmtKleeneCF` do --- not (the `#print axioms` lines in `PurityCheck`). --- Reading: in the bins of `ZeroParadox/Category/ChoiceCannotBe.md`, those Mathlib lemmas are --- ACCIDENTAL (a choice-free proof of the same type is exhibited above) and `fixed_point₂` / +-- Statement: the constants named by `type_of%` above other than `Nat.div2_val`, and `stmtFixedPoint₂` / +-- `stmtFixedPoint`, carry `Classical.choice`; `Nat.div2_val` (proved by `rfl`), the `cf_` lemmas, +-- `fpCF`, `kleene_cf`, `kleene_cf_fixed₂` and `stmtKleeneCF` do not (the `#print axioms` lines in +-- `PurityCheck`). +-- Reading: in the bins of `ZeroParadox/Category/ChoiceCannotBe.md`, those choice-carrying library +-- lemmas are ACCIDENTAL (a choice-free proof of the same type is exhibited above) and `fixed_point₂` / -- `fixed_point` are STATEMENT-CARRIED; the self-referential address is constructed, not selected. -- Reading (cited, not claimed): the construction is Kleene's, "On notation for ordinal numbers", J. -- Symbolic Logic 3(4) (1938), p. 153: "Let e define ψ(S¹ₙ(y, y), 𝔵) recursively, and set @@ -492,7 +498,8 @@ example : type_of% @Nat.Partrec.Code.eval_prec_succ := @cf_eval_prec_succ -- data); the counterpart of `diag_closure_spec`, which evaluates the code `e_f` returns, needs a -- universal code and is not built here. It builds no `NamingSystem` instance, and adds the measurement -- on `Code`, where the choice sits in the statements' packaging (`Partrec₂`, `Denumerable Code`) and in --- the proofs of the arithmetic lemmas above, not in the construction. +-- the proofs of the library's arithmetic lemmas named above (their `cf_` re-proofs are clean), not in the +-- construction. -- Statement: a universal code is built in `ZeroParadox/Computability/UniversalChoiceFree.lean` -- (`universal_code_cf`), which imports this file. -- Reading: whether selecting a code by its behaviour needs choice was not attempted as of 2026-10-22. @@ -727,14 +734,12 @@ open ZeroParadox #print axioms cf_ofNatCodeCF_encodeCode #print axioms ofNatCodeCF_eq_ofNatCode #print axioms stmtOfNatCodeCFEq --- The Mathlib constants the `cf_` lemmas share a type with, the two recursion theorems, and --- `ofNatCode`. +-- The Mathlib and Lean core constants the `cf_` lemmas share a type with, the two recursion +-- theorems, and `ofNatCode`. #print axioms Nat.unpair_pair #print axioms Nat.pair_unpair #print axioms Nat.sqrt_le #print axioms Nat.lt_succ_sqrt -#print axioms Nat.sqrt.iter_sq_le -#print axioms Nat.sqrt.lt_iter_succ_sq #print axioms Nat.sqrt_le_self #print axioms Nat.unpair_left_le #print axioms Nat.unpair_right_le diff --git a/ZeroParadox/Computability/MarkovNuUniversal.lean b/ZeroParadox/Computability/MarkovNuUniversal.lean index 28c99d3d..7931590c 100644 --- a/ZeroParadox/Computability/MarkovNuUniversal.lean +++ b/ZeroParadox/Computability/MarkovNuUniversal.lean @@ -27,13 +27,13 @@ stationary distribution in the probability simplex) in the bottom-diagram μ/ν is a coordinate-order antichain (`simplex_antichain`), so the stationary point is neither order-least (μ) nor order-greatest (ν). This file asks whether *changing the ambient* from the order to the **dynamics** rescues a universal property: the stationary distribution is a -*fixed point* of the Kleisli transfer action `μ ↦ μ.bind f`, and a **unique** fixed point of an -endomorphism is a terminal-flavoured (ν / final-coalgebra) universal object. The GO conjecture was +*fixed point* of the Kleisli transfer action `μ ↦ μ.bind f`; `Reading:` (no theorem or source) a +**unique** fixed point is read as a terminal-flavoured (ν) universal object. The GO conjecture was that the fixed-point predicate is a *subsingleton* (unique) under the doubly-stochastic hypothesis already in scope (`MeanErgodic.DoublyStochastic`); the NO-GO obstruction was that doubly-stochastic is **not enough** for uniqueness — a **reducible** chain has a whole simplex of stationary -distributions (one per communicating class), so #2 is a fixed *set*, not a fixed *point*, and resists -any μ/ν placement. +distributions (one vertex per essential (closed) communicating class: Levin–Peres 2nd ed., Ex. 1.14, Prop. +1.29), so #2 is a fixed *set*, not a fixed *point*, and resists any μ/ν placement. **What the Lean decides: the NO-GO is the truth, sharply — witnessed by a genuinely reducible chain.** The load-bearing theorem `markov_node_no_universal_property` exhibits a *concrete* doubly-stochastic @@ -152,8 +152,9 @@ theorem blockKernel_pure1_stationary : IsStationaryPMF blockKernel (PMF.pure 1) `0`, `1`, `{2,3}`), whose stationary-distribution predicate is **not a subsingleton**: it has two *distinct* witnesses, `pure 0` and `pure 1`, one per absorbing class. - A unique fixed point of an endomorphism is a terminal (ν / final-coalgebra) universal object; a - *non-unique* fixed set is not. So node #2 has **no** terminal/unique-fixed-point universal + `Reading:` (no theorem or source, as in the header) a unique fixed point of an endomorphism is + read as a terminal-flavoured (ν / final-coalgebra) universal object, and a *non-unique* fixed set + as not one. Under that reading node #2 has **no** terminal/unique-fixed-point universal property in the dynamical ambient under the doubly-stochastic hypothesis. The witness is a genuine reducible chain with internal dynamics — the obstruction is reducibility (multiple communicating classes), not the degenerate "does-nothing" identity. The pre-registered GO conjecture diff --git a/ZeroParadox/Computability/NatListRegime.lean b/ZeroParadox/Computability/NatListRegime.lean index 02906cce..2f2fa56a 100644 --- a/ZeroParadox/Computability/NatListRegime.lean +++ b/ZeroParadox/Computability/NatListRegime.lean @@ -166,7 +166,7 @@ theorem eventuallyLeaf_ne_infinity : ∀ x, EventuallyLeaf x → x ≠ natInfini rw [natCofix_infinity_dest] at hx have hc : c = (fun _ => natInfinity) := by have := (Sigma.mk.injEq _ _ _ _).mp hx.symm - simpa using this.2 + exact eq_of_heq this.2 rw [hc] /-- `natInfinity` never reaches a leaf. -/ diff --git a/ZeroParadox/Computability/Occurrence.lean b/ZeroParadox/Computability/Occurrence.lean index 35622035..bdaa2369 100644 --- a/ZeroParadox/Computability/Occurrence.lean +++ b/ZeroParadox/Computability/Occurrence.lean @@ -353,8 +353,9 @@ theorem occurs_iff_halts (c : Code) (n : ℕ) : Occurs c n ↔ (eval c n).Dom := exact ⟨k, by intro hnone; rw [hnone] at hk; exact absurd hk (by simp)⟩ /-- **Whether the snap occurs is undecidable.** No algorithm decides, of an arbitrary - computation, whether it ever changes observable state. Turing (1936), via Mathlib's - `ComputablePred.halting_problem`; the reduction is the identification above. -/ + computation, whether it ever changes observable state. The undecidability of halting is + conventionally credited to Turing (1936; that paper was not consulted here); the proof uses + Mathlib's `ComputablePred.halting_problem`, and the reduction is the identification above. -/ theorem occurrence_undecidable (n : ℕ) : ¬ ComputablePred (fun c : Code => Occurs c n) := by intro h diff --git a/ZeroParadox/Computability/Occurrence.md b/ZeroParadox/Computability/Occurrence.md index 5c978582..e9f5bf05 100644 --- a/ZeroParadox/Computability/Occurrence.md +++ b/ZeroParadox/Computability/Occurrence.md @@ -26,7 +26,9 @@ than statement lives here. ## What is claimed and what is not -The mathematics is classical throughout — the halting results are Turing (1936) via Mathlib, and the +The mathematics is classical throughout — the halting results are the ones conventionally credited +to Turing (1936; that paper was not consulted here), used through Mathlib's +`ComputablePred.halting_problem`, `halting_problem_re` and `halting_problem_not_re`, and the bottom-as-divergence reading is domain theory (Scott). Nothing is offered as new mathematics. What the Lean file contributes is the *arrangement*: which of the framework's own commitments collide (§ III), and where its occurrence question actually lives (§ V). The identification of the framework's @@ -58,8 +60,9 @@ anything with a single-valued step function, of which Turing machines are one wi does **not** license "the framework's bottom is a Turing machine" — that is an identity across carriers, and the same type boundary as everywhere else. The requirements are Mathlib's (`StateTransition`), the witness is Mathlib's (`Turing.TM0`); what is the framework's own is the **reading** of the trichotomy, -nothing more. Compare `ZeroParadox/Settheory/QuineHost.lean`: the honest form was never "we commit to -AFA" but "here are the requirements, and AFA is a witness meeting them." +nothing more. Compare `ZeroParadox/Settheory/QuineHost.lean`, where there is a commitment of the +framework's own: adopting AFA is CC-2's commitment, and the host requirements (`QuineAtomHost`) are its Lean +abstraction. ### Consequence 2 — `StateTransition`'s API is under-used; check it before hand-rolling @@ -196,9 +199,9 @@ Turing development uses the word for exactly this (`Mathlib/Computability/Turing quote is cited for EXISTENCE only — no other source here was read.** The notion is standard in model checking; *stutter equivalence* is commonly attributed to Browne, Clarke & Grumberg, TCS **59** (1988), and stuttering-insensitivity of specifications to Lamport (IFIP 1983), with a textbook treatment in -Baier & Katoen, *Principles of Model Checking* (cited above for the trap state). **None of the three was -located in `.claude-local/papers/` as of 2026-08-06, and this paragraph makes no claim about what any of -them says.** ⚠ Baier & Katoen is the exception worth naming: the adjacency section above *does* assert +Baier & Katoen, *Principles of Model Checking* (cited above for the trap state). **None of the three +had been located in this project's paper library as of 2026-08-06, and this paragraph makes no +claim about what any of them says.** ⚠ Baier & Katoen is the exception worth naming: the adjacency section above *does* assert its content (p. 157, the trap state), checked against an extracted source. Unfiled is not unread. Nothing in the stuttering section is claimed as new mathematics: the content is that the corpus's own @@ -206,7 +209,7 @@ trichotomy does not separate these cases. ## The trichotomy: loop versus recursion -*(Settled 2026-07-31; long form in `.claude-local/notes/recursion_not_loop_2026-07-30.md`.)* Whether +*(Settled 2026-07-31.)* Whether the bottom is a self-LOOP or a RECURSION — a descent through pairwise-distinct configurations — does not change the well-foundedness verdict, which is what the trichotomy results turn on. (Those results are stated for `f s = some s`; a distinct-state descent falls outside their hypothesis rather than @@ -218,7 +221,7 @@ better founded than a self-loop: **distinctness buys nothing; well-foundedness c `1 + X`, every non-terminating behaviour equals `natInfinity`. `Reading:` the "cannot depart" family is plausibly a one-relation shadow of coalgebraic -well-foundedness (Osius 1974 → Taylor → Adámek–Milius–Moss). Taylor (*Practical Foundations of Mathematics*, Prop 111 p. 6) and AMM are also +well-foundedness (Osius 1974 → Taylor → Adámek–Milius–Moss). Taylor (*Well founded coalgebras and recursion*, Prop 111 p. 6) and AMM are also cited by `snap_boundary_two_registers` (`ZeroParadox/Multihomed/BoundaryBridge.lean`), which fences that the corpus proves the ⇒ direction alone; the Osius attribution is AMM's own, at their p. 11 and ref [26] (*J. Pure Appl. Algebra* 4, 1974). Rutten, *Universal coalgebra*, TCS 249 (2000) p. 16 states the subject in one diff --git a/ZeroParadox/Computability/OutputSeparates.lean b/ZeroParadox/Computability/OutputSeparates.lean index f0e585c3..ad01d0d7 100644 --- a/ZeroParadox/Computability/OutputSeparates.lean +++ b/ZeroParadox/Computability/OutputSeparates.lean @@ -95,12 +95,12 @@ end ZeroParadox /-! ## Axiom Purity Check -**Measured 2026-07-30, all four: `[propext, Classical.choice, Quot.sound]`.** The choice is inherited -from Mathlib's `QPF.Cofix`, which is `Quot (@Mcongr F q)` over the M-type construction — every -statement here mentions `Cofix`, and `#print axioms` follows the STATEMENT, not the proof. This -matches the ν-side footprint `Category/CoalgebraForkPlace.lean` already records (μ side choice-free, -ν side not). None of it is a new commitment: the proofs themselves are one `Cofix.bisim`, one -`Cofix.dest_corec`, and one `congrArg` on a `Sigma.fst`. +**Measured 2026-07-30, all four: `[propext, Classical.choice, Quot.sound]`.** Every statement here +mentions Mathlib's `QPF.Cofix` (`Quot (@Mcongr F q)` over the M-type), whose type carries the choice +(`ZeroParadox/Category/ChoiceCannotBe.lean` § III, at `cofix_nonempty'`). `#print axioms` follows the +statement and the proof; here the statement already accounts for it. This matches the ν-side +footprint `Category/CoalgebraForkPlace.lean` records (μ side choice-free, ν side not). None of it is a +new commitment: the proofs are one `Cofix.bisim`, one `Cofix.dest_corec`, one `congrArg` on `Sigma.fst`. -/ section PurityCheck open ZeroParadox diff --git a/ZeroParadox/Computability/OutputSeparates.md b/ZeroParadox/Computability/OutputSeparates.md index d99bf018..b203f7ba 100644 --- a/ZeroParadox/Computability/OutputSeparates.md +++ b/ZeroParadox/Computability/OutputSeparates.md @@ -11,8 +11,7 @@ the declarations, the Engineer's Take and the per-declaration glosses. the corpus already had. **The governing result — Rutten, *Universal coalgebra: a theory of systems*, TCS 249 (2000), Example -10.2(5), printed p. 44** (`.claude-local/papers/rutten_universal_coalgebra_2000.pdf`; Rutten credits it -to his [52], Manes & Arbib 1986): for `F(S) = A × S^B` the final system is `A^{B*}`. A polynomial +10.2(5), printed p. 44** (Rutten credits it to his [52], Manes & Arbib 1986): for `F(S) = A × S^B` the final system is `A^{B*}`. A polynomial functor `⟨A, fun _ => B⟩` is exactly that `F`, so its final coalgebra has `|A|^{|B*|}` elements — **a single point iff `|A| = 1`, for every `B` whatsoever.** The head type decides; the arity `B` is irrelevant to whether the final coalgebra is a single point. diff --git a/ZeroParadox/Computability/Rice.lean b/ZeroParadox/Computability/Rice.lean index 0cddbd1f..64e68c08 100644 --- a/ZeroParadox/Computability/Rice.lean +++ b/ZeroParadox/Computability/Rice.lean @@ -55,7 +55,7 @@ theorem halting_undecidable (n : ℕ) : ¬ ComputablePred (fun c => (eval c n).D /-- **The exists-but-undecidable signature.** In the computability setting the recursion theorem, used twice, gives *both*: every computable self-map on codes has a fixed point **up to `eval`** (the Kleene quine exists — ν, via `computability_face_fixedPoint`; NOT a literal fixed point — `fun c => Code.pair c c` - has none), *and* every non-trivial extensional property is undecidable (Rice). + has none, `code_pair_diag_fixedPointFree`), *and* every non-trivial extensional property is undecidable (Rice). The second conjunct does not mention `f`: the undecidability is of `C` over all codes, and nothing is stated about membership at `f`'s fixed point (gloss: `ZeroParadox/Computability/ComputationCannotBe.lean` § V). -/ theorem quine_exists_yet_rice (C : Set Code) diff --git a/ZeroParadox/Computability/SelfApp.lean b/ZeroParadox/Computability/SelfApp.lean index 8e9b2ead..d8cac8a7 100644 --- a/ZeroParadox/Computability/SelfApp.lean +++ b/ZeroParadox/Computability/SelfApp.lean @@ -22,10 +22,12 @@ open ZeroParadox /-! ## § I. AbstractSelfApp Typeclass -/ -/-- A ZPSemilattice with a self-application operation whose unique fixed point is ⊥. - Abstracts the shared structure between: - Set theory (AFA): f x = {x}, unique fixed point = Quine atom = ⊥ - 2-adic integers: f x = 2 * x, unique fixed point = 0 (v₂ = +∞) +/-- A ZPSemilattice with a self-application operation whose unique fixed point is ⊥ of that + semilattice; in any instance ⊥ is the one occupant of the die's Quine-atom role under + `selfApp` (`selfApp_quine_role_iff`, `ZeroParadox/Settheory/QuineDichotomy.lean`). + Abstracts a pattern shared by two settings, neither of which is an instance declared here: + Set theory (ZF + AFA): f x = {x}, unique fixed point the Quine atom (CC-2) + 2-adic numbers ℚ_[2]: f x = 2 * x, unique fixed point 0 (v₂ = +∞), § IV From these two fields, AFAStructure's two LAWS become theorems; its `selfMem` field is DATA and is supplied by `def selfMemDerived`, not proved. See §III. -/ -- [ZP-CUSTOM] no Mathlib analog | reason: Abstracts the shared fixed-point pattern between AFA set theory (f x = {x}, unique fixed point = Quine atom) and 2-adic multiplication (f x = 2x, unique fixed point = 0). Mathlib has Function.IsFixedPt (a predicate) but no typeclass for "type with a self-application operation whose unique fixed point is a designated bottom element." Allows AFAStructure's two LAWS to become theorems; its selfMem field is DATA, supplied by definition. @@ -86,7 +88,7 @@ instance toAFAStructure : AFAStructure L where /-! ## § IV. The 2-Adic Parallel - The same abstract fixed-point pattern in ℚ_[2]: multiplication by 2 + An analogous fixed-point pattern in ℚ_[2]: multiplication by 2 has 0 as its unique fixed point, characterised by v₂(0) = +∞. Note: no ZPSemilattice ℚ_[2] is DEFINED, so no AbstractSelfApp instance for it here — not diff --git a/ZeroParadox/Computability/SelfApp.md b/ZeroParadox/Computability/SelfApp.md index 77e47d65..2f991b7b 100644 --- a/ZeroParadox/Computability/SelfApp.md +++ b/ZeroParadox/Computability/SelfApp.md @@ -1,6 +1,6 @@ # SelfApp — ride-along documentation -Moved from `ZeroParadox/Computability/SelfApp.lean`. ⚠ **This content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED. Moving it changes that by exactly nothing.** Its claims are unverified until a claim review says otherwise. +Moved from `ZeroParadox/Computability/SelfApp.lean` on 2026-10-13. ⚠ **At the move this content was GRANDFATHERED — it was carried in an accepted-defect baseline, which means it was let through UNEXAMINED, and moving it changed that by exactly nothing.** The text has been edited since the move; this banner records its state on 2026-10-13 and does not record whether any review has taken place since. In the sections below, "this file" and "here" refer to `ZeroParadox/Computability/SelfApp.lean`. @@ -19,8 +19,13 @@ Two facts from different ZP layers: - Set theory (ZPJ / AFA): ⊥ is the unique fixed point of x ↦ {x} - 2-adic (ZPB): 0 is the unique fixed point of x ↦ 2x (characterised by v₂ = +∞) -These are the same abstract pattern: the domain's self-application operation has a -unique fixed point, and that fixed point is the "bottom" of the domain. Uniqueness +These follow an analogous pattern: the domain's self-application operation has a +unique fixed point, and that fixed point is the "bottom" of the domain. Membership in +`AbstractSelfApp` does not discriminate: every `ZPSemilattice` carries one +(`abstractSelfApp_always_inhabited`). Prior art for treating AFA's unique solutions and final +coalgebras of locally contracting functors on complete metric spaces uniformly, as final-coalgebra uniqueness: +Rutten and Turi, "On the Foundations of Final Semantics: Non-Standard Sets, Metric Spaces, Partial +Orders", REX 1992, LNCS 666 (1993) (cited, not claimed). Uniqueness collapses construction to identification (ZeroParadox/Settheory/AczelConn.lean). Footprints: the `PurityCheck` section of `ZeroParadox/Computability/SelfApp.lean`. @@ -31,15 +36,19 @@ structure. Which of `AFAStructure`'s three fields it derives as theorems, and wh supplies as data: § III of `ZeroParadox/Computability/SelfApp.lean`. The 2-adic parallel is then proved standalone: `singleton_from_unique_witness` -(already proved in ZeroParadox/Settheory/AczelConn.lean) closes the Q₂ case with the same proof term. +(already proved in ZeroParadox/Settheory/AczelConn.lean) closes the Q₂ case with the same proof structure. Why it is standalone rather than an `AbstractSelfApp` instance: § IV of the same file. ## What the Scale files resolved -The abstract valuation typeclass described here as the remaining ZPB→ZPJ gap is -`ValuationStructure`, defined in `ZeroParadox/Valuation/Scale.lean`. That file derives the -unique-fixed-point chain without an AFA import: - ValuationStructure → scale_ne_fixed → AbstractSelfApp (unique_fp as theorem) -`ZeroParadox/Valuation/ScaleBridge.lean` further extends this: ValBridge drops the ZPSemilattice -constraint entirely, and both ℤ_[2] and ZPSemilattice types become instances -of a common ancestor. The formal gap described here is closed. +The 2-adic case above is proved standalone on ℚ_[2], not as an `AbstractSelfApp` instance. +`ZeroParadox/Valuation/Scale.lean` defines `ValuationStructure`, an abstract valuation typeclass over a +`ZPSemilattice`, and derives the unique-fixed-point chain from it without an AFA import: + ValuationStructure → scale_ne_fixed → AbstractSelfApp (unique_fp as theorem; instance `toAbstractSelfApp`) +Its 2-adic carrier is ℤ_[2], not ℚ_[2]: the `example`s closing `Scale.lean` build a `ZPSemilattice ℤ_[2]` +whose least element is ℤ_[2]'s 0 and put a `ValuationStructure` on it (scale `×2`, val `q2Val`); neither +is registered as an instance. `ZeroParadox/Valuation/ScaleBridge.lean` adds `ValBridge`, which drops the +`ZPSemilattice` requirement: ℤ_[2] (`instZ2ValBridge`) and every `ZPSemilattice` carrying a +`ValuationStructure` (`toValBridge`) are instances, and `scale_unique_fp_free` gives the unique fixed +point on each. Being a `ValBridge` instance does not by itself separate these carriers from a trivial +one: `trivialValBridge` inhabits `ValBridge Unit`. diff --git a/ZeroParadox/Computability/SelfCopyReference.lean b/ZeroParadox/Computability/SelfCopyReference.lean index 4ce931f9..83c0888d 100644 --- a/ZeroParadox/Computability/SelfCopyReference.lean +++ b/ZeroParadox/Computability/SelfCopyReference.lean @@ -157,6 +157,37 @@ theorem no_selfCopyRef_of_fintype {α : Type*} [Fintype α] [DecidableEq α] (f List.length_filter_lt_length_iff_exists.mpr ⟨y, hc y, by simp⟩ omega +/-- `Statement:` over a `Finite` type no `SelfCopyRef` map exists — the same list pigeonhole, on the +enumeration `α ≃ Fin n` the `Finite` proof carries, deciding equality through `Fin n`. -/ +theorem no_selfCopyRef_of_finite_constructive {α : Type*} [hfin : Finite α] (f : α → α) : + ¬ SelfCopyRef f := by + rintro ⟨hi, hns, _⟩ + apply hns + intro y + cases hfin with + | intro e => + let l := (List.finRange _).map e.symm + have hnd : l.Nodup := (List.nodup_finRange _).map e.symm.injective + have hc : ∀ x, x ∈ l := fun x => + List.mem_map.mpr ⟨e x, List.mem_finRange _, e.symm_apply_apply x⟩ + rcases Decidable.em (∃ x ∈ l, e (f x) = e y) with h | h + · obtain ⟨x, _, hx⟩ := h + exact ⟨x, e.injective hx⟩ + · exfalso + have hsub : l.map f ⊆ l.filter (fun x => decide (e x ≠ e y)) := by + intro z hz + obtain ⟨x, hxl, rfl⟩ := List.mem_map.mp hz + exact List.mem_filter.mpr ⟨hc _, decide_eq_true (fun he => h ⟨x, hxl, he⟩)⟩ + have hle := ((hnd.map hi).subperm hsub).length_le + rw [List.length_map] at hle + have hlt : (l.filter (fun x => decide (e x ≠ e y))).length < l.length := + List.length_filter_lt_length_iff_exists.mpr ⟨y, hc y, by simp⟩ + omega + +-- Statement: it proves the statement of `no_selfCopyRef_of_finite` as written. +example {α : Type} [Finite α] (f : α → α) : ¬ SelfCopyRef f := + no_selfCopyRef_of_finite_constructive f + /-- `Statement:` on a finite type, if `b` is the only periodic point of `f`, every orbit lands on `b` after finitely many steps. -/ theorem orbit_reaches_unique_periodic_of_finite {α : Type*} [Finite α] (f : α → α) (b : α) @@ -246,9 +277,9 @@ example (g : Fin 3 → Fin 3) : ¬ DieSelfCopyRef g := /-! ## § IV. Fences -* Proved: the AVAILABILITY of a `SelfCopyRef` map, on infinite carriers only. That the semilattice ⊥ on an - INFINITE carrier PERFORMS one is a commitment — see `l_inf` (`ZeroParadox/Information/Surprisal.lean`). - `MachinePhase`, the two-phase rounding that carries `machinePhaseKleene`, admits none +* Proved: the AVAILABILITY of a `SelfCopyRef` map, on infinite carriers only. That ⊥ of a `ZPSemilattice` + whose carrier is INFINITE PERFORMS one is a commitment — see `l_inf` (`ZeroParadox/Information/Surprisal.lean`). + `MachinePhase`, the two-element carrier of `machinePhaseKleene`, admits none (`no_selfCopyRef_of_finite`; the `example` in `ZeroParadox/Computability/ComputationCannotBe.lean` § IX). * `#print axioms` on a proof reports that proof's footprint, never a principle's necessity; whether a statement as written carries choice is a separate measurement (`ZeroParadox/Category/ChoiceCannotBe.md`). -/ @@ -265,7 +296,8 @@ open ZeroParadox -- Measured: the three below carry `Classical.choice` (Mathlib routes). For the ⟹ half it enters -- turning bare `Infinite α` into a counting — `Cardinal.aleph0_le_mk`, `Cardinal.mul_aleph0_eq`, -- `Cardinal.add_one_eq`, `Cardinal.mk_option` (and `Infinite.natEmbedding`) each report it; --- `Cardinal.eq` does not. A proof's footprint, never a principle's necessity: UNCLASSIFIED. In set theory +-- `Cardinal.eq` does not. A proof's footprint, never a principle's necessity: the ⟹ half is +-- UNCLASSIFIED (the finite half is classified in the note on the list pigeonhole below). In set theory -- without choice the ⟹ half is unprovable: infinite Dedekind-finite sets, with no one-to-one, not-onto -- self-map, are consistent there (Banakh, arXiv:2006.01613v4, Rem. 43.14, citing Jech 1973 § 4.6). -- Dependent choice gives every infinite set such a self-map (Prop. 43.12); the unique fixed point is not @@ -278,9 +310,18 @@ open ZeroParadox #print axioms natSCR_selfCopyRef #print axioms selfCopyRef_of_equiv_nat #print axioms boundaryDouble_selfCopyRef --- The finite half re-proved without `Classical.choice` (list pigeonhole over a `Fintype` enumeration): --- ACCIDENTAL for the `[Fintype] [DecidableEq]` statement, whose Mathlib route reports choice. The --- `[Finite]` statement `no_selfCopyRef_of_finite` is not re-proved here and stays UNCLASSIFIED. +-- The finite half by list pigeonhole, under two instance readings. `[Finite]`: the statement's +-- constants `Finite` and `SelfCopyRef` measure no axioms, and `no_selfCopyRef_of_finite_constructive` +-- proves it at `[propext, Quot.sound]` (the `example` after it gives `no_selfCopyRef_of_finite`), so +-- `no_selfCopyRef_of_finite`'s choice is ACCIDENTAL, as in set theory without choice: Banakh, +-- arXiv:2006.01613v4, Thm 43.3 and Cor. 43.4 (p. 102), and "By Theorem 43.3, every finite set is +-- Dedekind-finite" (p. 104). `[Fintype] [DecidableEq]`: the proof spends no +-- choice, and the statement carries it through the `[Fintype α]` binder, since `Fintype` itself reports +-- it at the pinned Mathlib, so `no_selfCopyRef_of_fintype` is STATEMENT-CARRIED +-- (`ZeroParadox/Category/ChoiceCannotBe.lean` § III, STATEMENT-CARRIED IS INSTANCE-RELATIVE). +#print axioms Finite +#print axioms Fintype +#print axioms no_selfCopyRef_of_finite_constructive #print axioms no_selfCopyRef_of_fintype -- The die form: `dieSelfCopyRef_of_selfCopyRef` adds to `fanIn_selfOnlyAt_of_selfCopyRef` only the -- step obtaining a point with no predecessor by contradiction from not-onto, and only it reports diff --git a/ZeroParadox/Computability/UniversalChoiceFree.lean b/ZeroParadox/Computability/UniversalChoiceFree.lean index 563757ae..0008b609 100644 --- a/ZeroParadox/Computability/UniversalChoiceFree.lean +++ b/ZeroParadox/Computability/UniversalChoiceFree.lean @@ -44,8 +44,8 @@ a one-step machine instead of `evaln`. -/ -- iterated and searched) is F. J. Balbach, "Some classical results in inductive inference of -- recursive functions", Archive of Formal Proofs (2020), entry `Inductive_Inference` -- (https://www.isa-afp.org/entries/Inductive_Inference.html), theory `Universal`, § 1.5, in --- classical Isabelle/HOL. Constructive universal functions exist in Coq, where no global choice --- operator (no classical axiom) is available unless one is declared: Forster and Kunze, "A +-- classical Isabelle/HOL. Constructive universal functions exist in Coq, where neither a global +-- choice operator nor a classical axiom is available unless one is declared: Forster and Kunze, "A -- certifying extraction with time bounds from Coq to call-by-value λ-calculus", arXiv 1904.11818, -- a universal L-term extracted from a step-indexed self-interpreter. Carneiro, p. 12:15, on -- Mathlib's development: "there was no particular reason to assume LEM except in Theorem 5". @@ -173,14 +173,14 @@ theorem mem_rfindSem {f : Code} {a m x : ℕ} : rw [Part.mem_map_iff] constructor · rintro ⟨k, hk, rfl⟩ - rw [Nat.mem_rfind] at hk - obtain ⟨h1, h2⟩ := hk + obtain ⟨h1, h2⟩ := Nat.mem_rfind.1 hk + have h1 : true ∈ (fun x => decide (x = 0)) <$> eval f (Nat.pair a (k + m)) := h1 rw [Part.map_eq_map, Part.mem_map_iff] at h1 obtain ⟨v, hv, hv0⟩ := h1 have : v = 0 := of_decide_eq_true hv0 subst this refine ⟨k, rfl, hv, fun j hj => ?_⟩ - have h3 := h2 hj + have h3 : false ∈ (fun x => decide (x = 0)) <$> eval f (Nat.pair a (j + m)) := h2 hj rw [Part.map_eq_map, Part.mem_map_iff] at h3 obtain ⟨w, hw, hw0⟩ := h3 cases w with @@ -188,8 +188,7 @@ theorem mem_rfindSem {f : Code} {a m x : ℕ} : | succ w => exact ⟨w, hw⟩ · rintro ⟨k, rfl, h0, hlt⟩ refine ⟨k, ?_, rfl⟩ - rw [Nat.mem_rfind] - refine ⟨Part.mem_map_iff _ |>.2 ⟨0, h0, rfl⟩, fun {j} hj => ?_⟩ + refine Nat.mem_rfind.2 ⟨Part.mem_map_iff _ |>.2 ⟨0, h0, rfl⟩, fun {j} hj => ?_⟩ obtain ⟨v, hv⟩ := hlt j hj exact Part.mem_map_iff _ |>.2 ⟨v + 1, hv, rfl⟩ @@ -261,8 +260,7 @@ theorem codeStep_sem : ∀ s, codeSem (codeStep s) = codeSem s rw [eval_pair_bind_eq]; rfl | .ev (.comp f g) n k => by show eval g n >>= codeContSem (.compK f k) = (eval g n >>= eval f) >>= codeContSem k - simp only [Part.bind_eq_bind] - rw [Part.bind_assoc]; rfl + exact (Part.bind_assoc (eval g n) (eval f) (codeContSem k)).symm | .ev (.prec f g) n k => by show eval f n.unpair.1 >>= codeContSem (.precK g n.unpair.1 0 n.unpair.2 k) = eval (prec f g) n >>= codeContSem k @@ -405,8 +403,7 @@ theorem codeRun_complete : ((codeRun_complete g n b hb _).trans (CodeReaches.of_step (CodeReaches.refl _))))) | .comp f g, n, x, h, k => by have h' : x ∈ (eval g n).bind (eval f) := h - rw [Part.mem_bind_iff] at h' - obtain ⟨y, hy, hx⟩ := h' + obtain ⟨y, hy, hx⟩ := Part.mem_bind_iff.1 h' exact CodeReaches.of_step ((codeRun_complete g n y hy _).trans (CodeReaches.of_step (codeRun_complete f y x hx _))) | .prec f g, n, x, h, k => by @@ -568,9 +565,25 @@ theorem boddNat_eq : ∀ n, boddNat n = (Nat.bodd n).toNat theorem div2Nat_eq : ∀ n, div2Nat n = Nat.div2 n | 0 => rfl | n + 1 => by - show div2Nat n + boddNat n = _ - rw [div2Nat_eq n, boddNat_eq n, Nat.div2_succ] - cases Nat.bodd n <;> rfl + have hb : ∀ m, boddNat m = m % 2 := fun m => by + induction m with + | zero => rfl + | succ m ih => + show natSel (boddNat m) 1 0 = (m + 1) % 2 + rw [ih, Nat.add_mod] + rcases Nat.mod_two_eq_zero_or_one m with h | h <;> rw [h] <;> rfl + show div2Nat n + boddNat n = (n + 1) / 2 + rw [div2Nat_eq n, hb n] + show n / 2 + n % 2 = (n + 1) / 2 + have e := (Nat.mod_add_div n 2).symm + rcases Nat.mod_two_eq_zero_or_one n with h | h <;> rw [h] at e ⊢ <;> + generalize n / 2 = q at e ⊢ <;> subst e + · show q + 0 = (0 + 2 * q + 1) / 2 + rw [Nat.zero_add, Nat.add_comm (2 * q) 1, Nat.add_mul_div_left 1 q (by decide : 0 < 2)] + exact (Nat.add_zero q).trans (Nat.zero_add q).symm + · show q + 1 = (1 + 2 * q + 1) / 2 + rw [Nat.add_right_comm 1 (2 * q) 1, Nat.add_mul_div_left (1 + 1) q (by decide : 0 < 2)] + exact Nat.add_comm q 1 /-- `Statement:` for `X = x.toNat + 2 * (y.toNat + 2 * P)`, `boddNat` and `div2Nat` read back `x`, `y` and `P`. -/ @@ -1008,8 +1021,8 @@ theorem univ_value_eq (a : ℕ) : obtain ⟨t0, ht0⟩ := (codeRun_halts_iff _ _ _).2 hx have hdom : (Nat.rfind fun t => (fun m => decide (m = 0)) <$> (Part.some (haltSearch (Nat.pair a t)))).Dom := by - rw [Nat.rfind_dom] - refine ⟨t0, ?_, fun _ => trivial⟩ + refine Nat.rfind_dom.2 ⟨t0, ?_, fun _ => trivial⟩ + show true ∈ (fun m => decide (m = 0)) <$> Part.some (haltSearch (Nat.pair a t0)) rw [Part.map_eq_map, Part.mem_map_iff] refine ⟨0, ?_, rfl⟩ rw [hs, ht0, (doneTest_enc _).2 ⟨x, rfl⟩] @@ -1099,9 +1112,20 @@ theorem zero_not_universal : and `ofNatCodeCF`, the bridges to them, and a code meeting both: Kleene's ψ-form (`kleene_cf`) applied to a total dispatcher followed by `universal_code_cf'`. -Reading (cited, not claimed): the textbook ψ-form corollary of the recursion theorem; in the framing -of Bonfante, Kaczmarek, Marion, "On abstract computer virology from a recursion-theoretic -perspective", J. Computer Virology 1(3-4), 2006, Def. 2 and Thm 3, such a code is a virus. -/ +Reading (cited, not claimed): the textbook ψ-form corollary of the recursion theorem; the +computer-virology framing is glossed at the `example` below. -/ + +-- Reading (cited, not claimed): Bonfante, Kaczmarek, Marion, "On abstract computer virology from a +-- recursion-theoretic perspective" (Def. 2, Thm 3 numbered as in the authors' preprint held here; +-- the locator J. Computer Virology 1(3-4), 2006, not checked against the publisher's record), call +-- `v` a virus w.r.t. a computable `B` when `φ_v(p, x) = φ_{B(v,p)}(x)` (Def. 2). With `B` the s-m-n +-- map their iteration property (1) makes every program a virus, as their Thm 20 itself records +-- (a `B` built from s-m-n with `V_B = D`), so the label does not single out the code built here; +-- shared with their Thm 3 is only the shape, a recursion-theorem fixed point `v` with +-- `φ_v(p, x) = f(v, p, x)`. +-- Statement: `curry` is computable and every code `v` meets Def. 2 with `B v p = curry v p`. +example : Primrec₂ curry ∧ ∀ (v : Code) (p x : ℕ), eval v (Nat.pair p x) = eval (curry v p) x := + ⟨primrec₂_curry, fun v p x => (cf_eval_curry v p x).symm⟩ /-- `Statement:` `SelfPrints` with `encodeCode`: channel `0` returns the code's own number. -/ def SelfPrintsCF (c : Code) : Prop := @@ -1514,8 +1538,9 @@ open ZeroParadox #print axioms zero_selfPrints_not_universal #print axioms universal_not_selfPrints_cf #print axioms unshifted_incompatible --- Mathlib constants that entries above share a type with, then the corpus original --- `selfref_universal_exists`. +-- Mathlib constants that entries above share a type with (for the biconditional +-- `Nat.Partrec.Code.exists_code`, its forward direction only: `cf_exists_code_mp`), then the corpus +-- original `selfref_universal_exists`. #print axioms Nat.Primrec.casesOn' #print axioms Nat.Partrec.Code.exists_code #print axioms Nat.left_le_pair diff --git a/ZeroParadox/DiagonalFixedPoint.lean b/ZeroParadox/DiagonalFixedPoint.lean index 3311a699..9749755a 100644 --- a/ZeroParadox/DiagonalFixedPoint.lean +++ b/ZeroParadox/DiagonalFixedPoint.lean @@ -49,11 +49,11 @@ In the fork / AFA face the occupant is ⊥ of the `ZPSemilattice`, a fixed point In the computability face it is a Kleene code (a `Code`), a term of another type. -/ #check @ZeroParadox.t_exec -- the Quine atom: any `q` with `IsQuineAtom q` equals ⊥ of the `ZPSemilattice`, from the `AFAStructure` class fields. "⊥ self-executes" is the framework's reading, not this statement #check @ZeroParadox.da1_closed_concrete -- concrete Quine atom: `IsQuineAtom (bot : MachinePhase)` -#check @ZeroParadox.kleene_quine_is_bot -- any Quine atom = ⊥ of the `ZPSemilattice` `L`, under `[KleeneStructure]`. NB the statement has no Kleene clause; `KleeneStructure` nominates `botCode` (a `Code`) as the computational witness of the bottom role of `L`, ZP-K's commitment, not a Lean `=` (Code vs L) -#check @ZeroParadox.t_comp -- T-COMP: proves the Quine-atom / order-bottom / join-identity faces equivalent (three). The Kleene face is a `KleeneStructure` class field, not a clause +#check @ZeroParadox.kleene_quine_is_bot -- any Quine atom = ⊥ of the `ZPSemilattice` `L`, under `[KleeneStructure]`. NB the statement has no Kleene clause; `KleeneStructure` names a `botCode` (a `Code`), and reading it as the computational witness of the bottom role of `L` keeps no identity half: the code chart has its own occupancy of the die's Quine-atom role (`codes_vs_classes`, `ZeroParadox/Computability/Kleene.lean` § IX), and that ⊥ runs is the occurrence commitment. No Lean `=` (Code vs L, for a generic L; at L := Code one typechecks: `ZeroParadox/Computability/ComputationCannotBe.lean` § IV) +#check @ZeroParadox.t_comp -- T-COMP: Quine atom ↔ (order-bottom ∧ join identity); with `da2_bottom_characterization` the three faces are equivalent. The Kleene face is a `KleeneStructure` class field, not a clause #check @ZeroParadox.selfApp_isLeastFixedPointFrom -- ⊥ of the `ZPSemilattice` is the least fixed point of self-application (the order floor) #check @ZeroParadox.ProvabilityLogic.loeb_sentence_is_fixedpoint -- Löb: the provability diagonal closes given a Löb diagonal ψ (hypotheses hfix1, hfix2) -#check @ZeroParadox.ProvabilityLogic.godel_two -- Gödel's second: given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum — the provability floor, given a Löb diagonal +#check @ZeroParadox.ProvabilityLogic.godel_two -- Gödel's second: given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum — the provability floor #check @ZeroParadox.rice_face_has_bottom -- Rice: computable f has a fixed point up to eval; reading it as the face's floor is the family's criterion, not the theorem #check @ZeroParadox.quine_exists_yet_rice -- Rice pivot: f's fixed point exists AND a non-trivial extensional C is undecidable over all codes; the second conjunct does not mention f (ComputationCannotBe.lean § V) diff --git a/ZeroParadox/Die.lean b/ZeroParadox/Die.lean index 6d3a0479..472772a6 100644 --- a/ZeroParadox/Die.lean +++ b/ZeroParadox/Die.lean @@ -1,3 +1,4 @@ +import ZeroParadox.Order.ChoiceFreeWithTop import Mathlib.Order.Cover import Mathlib.Order.BoundedOrder.Basic import Mathlib.Data.PFun @@ -75,12 +76,12 @@ example {α : Type u} (u : α →. α) : (∀ x y, y ∈ u x → y ∈ u y) ↔ funext x apply Part.ext intro y - rw [PFun.comp_apply, Part.mem_bind_iff] + rw [PFun.comp_apply, Part.mem_bind_iff (g := u)] -- [ZP port] Lean 4.35: `g` named through `PFun` exact ⟨fun ⟨z, hz, hyz⟩ => (Part.mem_unique (h x z hz) hyz) ▸ hz, fun hy => ⟨y, hy, h x y hy⟩⟩ · intro h x y hy have hy' : y ∈ (u.comp u) x := by rw [congrFun h x]; exact hy - rw [PFun.comp_apply, Part.mem_bind_iff] at hy' + rw [PFun.comp_apply, Part.mem_bind_iff (g := u)] at hy' -- [ZP port] Lean 4.35: as above obtain ⟨z, hz, hyz⟩ := hy' exact Part.mem_unique hz hy ▸ hyz @@ -617,6 +618,28 @@ theorem selectedTotal_of_option (f : α → Option α) (h : ∀ a b, M.step a b rw [hb'] rfl +/-- `Statement:` if `α` has points `u ≠ v` and a `Bool` test `t` with `t b = true ↔ b = u`, and every + `Prop`-valued step on `α` has a total selector, weak excluded middle holds; the reduction reads + the selector at `u` of the step to `u` when `p` and to `v` when `¬ p`. -/ +theorem wem_of_selectedTotal_propStep (u v : α) (huv : u ≠ v) (t : α → Bool) + (ht : ∀ b, t b = true ↔ b = u) + (H : ∀ s : α → α → Prop, (ofTotal id (fun _ => rfl) s).SelectedTotal) : + ∀ p : Prop, ¬ p ∨ ¬ ¬ p := by + intro p + obtain ⟨f, hf⟩ := H (fun _ b => (b = u ∧ p) ∨ (b = v ∧ ¬ p)) + cases hfu : t (f u) with + | true => + have e := (ht _).1 hfu + refine Or.inr fun hnp => ?_ + rcases hf u ⟨v, Or.inr ⟨rfl, hnp⟩⟩ with ⟨_, hp⟩ | ⟨hv, _⟩ + · exact hnp hp + · exact huv (e.symm.trans hv) + | false => + refine Or.inl fun hp => ?_ + rcases hf u ⟨u, Or.inl ⟨rfl, hp⟩⟩ with ⟨hu, _⟩ | ⟨_, hnp⟩ + · rw [(ht _).2 hu] at hfu; cases hfu + · exact hnp hp + /-! ### § IX. The OVER leg's WHETHER: what OVER does at a point -/ variable (M) @@ -645,9 +668,10 @@ theorem overTrichotomy_of_option [DecidableEq α] (f : α → Option α) cases hf : f y with | none => exact Or.inl fun b hb => by rw [h, hf] at hb; cases hb | some b => - rcases decEq b y with hne | heq - · exact Or.inr (Or.inr ⟨b, (h y b).2 hf, hne⟩) - · subst heq + cases decEq b y with -- [ZP port] Lean 4.35: rcases on `Decidable` no longer binds names + | isFalse hne => exact Or.inr (Or.inr ⟨b, (h y b).2 hf, hne⟩) + | isTrue heq => + subst heq exact Or.inr (Or.inl ⟨(h _ _).2 hf, fun c hc => (Option.some_injective _ (hf.symm.trans ((h _ c).1 hc))).symm⟩) @@ -668,6 +692,32 @@ theorem lpo_of_trichotomy_nat_boolStep · exact Or.inl ⟨0, hs⟩ · exact Or.inl ⟨b, hb⟩ +/-- `Statement:` if, at a point `y` of `α`, the trichotomy holds for every `Prop`-valued step on `α`, + excluded middle holds; the reduction reads the step `a ↦ {b | p ∧ b = y}` at `y`. -/ +theorem em_of_trichotomy_propStep (y : α) + (H : ∀ s : α → α → Prop, (ofTotal id (fun _ => rfl) s).OverTrichotomy y) : + ∀ p : Prop, p ∨ ¬ p := by + intro p + rcases H (fun _ b => p ∧ b = y) with h | ⟨⟨hp, _⟩, _⟩ | ⟨b, ⟨_, hb⟩, hne⟩ + · exact Or.inr fun hp => h y ⟨hp, rfl⟩ + · exact Or.inl hp + · exact absurd hb hne + +/-- `Statement:` if excluded middle holds, every motion meets the trichotomy at every point. -/ +theorem trichotomy_of_em (em : ∀ p : Prop, p ∨ ¬ p) (M : Motion α) (y : α) : + M.OverTrichotomy y := by + rcases em (∃ b, M.step y b ∧ b ≠ y) with h1 | h1 + · exact Or.inr (Or.inr h1) + · rcases em (M.step y y) with h2 | h2 + · refine Or.inr (Or.inl ⟨h2, fun b hb => ?_⟩) + rcases em (b = y) with e | e + · exact e + · exact absurd ⟨b, hb, e⟩ h1 + · refine Or.inl fun b hb => ?_ + rcases em (b = y) with e | e + · exact h2 (e ▸ hb) + · exact h1 ⟨b, hb, e⟩ + /-- `Statement:` if `y` has at most one successor and steps to itself, `y` steps to itself only; no order is used. `Reading:` the order-free trap beside § XII's order traps. -/ theorem selfOnlyAt_of_step_self {y : α} (hu : ∀ b c, M.step y b → M.step y c → b = c) (hy : M.step y y) : @@ -1335,16 +1385,21 @@ theorem isBot_and_isTop_iff {X : Type u} [PartialOrder X] (x : X) : ⟨fun ⟨hb, ht⟩ y => le_antisymm (ht y) (hb y), fun h => ⟨fun y => (h y).symm ▸ le_rfl, fun y => (h y).symm ▸ le_rfl⟩⟩ +section +-- [ZP port] Lean 4.35: Mathlib proves `WithBot`/`WithTop.le_def` by `grind`, so their `Preorder` +-- carries `Classical.choice`; pin the bare `instLE` here and prove from its constructors. +attribute [local instance high] WithBot.instLE WithTop.instLE + /-- `Statement:` on `WithBot σ`, ⊥ is also greatest iff `σ` is empty. -/ theorem withBot_bot_isBot_and_isTop_iff {σ : Type u} [Preorder σ] : (IsBot (⊥ : WithBot σ) ∧ IsTop (⊥ : WithBot σ)) ↔ IsEmpty σ := by constructor · rintro ⟨-, ht⟩ - exact ⟨fun a => WithBot.not_coe_le_bot a (ht a)⟩ + exact ⟨fun a => by cases ht a⟩ · intro h - refine ⟨fun _ => bot_le, fun x => ?_⟩ + refine ⟨fun x => WithBot.LE.bot_le x, fun x => ?_⟩ induction x using WithBot.recBotCoe with - | bot => exact le_rfl + | bot => exact WithBot.LE.bot_le _ | coe a => exact isEmptyElim a /-- `Statement:` on `WithTop σ`, ⊤ is also least iff `σ` is empty. -/ @@ -1352,13 +1407,15 @@ theorem withTop_top_isBot_and_isTop_iff {σ : Type u} [Preorder σ] : (IsBot (⊤ : WithTop σ) ∧ IsTop (⊤ : WithTop σ)) ↔ IsEmpty σ := by constructor · rintro ⟨hb, -⟩ - exact ⟨fun a => WithTop.not_top_le_coe a (hb a)⟩ + exact ⟨fun a => by cases hb a⟩ · intro h - refine ⟨fun x => ?_, fun _ => le_top⟩ + refine ⟨fun x => ?_, fun x => WithTop.LE.le_top x⟩ induction x using WithTop.recTopCoe with - | top => exact le_rfl + | top => exact WithTop.LE.le_top _ | coe a => exact isEmptyElim a +end + /-- `Statement:` ⊥ of `WithBot σ` has a cover iff `σ` has a minimal point. -/ theorem botCovered_withBot_iff {σ : Type u} [PartialOrder σ] : BotCovered (WithBot σ) ↔ ∃ a : σ, IsMin a := by @@ -1370,19 +1427,31 @@ theorem botCovered_withBot_iff {σ : Type u} [PartialOrder σ] : · rintro ⟨a, ha⟩ exact ⟨a, WithBot.bot_covBy_coe.2 ha⟩ +section +-- [ZP port] Lean 4.35: Mathlib's `WithTop` orders carry `Classical.choice`; scope `ZeroParadox/Order/ChoiceFreeWithTop.lean`'s. +attribute [local instance high] withTopPreorderCF withTopPartialOrderCF withTopOrderBotCF + /-- `Statement:` if `σ` has a least point and no maximal point, ⊥ of `WithTop σ` has a cover iff ⊥ of `σ` has one. -/ theorem botCovered_withTop_iff {σ : Type u} [PartialOrder σ] [OrderBot σ] [NoMaxOrder σ] : BotCovered (WithTop σ) ↔ BotCovered σ := by + have inv : ∀ {x y : σ}, (x : WithTop σ) < y → x < y := fun h => by + change WithTop.LT _ _ at h + cases h with | coe_lt_coe h => exact h constructor · rintro ⟨a, h⟩ induction a using WithTop.recTopCoe with | top => obtain ⟨b, hb⟩ := exists_gt (⊥ : σ) - exact absurd (WithTop.coe_lt_top b) (h.2 (WithTop.coe_lt_coe.2 hb)) - | coe a => exact ⟨a, WithTop.coe_covBy_coe.1 h⟩ + exact (h.2 (WithTop.LT.coe_lt_coe hb) (WithTop.LT.lt_top b)).elim + | coe a => exact ⟨a, inv h.1, fun c h1 h2 => h.2 (WithTop.LT.coe_lt_coe h1) (WithTop.LT.coe_lt_coe h2)⟩ · rintro ⟨a, h⟩ - exact ⟨a, WithTop.coe_covBy_coe.2 h⟩ + refine ⟨a, WithTop.LT.coe_lt_coe h.1, fun c h1 h2 => ?_⟩ + induction c using WithTop.recTopCoe with + | top => change WithTop.LT _ _ at h2; cases h2 + | coe c => exact h.2 (inv h1) (inv h2) + +end /-- `Statement:` under any `≤`, an empty carrier has no least-element and no greatest-element structure. -/ @@ -1832,6 +1901,12 @@ def closedSublattice : CompleteSublattice (Set α) := (fun _ hs => ⟨fun x hx y hy t ht => (hs ht).1 x (hx t ht) y hy, fun x hx b hb t ht => (hs ht).2 x (hx t ht) b hb⟩) +section +-- [ZP port] Lean 4.35: `subset_rfl`/`Subset.trans` on `Set` now go through +-- `Set.instCompleteAtomicBooleanAlgebra`, which carries `Classical.choice`; erasing the two +-- Boolean-algebra instances here routes them through the choice-free `Set.instDistribLattice`. +attribute [-instance] Set.instCompleteAtomicBooleanAlgebra Set.instBooleanAlgebra + /-- `Statement:` `restrictInclusion` along `S ⊆ S` is the identity. -/ theorem restrictInclusion_refl {S : Set α} (hS : M.UpClosed S) (x : S) : M.restrictInclusion hS hS subset_rfl x = x := rfl @@ -1843,6 +1918,8 @@ theorem restrictInclusion_trans {S T U : Set α} (hS : M.UpClosed S) (hT : M.UpC M.restrictInclusion hS hT hTS (M.restrictInclusion hT hU hUT x) = M.restrictInclusion hS hU (hUT.trans hTS) x := rfl +end + /-- `Statement:` `M ≤ N` when `M` and `N` have the same UP and every step of `M` is a step of `N`. -/ -- [ZP-CUSTOM] no Mathlib analog | reason: an order on the die's own record `Motion`: equality of the -- UP leg and inclusion of the OVER relation; Mathlib orders relations by `≤` on `α → α → Prop`, not @@ -2177,6 +2254,10 @@ example {α β : Type} (M : Motion α) (N : Motion β) (f : α → β) : def StepBack (M : Motion α) (N : Motion β) (f : α → β) : Prop := ∀ a c, N.step (f a) c → ∃ b, M.step a b ∧ f b = c +-- Reading: `StepBack` also resembles the back condition of a bounded morphism (p-morphism) of modal +-- logic; no source for that name was retrieved as of 2026-11-03 (searched: the local papers library +-- for Blackburn and for modal logic). + -- Statement: `StepBack` is `Relation.Fibration` of the reversed steps, by `Iff.rfl`. example (M : Motion α) (N : Motion β) (f : α → β) : StepBack M N f ↔ Relation.Fibration M.reverse.step N.reverse.step f := Iff.rfl @@ -3018,8 +3099,8 @@ example : -- `f ↦ (x ↦ (V ↦ x (V ∘ f)))` fails `PreservesWeakPullbacksElementwise`, at `f : Bool → Bool` -- constant `false` and `g : Unit → Bool` constant `true`, whose pullback is empty. Reading: the -- functor is the contravariant powerset composed with itself, the neighbourhood functor with `Prop` --- for `2`, which Gumm and Freese (arXiv:2103.09566, p. 1) name as an exception to weak preservation --- of pullbacks. +-- in place of `2` (the two agree only classically); Gumm and Freese (arXiv:2103.09566, p. 1) name the +-- neighbourhood functor as an exception to weak preservation of pullbacks. example : ¬ PreservesWeakPullbacksElementwise { obj := fun S : Type => (S → Prop) → Prop map := fun f => TypeCat.ofHom fun x V => x fun a => V (f a) } := by @@ -3191,7 +3272,9 @@ theorem isBisim_comp {M : Motion α} {N : Motion β} {P : Motion γ} {R : α → def Bisimilar (M : Motion α) (N : Motion β) (a : α) (b : β) : Prop := ∃ R, IsBisim M N R ∧ R a b /-- `Statement:` `Bisimilar M M` is an equivalence relation (Mathlib `Equivalence`). `Reading:` the - last clause of Rutten's Corollary 5.6 (p. 33); transitivity here uses `isBisim_comp`. -/ + equivalence half of the last clause of Rutten's Corollary 5.6 (p. 33), that the greatest + bisimulation on one system is a bisimulation equivalence; the bisimulation half is + `isBisim_bisimilar` at `N := M`. Transitivity here uses `isBisim_comp`. -/ theorem bisimilar_equivalence (M : Motion α) : Equivalence (Bisimilar M M) := ⟨fun _ => ⟨Eq, isBisim_eq M, rfl⟩, fun ⟨R, hR, r⟩ => ⟨flip R, isBisim_flip hR, r⟩, @@ -3255,7 +3338,7 @@ theorem isBisim_ker_coalgHom {α β : Type u} {M : Motion α} {N : Motion β} /-- `Statement:` if `f` carries steps to steps and has `StepBack` and `UpStrict`, and `Q` is a bisimulation from `N` to itself, `fun a a' => Q (f a) (f a')` is one from `M` to itself. - `Reading:` Rutten's Proposition* 5.9(2) (p. 34). -/ + `Reading:` for carriers in one universe, Rutten's Proposition* 5.9(2) (p. 34). -/ theorem isBisim_preimage {M : Motion α} {N : Motion β} {f : α → β} (hf : ∀ a b, M.step a b → N.step (f a) (f b)) (hb : StepBack M N f) (hu : UpStrict M N f) {Q : β → β → Prop} (hQ : IsBisim N N Q) : IsBisim M M (fun a a' => Q (f a) (f a')) := by @@ -3619,15 +3702,13 @@ theorem hmap_ofNat_ne (y : NInf) (n : ℕ) : hmap y (ofNat n) ≠ y := by | true => rw [hmap_ofNat_of_true y n hy] intro e - have := congrArg (fun z : NInf => z.1 n) e - simp only at this + have := congrArg (fun z : NInf => z.1 n) e -- [ZP port] Lean 4.35: arrives beta-reduced rw [hy] at this exact absurd this (by rw [show (ofNat n).1 n = false from decide_eq_false (Nat.lt_irrefl n)]; decide) | false => rw [hmap_ofNat_of_false y n hy] intro e - have := congrArg (fun z : NInf => z.1 n) e - simp only at this + have := congrArg (fun z : NInf => z.1 n) e -- [ZP port] Lean 4.35: arrives beta-reduced rw [hy] at this exact absurd this (by rw [show (ofNat (n + 1)).1 n = true from decide_eq_true (Nat.lt_succ_self n)]; decide) @@ -3776,17 +3857,19 @@ theorem overTrichotomy_option_boolStep_of_lpo (ofTotal id (fun _ => rfl) (fun a b => r a b = true)).OverTrichotomy y := by have hb : ∀ b, (r y b && !decide (b = y)) = true → r y b = true ∧ b ≠ y := by intro b hb - rcases decEq b y with hne | he - · cases hr : r y b + cases decEq b y with -- [ZP port] Lean 4.35: rcases on `Decidable` no longer binds names + | isFalse hne => + cases hr : r y b · rw [hr] at hb; cases hb · exact ⟨rfl, hne⟩ - · rw [decide_eq_true he] at hb + | isTrue he => + rw [decide_eq_true he] at hb cases hr : r y b <;> rw [hr] at hb <;> cases hb have hc : ∀ b, (r y b && !decide (b = y)) = false → r y b = true → b = y := by intro b hb hr - rcases decEq b y with hne | he - · rw [hr, decide_eq_false hne] at hb; cases hb - · exact he + cases decEq b y with -- [ZP port] Lean 4.35: rcases on `Decidable` no longer binds names + | isFalse hne => rw [hr, decide_eq_false hne] at hb; cases hb + | isTrue he => exact he rcases h (fun n => r y (some n) && !decide (some n = y)) with ⟨n, hn⟩ | hall · exact Or.inr (Or.inr ⟨some n, hb _ hn⟩) · cases hnone : (r y none && !decide (none = y)) with @@ -3840,12 +3923,12 @@ end Motion namespace NInf /-- `Statement:` if a `Bool` test `t` isolates `∞`, deciding membership in `{∞}`, the weak limited - principle of omniscience (WLPO) holds. `Reading:` "isolated": Escardó, arXiv:2609.10447v3, Def. - 3.2 (p. 14), as data; compare his Examples 3.3(5) with the `Nonempty` iff example, whose forward - direction this is at the `Prop` level (`ZeroParadox/DieCannotBe.lean` § XXVII). Via - `isolating_infty_iff`, the choice-free reduction is the WLPO row with Lemma 3.3 (p. 4) of his - preprint of JSL 78(3) (2013), formalized for the `ℕ∞`-indexed `WLPO` as TypeTopology - `basic-discontinuity-taboo` (`Taboos.BasicDiscontinuity`, retrieved 2026-10-29). -/ + principle of omniscience (WLPO) holds. `Reading:` "isolates": `∞` is isolated (Escardó, + arXiv:2609.10447v3, Def. 3.2, p. 14), as data; compare his Examples 3.3(5) with the `Nonempty` + iff example (`ZeroParadox/DieCannotBe.lean` § XXVII), of which this is the forward direction at + the `Prop` level. By `isolating_infty_iff`, `t` satisfies TypeTopology's `basic-discontinuity`; + its `basic-discontinuity-taboo` (`Taboos.BasicDiscontinuity`, retrieved 2026-10-29, for the + `ℕ∞`-indexed `WLPO`) is Escardó's WLPO row with Lemma 3.3 (JSL 78(3) (2013), preprint p. 4). -/ theorem wlpo_of_isolating_infty (t : NInf → Bool) (ht : ∀ b, t b = true ↔ b = infty) : ∀ r : ℕ → Bool, (∀ n, r n = false) ∨ ¬ ∀ n, r n = false := fun r => by cases h : t (det r) with @@ -3950,7 +4033,8 @@ def decEq_of_isolating_infty (t : NInf → Bool) (ht : ∀ b, t b = true ↔ b = DecidableEq NInf := decEq_of_wlpoData fun r => @decidable_of_iff _ _ ((ht (det r)).trans (det_eq_infty_iff r)) (instDecidableEqBool (t (det r)) true) -/-- `Statement:` and back: decidable equality on `NInf` gives a `Bool` test isolating `∞`. -/ +/-- `Statement:` and back: decidable equality on `NInf` gives that a `Bool` test isolating `∞` + exists. -/ theorem isolating_infty_of_decEq (d : DecidableEq NInf) : ∃ t : NInf → Bool, ∀ b, t b = true ↔ b = infty := ⟨fun b => @decide _ (d b infty), fun b => @decide_eq_true_iff _ (d b infty)⟩ @@ -3968,6 +4052,19 @@ theorem wlpo_of_tag (g : NInf → Option ℕ) (hg : ∀ x, g x = none ↔ x = in have := (hg b).2 e rw [hb] at this; cases this +-- The `DecidableEq` binder is kept in the type on purpose: the proof cases on it, and the +-- PurityCheck prints the footprint that binder buys. +set_option linter.unusedDecidableInType false in +/-- `Statement:` if `D` has decidable equality and a map `g : NInf → D` has `g x = g ∞ ↔ x = ∞` at + every `x`, WLPO holds. `wlpo_of_tag` has the hypotheses of the case `D = Option ℕ`, there with + `g ∞ = none` (`ZeroParadox/DieCannotBe.lean` § XXVII). -/ +theorem wlpo_of_discrete_tag {D : Type*} [DecidableEq D] (g : NInf → D) + (hg : ∀ x, g x = g infty ↔ x = infty) : + ∀ r : ℕ → Bool, (∀ n, r n = false) ∨ ¬ ∀ n, r n = false := fun r => by + by_cases h : g (det r) = g infty + · exact Or.inl ((det_eq_infty_iff r).1 ((hg _).1 h)) + · exact Or.inr fun hall => h (by rw [(det_eq_infty_iff r).2 hall]) + /-- `Statement:` `toPart x` is defined iff `x n = false` for some `n`, with value the least such `n`. -/ def toPart (x : NInf) : Part ℕ := ⟨∃ n, x.1 n = false, fun h => Nat.find h⟩ @@ -4009,7 +4106,7 @@ theorem toPart_injective : Function.Injective toPart := by | false => have e := key y x hxy.symm n hy have := congrArg (fun z : NInf => z.1 n) e - simp only at this; rw [hy, hx] at this; exact this.symm + rw [hy, hx] at this; exact this.symm -- [ZP port] Lean 4.35: `congrArg` result arrives beta-reduced | true => rfl /-- `Statement:` `toPart ∘ ofOption = Part.ofOption` on `Option ℕ`. -/ @@ -4029,6 +4126,90 @@ theorem toPart_ofOption (o : Option ℕ) : toPart (ofOption o) = Part.ofOption o exact congrArg some (by omega) · intro h; cases h; rfl +/-- `Statement:` partial elements of `ℕ` defined iff `∃ n, α n = true`, for some `α`. -/ +def RosPart : Type := {o : Part ℕ // ∃ α : ℕ → Bool, (o.Dom ↔ ∃ n, α n = true)} + +/-- `Statement:` `toPart x` with the witness `α = fun n => !x n` for its definedness. -/ +def toRos (x : NInf) : RosPart := ⟨toPart x, ⟨fun n => !x.1 n, + ⟨fun ⟨n, h⟩ => ⟨n, by simp [h]⟩, fun ⟨n, h⟩ => ⟨n, by simpa using h⟩⟩⟩⟩ + +/-- `Statement:` if `toRos` is onto, LPO holds; the proof reads the preimage of the element with + value `0` defined iff `∃ n, α n = true` at bit `0`. -/ +theorem lpo_of_toRos_surjective (h : Function.Surjective toRos) : + ∀ α : ℕ → Bool, (∃ n, α n = true) ∨ ∀ n, α n = false := by + intro α + obtain ⟨x, hx⟩ := h ⟨⟨∃ n, α n = true, fun _ => 0⟩, ⟨α, Iff.rfl⟩⟩ + have hx' : toPart x = ⟨∃ n, α n = true, fun _ => 0⟩ := congrArg Subtype.val hx + cases h0 : x.1 0 with + | false => + left + have hd : (toPart x).Dom := ⟨0, h0⟩ + rw [hx'] at hd; exact hd + | true => + right + intro n + cases hn : α n with + | false => rfl + | true => + have hm : (0 : ℕ) ∈ toPart x := by rw [hx']; exact ⟨⟨n, hn⟩, rfl⟩ + rw [(mem_toPart_iff x 0).1 hm] at h0 + exact absurd h0 (by decide) + +/-- `Statement:` if LPO holds, `toRos` is onto. -/ +theorem toRos_surjective_of_lpo (h : ∀ α : ℕ → Bool, (∃ n, α n = true) ∨ ∀ n, α n = false) : + Function.Surjective toRos := by + rintro ⟨o, α, hα⟩ + rcases h α with hex | hall + · have hd : o.Dom := hα.2 hex + refine ⟨ofNat (o.get hd), Subtype.ext (Part.ext fun n => ?_)⟩ + show n ∈ toPart (ofOption (some (o.get hd))) ↔ n ∈ o + rw [toPart_ofOption, Part.mem_ofOption] + exact ⟨fun e => (Option.some_injective _ e) ▸ Part.get_mem hd, + fun hn => congrArg some (Part.mem_unique (Part.get_mem hd) hn)⟩ + · refine ⟨infty, Subtype.ext (Part.ext fun n => ?_)⟩ + show n ∈ toPart infty ↔ n ∈ o + constructor + · rintro ⟨⟨m, hm⟩, _⟩; cases hm + · rintro ⟨hd, _⟩ + obtain ⟨m, hm⟩ := hα.1 hd + rw [hall m] at hm; cases hm + +/-- `Statement:` `toRos` is onto iff LPO; both directions. `Reading:` compare Escardó and Knapp, + CSL 2017, § 2.8, p. 21:6: "the decidability of Rosolini propositions is known as LPO". -/ +theorem toRos_surjective_iff : + Function.Surjective toRos ↔ ∀ α : ℕ → Bool, (∃ n, α n = true) ∨ ∀ n, α n = false := + ⟨lpo_of_toRos_surjective, toRos_surjective_of_lpo⟩ + +/-- `Statement:` every proposition `p` has some `α : ℕ → Bool` with `p ↔ ∃ n, α n = true`. -/ +def AllRosolini : Prop := ∀ p : Prop, ∃ α : ℕ → Bool, (p ↔ ∃ n, α n = true) + +/-- `Statement:` if excluded middle holds, `AllRosolini` holds. -/ +theorem allRosolini_of_em (em : ∀ p : Prop, p ∨ ¬ p) : AllRosolini := fun p => + (em p).elim (fun hp => ⟨fun _ => true, ⟨fun _ => ⟨0, rfl⟩, fun _ => hp⟩⟩) + (fun hn => ⟨fun _ => false, ⟨fun hp => absurd hp hn, fun ⟨_, h⟩ => by cases h⟩⟩) + +/-- `Statement:` if `AllRosolini` and LPO hold, excluded middle holds. -/ +theorem em_of_allRosolini_lpo (hr : AllRosolini) + (hl : ∀ α : ℕ → Bool, (∃ n, α n = true) ∨ ∀ n, α n = false) : ∀ p : Prop, p ∨ ¬ p := fun p => by + obtain ⟨α, hα⟩ := hr p + rcases hl α with h | h + · exact Or.inl (hα.2 h) + · exact Or.inr fun hp => by obtain ⟨n, hn⟩ := hα.1 hp; rw [h n] at hn; cases hn + +/-- `Statement:` the inclusion `RosPart → Part ℕ` is onto iff `AllRosolini`; both directions. -/ +theorem rosIncl_surjective_iff : + Function.Surjective (Subtype.val : RosPart → Part ℕ) ↔ AllRosolini := by + constructor + · intro h p + obtain ⟨⟨o, hro⟩, ho⟩ := h ⟨p, fun _ => 0⟩ + obtain ⟨α, hα⟩ := hro + refine ⟨α, ?_⟩ + have ho' : o = ⟨p, fun _ => 0⟩ := ho + subst ho' + exact hα + · intro h o + exact ⟨⟨o, h o.Dom⟩, rfl⟩ + /-- `Statement:` a map `g : NInf → Option ℕ` with `g x = some n ↔ x = n̲` gives LPO (Escardó, p. 4, the LPO row `ℕ∞ = ℕ ∪ {∞}`, right to left; compare his Corollary 3.7, p. 5). -/ theorem lpo_of_exactTag (g : NInf → Option ℕ) (hg : ∀ x n, g x = some n ↔ x = ofNat n) : @@ -4297,6 +4478,716 @@ theorem lpo_of_loopAt_image (r : NInf → Option ℕ) end Motion +/-! ### § XXIV. A limit pinned from two directions: `PinnedLimit` +`Reading:` Tim's role (2026-11-03), "squishy" in his word: a value pinned from below as the least +upper bound of the stages of a climbing run (`Monotone s`) it is not a stage of, and from the step +map as its least fixed point. The run `s (n + 1) = g (s n)` is `(Motion.ofFun g).IsRun s`, stated beside the role at each +occupant. The ε₀ occupant is `epsilon0_pinnedLimit` (`ZeroParadox/Ordinal/Epsilon0MinMax.lean` § III). -/ + +section PinnedLimit + +variable {α : Type*} [Preorder α] + +/-- `Statement:` `c` is the least upper bound of the stages `Set.range s`, is not a stage, and is the + least fixed point of `g`, and the run climbs (`Monotone s`). `Reading:` the standard name, for a + monotone `g` and the run from the least element of a partial order, is closure ordinal ω + (`pinnedLimit_iff_closure_omega`). -/ +-- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib's Kleene theorems for an ω-continuous map +-- (`fixedPoints.lfp_eq_sSup_iterate` on a complete lattice, +-- `OmegaCompletePartialOrder.fixedPoints.ωSup_iterate_mem_fixedPoint` on an ω-complete partial +-- order) and `Ordinal.nfp` state the sup and leastness halves; this is the +-- four-clause predicate on a preorder, with the not-a-stage and climbing clauses. +def PinnedLimit (g : α → α) (s : ℕ → α) (c : α) : Prop := + IsLUB (Set.range s) c ∧ c ∉ Set.range s ∧ IsLeast {x | g x = x} c ∧ Monotone s + +/-- `Statement:` `PinnedLimit g s c`, and every fixed point of `g` is `c`. -/ +def PinnedLimitUnique (g : α → α) (s : ℕ → α) (c : α) : Prop := + PinnedLimit g s c ∧ ∀ x, g x = x → x = c + +/-- `Statement:` `PinnedLimit` with clause (c) relative to the first stage: `c` is the least fixed + point of `g` at or above `s 0`. -/ +-- [ZP-CUSTOM] extends: PinnedLimit (ZeroParadox/Die.lean) | reason: the least fixed point above a +-- seed, which `PinnedLimit` (least over the whole carrier) cannot see at a seed above the least one; +-- Mathlib's `OrderHom.nextFixed` is that fixed point on a complete lattice, for a seed `x ≤ f x`. +def PinnedLimitAbove (g : α → α) (s : ℕ → α) (c : α) : Prop := + IsLUB (Set.range s) c ∧ c ∉ Set.range s ∧ IsLeast {x | g x = x ∧ s 0 ≤ x} c ∧ Monotone s + +/-- `Statement:` `PinnedLimit g s c → PinnedLimitAbove g s c`, for every run. -/ +theorem PinnedLimit.toAbove {g : α → α} {s : ℕ → α} {c : α} (h : PinnedLimit g s c) : + PinnedLimitAbove g s c := + ⟨h.1, h.2.1, ⟨⟨h.2.2.1.1, h.1.1 ⟨0, rfl⟩⟩, fun _ hx => h.2.2.1.2 hx.1⟩, h.2.2.2⟩ + +/-- `Statement:` when `s 0` is ⊥ of `α`, `PinnedLimitAbove g s c ↔ PinnedLimit g s c`; both + directions. -/ +theorem pinnedLimitAbove_iff_of_bot [OrderBot α] {g : α → α} {s : ℕ → α} {c : α} (hs : s 0 = ⊥) : + PinnedLimitAbove g s c ↔ PinnedLimit g s c := + ⟨fun h => ⟨h.1, h.2.1, ⟨h.2.2.1.1.1, fun _ hx => h.2.2.1.2 ⟨hx, hs ▸ bot_le⟩⟩, h.2.2.2⟩, + PinnedLimit.toAbove⟩ + +end PinnedLimit + +/-- `Statement:` on a partial order `α` with a least element, for a monotone `g`, `PinnedLimit` at the + run `g^[n] ⊥` from ⊥ of `α` holds iff `c` is the least upper bound of the stages, `g c = c`, and no stage is + fixed; both directions. `Reading:` the right side is closure ordinal ω, "we reached the (least) + fixed point for the first time at stage ω. We say that ω is the closure ordinal of these + operators" (A. Das and L. Melgaard, *Cyclic proofs for arithmetical inductive definitions*, FSCD + 2023, doi:10.4230/LIPIcs.FSCD.2023.23, 23:4, Example 2.9, there on `𝒫(ℕ)`). -/ +theorem pinnedLimit_iff_closure_omega {α : Type*} [PartialOrder α] [OrderBot α] (g : α → α) + (hg : Monotone g) (c : α) : + PinnedLimit g (fun n => g^[n] ⊥) c ↔ + (IsLUB (Set.range fun n => g^[n] ⊥) c ∧ g c = c ∧ ∀ n, g (g^[n] ⊥) ≠ g^[n] ⊥) := by + have chain : Monotone (fun n => g^[n] ⊥) := hg.monotone_iterate_of_le_map bot_le + have below : ∀ x, g x = x → ∀ n, g^[n] ⊥ ≤ x := fun x hx n => by + induction n with + | zero => exact bot_le + | succ k ih => rw [Function.iterate_succ_apply', ← hx]; exact hg ih + constructor + · rintro ⟨hlub, hnot, ⟨hfix, _⟩, _⟩ + refine ⟨hlub, hfix, fun k hk => hnot ⟨k, ?_⟩⟩ + have const : ∀ m, g^[k + m] ⊥ = g^[k] ⊥ := fun m => by + induction m with + | zero => rfl + | succ j ih => rw [← add_assoc, Function.iterate_succ_apply', ih, hk] + have ub : ∀ n, g^[n] ⊥ ≤ g^[k] ⊥ := fun n => by + rcases le_total n k with h | h + · exact chain h + · obtain ⟨m, rfl⟩ := Nat.exists_eq_add_of_le h; rw [const m] + exact le_antisymm (hlub.1 ⟨k, rfl⟩) (hlub.2 (by rintro _ ⟨n, rfl⟩; exact ub n)) + · rintro ⟨hlub, hfix, hnf⟩ + refine ⟨hlub, fun ⟨k, hk⟩ => hnf k (by simp only at hk; rw [hk]; exact hfix), + ⟨hfix, fun x hx => ?_⟩, chain⟩ + exact hlub.2 (by rintro _ ⟨n, rfl⟩; exact below x hx n) + +/-- `Statement:` on a finite partial order, `PinnedLimitAbove g s c` fails for every `g`, `s` and `c`: + a climbing run there is eventually constant (the ascending chain condition, Mathlib + `wellFoundedGT_iff_monotone_chain_condition`), so the least upper bound of its stages is a stage. -/ +theorem not_pinnedLimitAbove_of_finite {α : Type*} [PartialOrder α] [Finite α] (g : α → α) + (s : ℕ → α) (c : α) : ¬ PinnedLimitAbove g s c := by + rintro ⟨hlub, hnot, _, hs⟩ + obtain ⟨N, hN⟩ := wellFoundedGT_iff_monotone_chain_condition.1 inferInstance ⟨s, hs⟩ + refine hnot ⟨N, le_antisymm (hlub.1 ⟨N, rfl⟩) (hlub.2 ?_)⟩ + rintro _ ⟨k, rfl⟩ + rcases le_total k N with h | h + · exact hs h + · exact (hN k h).ge + +/-- `Statement:` on a finite partial order, `PinnedLimit g s c` fails for every `g`, `s` and `c`. -/ +theorem not_pinnedLimit_of_finite {α : Type*} [PartialOrder α] [Finite α] (g : α → α) + (s : ℕ → α) (c : α) : ¬ PinnedLimit g s c := + fun h => not_pinnedLimitAbove_of_finite g s c h.toAbove + +-- `Statement:` CONTROL: antisymmetry is a premise of the exclusion. On `Bool` preordered by `x ≤ y` +-- for all `x`, `y` (not a partial order), the constant run at `false` climbs and `true` occupies +-- `PinnedLimit id`. +example : ∃ inst : Preorder Bool, @PinnedLimit Bool inst id (fun _ => false) true := + ⟨{ le := fun _ _ => True, le_refl := fun _ => trivial, le_trans := fun _ _ _ _ _ => trivial, + lt := fun _ _ => False, lt_iff_le_not_ge := fun _ _ => by simp }, + ⟨fun _ _ => trivial, fun _ _ => trivial⟩, fun ⟨_, h⟩ => by simp at h, ⟨rfl, fun _ _ => trivial⟩, + fun _ _ _ => trivial⟩ + +-- `Statement:` CONTROL: on `Finset Bool` (four points) the step sending `{false}` to `{true}`, +-- `{true}` and `∅` to `{false}`, and fixing only `univ`, has the alternating run; `univ` is the least +-- upper bound of its stages, is not a stage, and is the least fixed point, the run does not climb, and +-- no point occupies `PinnedLimitUnique` there (`not_pinnedLimit_of_finite`). The climbing clause is +-- what fails here. The exclusion names no clause: at the `Fin 3` CONTROL below the run climbs and its +-- least upper bound `2` is a stage. +example : (Motion.ofFun fun x : Finset Bool => + if x = Finset.univ then Finset.univ else if x = {false} then {true} else {false}).IsRun + (fun n => if n % 2 = 0 then {false} else {true}) ∧ + (IsLUB (Set.range fun n => if n % 2 = 0 then ({false} : Finset Bool) else {true}) Finset.univ ∧ + Finset.univ ∉ Set.range (fun n => if n % 2 = 0 then ({false} : Finset Bool) else {true}) ∧ + IsLeast {x : Finset Bool | (if x = Finset.univ then Finset.univ else + if x = {false} then {true} else {false}) = x} Finset.univ) ∧ + ¬ Monotone (fun n => if n % 2 = 0 then ({false} : Finset Bool) else {true}) ∧ + ∀ c, ¬ PinnedLimitUnique (fun x : Finset Bool => + if x = Finset.univ then Finset.univ else if x = {false} then {true} else {false}) + (fun n => if n % 2 = 0 then {false} else {true}) c := by + have fix : ∀ x : Finset Bool, (if x = Finset.univ then Finset.univ else + if x = {false} then {true} else {false}) = x ↔ x = Finset.univ := by decide + refine ⟨fun n => ?_, ⟨⟨fun _ _ => Finset.subset_univ _, fun b hb => ?_⟩, ?_, ?_⟩, + fun h => absurd (h (Nat.zero_le 1)) (by decide), fun c h => not_pinnedLimit_of_finite _ _ c h.1⟩ + · show (if (n + 1) % 2 = 0 then ({false} : Finset Bool) else {true}) = + (fun x : Finset Bool => if x = Finset.univ then Finset.univ else + if x = {false} then {true} else {false}) (if n % 2 = 0 then {false} else {true}) + rcases Nat.mod_two_eq_zero_or_one n with h | h + · rw [if_neg (by omega : ¬ (n + 1) % 2 = 0), if_pos h]; decide + · rw [if_pos (by omega : (n + 1) % 2 = 0), if_neg (by omega : ¬ n % 2 = 0)]; decide + · have h0 : ({false} : Finset Bool) ⊆ b := hb ⟨0, rfl⟩ + have h1 : ({true} : Finset Bool) ⊆ b := hb ⟨1, rfl⟩ + intro y _ + cases y + · exact h0 (Finset.mem_singleton_self _) + · exact h1 (Finset.mem_singleton_self _) + · rintro ⟨n, hn⟩ + dsimp only at hn + split_ifs at hn <;> exact absurd hn (by decide) + · exact ⟨(fix _).2 rfl, fun x hx => ((fix x).1 hx) ▸ le_rfl⟩ + +-- `Statement:` on a complete lattice, for an ω-Scott-continuous `f`, `lfp f` meets clauses (a) and +-- (c) at the run from ⊥ of that lattice (Kleene's fixed-point theorem, Mathlib +-- `fixedPoints.lfp_eq_sSup_iterate`); the premises are the complete lattice and ω-Scott-continuity. +example {β : Type*} [CompleteLattice β] (f : β →o β) + (h : OmegaCompletePartialOrder.ωScottContinuous f) : + IsLUB (Set.range fun n => (⇑f)^[n] ⊥) f.lfp ∧ IsLeast {x | f x = x} f.lfp := + ⟨by rw [fixedPoints.lfp_eq_sSup_iterate f h]; exact isLUB_iSup, + ⟨f.map_lfp, fun _ hx => f.lfp_le_fixed hx⟩⟩ + +namespace NInf + +/-- `Statement:` tape-wise order: `x ≤ y` iff every `true` bit of `x` is a `true` bit of `y`. -/ +instance instPartialOrder : PartialOrder NInf where + le x y := ∀ i, x.1 i = true → y.1 i = true + le_refl _ _ h := h + le_trans _ _ _ h1 h2 i h := h2 i (h1 i h) + le_antisymm x y h1 h2 := ext fun i => by + cases hx : x.1 i <;> cases hy : y.1 i + · rfl + · exact absurd (h2 i hy) (by rw [hx]; decide) + · exact absurd (h1 i hx) (by rw [hy]; decide) + · rfl + +/-- `Statement:` the tape-wise order unfolded. -/ +theorem le_def (x y : NInf) : x ≤ y ↔ ∀ i, x.1 i = true → y.1 i = true := Iff.rfl + +-- `Statement:` it is the pointwise order of `ℕ → Bool` restricted to `NInf`. +example (x y : NInf) : x ≤ y ↔ ∀ i, x.1 i ≤ y.1 i := + forall_congr' fun i => by cases x.1 i <;> cases y.1 i <;> decide + +/-- `Statement:` ⊥ of `NInf` is `ofNat 0`. -/ +instance instOrderBot : OrderBot NInf where + bot := ofNat 0 + bot_le _ i h := by simp [ofNat] at h + +/-- `Statement:` ⊤ of `NInf` is `infty`. -/ +instance instOrderTop : OrderTop NInf where + top := infty + le_top _ _ _ := rfl + +/-- `Statement:` ⊥ of `NInf` is `ofNat 0`. -/ +theorem bot_eq : (⊥ : NInf) = ofNat 0 := rfl + +/-- `Statement:` ⊤ of `NInf` is `infty`. -/ +theorem top_eq : (⊤ : NInf) = infty := rfl + +-- `Statement:` ⊥ of `NInf` is the all-`false` tape and ⊤ of `NInf` the all-`true` tape. +example : (⊥ : NInf).1 = (fun _ => false) ∧ (⊤ : NInf).1 = (fun _ => true) := + ⟨funext fun i => by simp [bot_eq, ofNat], rfl⟩ + +/-- `Statement:` `ofNat m ≤ ofNat n ↔ m ≤ n`; both directions. -/ +theorem ofNat_le_iff (m n : ℕ) : ofNat m ≤ ofNat n ↔ m ≤ n := by + constructor + · intro h + rcases Nat.lt_or_ge n m with hc | hc + · have := h n (by simp [ofNat]; omega) + simp [ofNat] at this + · exact hc + · intro h i hi; simp [ofNat] at hi ⊢; omega + +/-- `Statement:` `x ≤ succ x`. -/ +theorem le_succ (x : NInf) : x ≤ succ x := fun i h => by + cases i with + | zero => rfl + | succ j => exact x.2 j h + +/-- `Statement:` if `succ x ≤ x`, then `x = ∞`. -/ +theorem eq_infty_of_succ_le (x : NInf) (h : succ x ≤ x) : x = infty := by + apply ext + intro i + induction i with + | zero => exact h 0 rfl + | succ j ih => exact h (j + 1) ih + +/-- `Statement:` `succ x = x ↔ x = ∞`; both directions. `Reading:` prior art in + `ZeroParadox/DieCannotBe.lean` § XXIX. -/ +theorem succ_fixed_iff (x : NInf) : succ x = x ↔ x = infty := + ⟨fun h => eq_infty_of_succ_le x (le_of_eq h), fun e => e ▸ succ_infty⟩ + +/-- `Statement:` `∞` is the least upper bound of the finite stages. -/ +theorem isLUB_range_ofNat : IsLUB (Set.range ofNat) infty := + ⟨fun _ _ => le_top, fun _ hb i _ => hb ⟨i + 1, rfl⟩ i (decide_eq_true (Nat.lt_succ_self i))⟩ + +/-- `Statement:` `∞` is not a finite stage. -/ +theorem infty_not_mem_range_ofNat : infty ∉ Set.range ofNat := fun ⟨n, hn⟩ => ofNat_ne_infty n hn + +/-- `Statement:` `ofNat` is a run of `Motion.ofFun succ`, and `∞` occupies `PinnedLimitUnique succ ofNat`. -/ +theorem pinnedLimitUnique_succ : + (Motion.ofFun succ).IsRun ofNat ∧ PinnedLimitUnique succ ofNat infty := + ⟨fun n => (succ_ofNat n).symm, + ⟨isLUB_range_ofNat, infty_not_mem_range_ofNat, + ⟨succ_infty, fun x hx => ((succ_fixed_iff x).1 hx) ▸ le_rfl⟩, + fun m n h => (ofNat_le_iff m n).2 h⟩, + fun x hx => (succ_fixed_iff x).1 hx⟩ + +/-- `Statement:` anything between `ofNat n` and `ofNat (n + 1)` is one of them. -/ +theorem eq_or_eq_of_between (n : ℕ) (c : NInf) (h1 : ofNat n ≤ c) (h2 : c ≤ ofNat (n + 1)) : + c = ofNat n ∨ c = ofNat (n + 1) := by + have lo : ∀ i, i < n → c.1 i = true := fun i hi => h1 i (decide_eq_true hi) + have hi' : ∀ i, n + 1 ≤ i → c.1 i = false := fun i hi => by + cases hc : c.1 i + · rfl + · have := of_decide_eq_true (h2 i hc); omega + cases hb : c.1 n + · left; exact ext fun i => by + show c.1 i = decide (i < n) + rcases Nat.lt_trichotomy i n with h | h | h + · rw [lo i h]; exact (decide_eq_true h).symm + · subst h; rw [hb]; exact (decide_eq_false (Nat.lt_irrefl _)).symm + · rw [hi' i h]; exact (decide_eq_false (by omega)).symm + · right; exact ext fun i => by + show c.1 i = decide (i < n + 1) + rcases Nat.lt_trichotomy i n with h | h | h + · rw [lo i h]; exact (decide_eq_true (by omega)).symm + · subst h; rw [hb]; exact (decide_eq_true (Nat.lt_succ_self _)).symm + · rw [hi' i h]; exact (decide_eq_false (by omega)).symm + +/-- `Statement:` `ofNat (n + 1)` covers `ofNat n`. -/ +theorem ofNat_covBy (n : ℕ) : ofNat n ⋖ ofNat (n + 1) := by + refine ⟨lt_of_le_of_ne ((ofNat_le_iff _ _).2 (by omega)) fun e => ?_, fun c h1 h2 => ?_⟩ + · have := (ofNat_le_iff (n + 1) n).1 (e ▸ le_rfl); omega + · rcases eq_or_eq_of_between n c h1.le h2.le with e | e + · exact h1.ne e.symm + · exact h2.ne e + +/-- `Statement:` `EveryStepCovered NInf`, with the witness `succ x` at each non-maximal `x`. -/ +theorem everyStepCovered : EveryStepCovered NInf := by + intro x hx + have hne : x ≠ infty := fun e => hx (by rw [e]; exact fun _ _ => le_top) + refine ⟨succ x, lt_of_le_of_ne (le_succ x) fun e => hne (eq_infty_of_succ_le x (e ▸ le_rfl)), + fun c h1 h2 => ?_⟩ + apply not_not_exists_ofNat x hne + rintro ⟨k, rfl⟩ + rw [succ_ofNat] at h2 + rcases eq_or_eq_of_between k c h1.le h2.le with e | e + · exact h1.ne e.symm + · exact h2.ne e + +/-- `Statement:` no point is covered by `∞`. -/ +theorem not_covBy_infty (b : NInf) : ¬ b ⋖ infty := by + intro h + apply not_not_exists_ofNat b h.lt.ne + rintro ⟨k, rfl⟩ + exact h.2 (ofNat_covBy k).lt (lt_of_le_of_ne le_top (ofNat_ne_infty _)) + +/-- `Statement:` `∞` is a successor limit of `NInf` (Mathlib `Order.IsSuccLimit`). -/ +theorem isSuccLimit_infty : Order.IsSuccLimit infty := + ⟨fun h => ofNat_ne_infty 0 (le_antisymm bot_le (h (bot_le : (⊥ : NInf) ≤ infty))), + fun b => not_covBy_infty b⟩ + +/-- `Statement:` every finite stage is covered by the next, `BotCovered` and `EveryStepCovered` hold, + `∞` is a successor limit, and some `e : (NInf → Bool) → NInf` has `p (e p) = true → ∀ x, p x = true` + for every `p` (witness `eps`, by `eps_spec`). -/ +theorem covered_limit_searchable : + (∀ n : ℕ, ofNat n ⋖ ofNat (n + 1)) ∧ BotCovered NInf ∧ EveryStepCovered NInf ∧ + Order.IsSuccLimit infty ∧ + ∃ e : (NInf → Bool) → NInf, ∀ p : NInf → Bool, p (e p) = true → ∀ x, p x = true := + ⟨ofNat_covBy, ⟨ofNat 1, ofNat_covBy 0⟩, everyStepCovered, isSuccLimit_infty, ⟨eps, eps_spec⟩⟩ + +section +-- [ZP port] Lean 4.35: `WithTop.instPreorder` carries `Classical.choice` (`le_def` by `grind`); +-- `≃o` needs only `≤`, so pin the bare choice-free `WithTop.instLE` here. +attribute [local instance high] WithTop.instLE + +/-- `Statement:` any order isomorphism `NInf ≃o WithTop ℕ` gives WLPO. `Reading:` by + `wlpo_of_discrete_tag` at `D = WithTop ℕ`, whose `DecidableEq` is an instance. -/ +theorem wlpo_of_iso (e : NInf ≃o WithTop ℕ) : + ∀ r : ℕ → Bool, (∀ n, r n = false) ∨ ¬ ∀ n, r n = false := + wlpo_of_discrete_tag e fun _ => e.injective.eq_iff + +end + +-- `Statement:` the order is not used: any injection into `WithTop ℕ` gives WLPO. +example (e : NInf → WithTop ℕ) (he : Function.Injective e) : + ∀ r : ℕ → Bool, (∀ n, r n = false) ∨ ¬ ∀ n, r n = false := + wlpo_of_discrete_tag e fun _ => he.eq_iff + +/-- `Statement:` `WithTop ℕ → NInf`, `⊤ ↦ ∞` and `n ↦ ofNat n`. -/ +def ofWithTop : WithTop ℕ → NInf + | ⊤ => infty + | (n : ℕ) => ofNat n + +section +-- [ZP port] Lean 4.35: Mathlib's `WithTop` `Preorder` carries `Classical.choice`; scope `ZeroParadox/Order/ChoiceFreeWithTop.lean`'s. +attribute [local instance high] withTopPreorderCF + +/-- `Statement:` `ofWithTop` is strictly monotone. -/ +theorem ofWithTop_strictMono : StrictMono ofWithTop := by + intro a b hab + change WithTop.LT a b at hab + cases a with + | top => cases hab + | coe m => + cases b with + | top => exact lt_of_le_of_ne le_top (ofNat_ne_infty m) + | coe n => + have hmn : m < n := by cases hab with | coe_lt_coe h => exact h + refine lt_of_le_of_ne ((ofNat_le_iff _ _).2 hmn.le) fun e => ?_ + have := (ofNat_le_iff n m).1 (le_of_eq (show ofNat n = ofNat m from e.symm)); omega + +end + +/-- `Statement:` CONTROL: `NInf ≃o WithTop ℕ` from `Classical.propDecidable`, so `wlpo_of_iso`'s + hypothesis is inhabited classically. -/ +noncomputable def orderIsoWithTopClassical : NInf ≃o WithTop ℕ := + (StrictMono.orderIsoOfSurjective ofWithTop ofWithTop_strictMono fun x => by + classical + by_cases h : ∃ k, x = ofNat k + · obtain ⟨k, rfl⟩ := h; exact ⟨k, rfl⟩ + · exact ⟨⊤, (eq_infty_of_ne_ofNat x fun k e => h ⟨k, e⟩).symm⟩).symm + +end NInf + +/-- `Statement:` `WithTop ℕ`, step `· + 1`, stages the coercion: `⊤` occupies + `PinnedLimitUnique`. `Statement:` INVARIANT: the predicate `PinnedLimitUnique` holds at `NInf`'s `∞` + (`NInf.pinnedLimitUnique_succ`) and at `WithTop ℕ`'s `⊤`, so it does not separate the two + carriers; identifying them by an order isomorphism costs WLPO (`NInf.wlpo_of_iso`). -/ +theorem pinnedLimitUnique_withTop : + (Motion.ofFun fun x : WithTop ℕ => x + 1).IsRun (fun n : ℕ => (n : WithTop ℕ)) ∧ + PinnedLimitUnique (fun x : WithTop ℕ => x + 1) (fun n : ℕ => (n : WithTop ℕ)) ⊤ := by + have fix : ∀ x : WithTop ℕ, x + 1 = x ↔ x = ⊤ := fun x => by + constructor + · intro h + cases x with + | top => rfl + | coe n => + exfalso + rw [← WithTop.coe_one, ← WithTop.coe_add, WithTop.coe_inj] at h + exact Nat.succ_ne_self n h + · rintro rfl; rfl + refine ⟨fun n => show ((n + 1 : ℕ) : WithTop ℕ) = (n : WithTop ℕ) + 1 by simp, + ⟨⟨fun _ _ => le_top, fun b hb => ?_⟩, fun ⟨n, hn⟩ => WithTop.coe_ne_top hn, + ⟨rfl, fun x hx => ((fix x).1 hx) ▸ le_rfl⟩, fun a b h => show (a : WithTop ℕ) ≤ b by exact_mod_cast h⟩, + fun x hx => (fix x).1 hx⟩ + cases b with + | top => exact le_rfl + | coe m => + exfalso + have := hb ⟨m + 1, rfl⟩ + exact absurd (Nat.cast_le.1 this) (by omega) + +-- `Statement:` CONTROL: `ℕ` with `Nat.succ` has a run and no occupant (no fixed point). +example : (Motion.ofFun Nat.succ).IsRun id ∧ ∀ c : ℕ, ¬ PinnedLimit Nat.succ id c := + ⟨fun _ => rfl, fun c ⟨_, _, ⟨hfix, _⟩, _⟩ => Nat.succ_ne_self c hfix⟩ + +-- `Statement:` CONTROL: on `Fin 3` with step `![1, 2, 2]`, the run from `0` climbs, and its least +-- upper bound `2` is a fixed point and a stage, so there is no occupant. +example : (Motion.ofFun (![1, 2, 2] : Fin 3 → Fin 3)).IsRun + (fun n => (![1, 2, 2] : Fin 3 → Fin 3)^[n] 0) ∧ + Monotone (fun n => (![1, 2, 2] : Fin 3 → Fin 3)^[n] 0) ∧ + ∀ c : Fin 3, ¬ PinnedLimit (![1, 2, 2] : Fin 3 → Fin 3) + (fun n => (![1, 2, 2] : Fin 3 → Fin 3)^[n] 0) c := by + refine ⟨fun n => show (![1, 2, 2] : Fin 3 → Fin 3)^[n + 1] 0 = _ by + simp only [Function.iterate_succ_apply'], + Monotone.monotone_iterate_of_le_map (by decide) (by decide), ?_⟩ + rintro c ⟨hlub, hnot, _⟩ + have h2 : (![1, 2, 2] : Fin 3 → Fin 3)^[2] 0 = 2 := rfl + have hle : (2 : Fin 3) ≤ c := h2 ▸ hlub.1 ⟨2, rfl⟩ + have hc : c = 2 := le_antisymm (by fin_cases c <;> decide) hle + exact hnot ⟨2, h2.trans hc.symm⟩ + +-- `Statement:` CONTROL: on `NInf` with `g = id`, the least fixed point is ⊥ of `NInf`, `ofNat 0`, not +-- the least upper bound `∞` of the stages, so no point occupies `PinnedLimit id NInf.ofNat`. +example : IsLeast {x : NInf | id x = x} (NInf.ofNat 0) ∧ + ∀ c : NInf, ¬ PinnedLimit id NInf.ofNat c := by + refine ⟨⟨rfl, fun _ _ => bot_le⟩, fun c ⟨hlub, _, ⟨_, hleast⟩, _⟩ => ?_⟩ + have hc : c = NInf.infty := hlub.unique NInf.isLUB_range_ofNat + have hbot : c ≤ NInf.ofNat 0 := hleast (show id (NInf.ofNat 0) = NInf.ofNat 0 from rfl) + rw [hc] at hbot + exact absurd (hbot 0 rfl) (by decide) + +/-! ### § XXV. First-occurrence time as a Galois insertion: tapes onto `NInf`, order reversed +`Reading:` Tim's "bend" (2026-11-03): one tape read two ways, as a firing record in `ℕ → Bool` +(pointwise order, Mathlib's `Pi` instance) and as its waiting time `det` in `NInf`. "Time" is his +reading only; nothing here is a claim about physics. -/ + +namespace NInf + +/-- `Statement:` ⊥ of `NInf` and ⊤ of `NInf` together, as Mathlib's `BoundedOrder`. -/ +instance instBoundedOrder : BoundedOrder NInf := { instOrderBot, instOrderTop with } + +/-- `Statement:` on `ℕ → Bool`, `r ≤ r'` iff every `true` bit of `r` is a `true` bit of `r'`. -/ +theorem tape_le_iff (r r' : ℕ → Bool) : r ≤ r' ↔ ∀ i, r i = true → r' i = true := by + refine forall_congr' fun i => ?_ + cases r i <;> cases r' i <;> simp + +/-- `Statement:` `detSeq r n = true` iff `r k = false` for every `k ≤ n`; both directions. -/ +theorem detSeq_eq_true_iff (r : ℕ → Bool) (n : ℕ) : + detSeq r n = true ↔ ∀ k ≤ n, r k = false := by + refine ⟨detSeq_true r n, ?_⟩ + induction n with + | zero => intro h; simp [detSeq, h 0 le_rfl] + | succ n ih => + intro h + simp [detSeq, ih (fun k hk => h k (by omega)), h (n + 1) le_rfl] + +/-- `Statement:` ⊥ of `ℕ → Bool` is below every tape, with axioms `[propext]`. -/ +theorem tape_bot_le (r : ℕ → Bool) : (⊥ : ℕ → Bool) ≤ r := + (tape_le_iff _ _).2 fun _ h => Bool.noConfusion h + +/-- `Statement:` by Mathlib's `bot_le`, axioms `[propext, Classical.choice, Quot.sound]`. -/ +theorem mathlib_bot_le_tape (r : ℕ → Bool) : (⊥ : ℕ → Bool) ≤ r := bot_le + +/-- `Statement:` `det` is antitone: if every `true` bit of `r` is a `true` bit of `r'`, then + `det r' ≤ det r`. -/ +theorem det_antitone : Antitone det := by + intro r r' hle + rw [le_def]; intro i hi + have hi' := (detSeq_eq_true_iff r' i).1 hi + show detSeq r i = true + rw [detSeq_eq_true_iff] + intro k hk + cases hr : r k + · rfl + · have := (tape_le_iff r r').1 hle k hr; rw [hi' k hk] at this; cases this + +/-- `Statement:` `det` sends ⊥ of `ℕ → Bool` to ⊤ of `NInf` and ⊤ of `ℕ → Bool` to ⊥ of `NInf`. -/ +theorem det_poles : det ⊥ = ⊤ ∧ det ⊤ = ⊥ := by + refine ⟨(det_eq_infty_iff _).2 fun _ => rfl, ext fun i => ?_⟩ + cases i <;> simp [det, detSeq] <;> rfl + +/-- `Statement:` the bitwise complement of a point of `NInf`, as a tape. -/ +def negS (x : NInf) : ℕ → Bool := fun n => !x.1 n + +/-- `Statement:` `det (negS x) = x`: `negS` is a section of `det`. -/ +theorem det_negS (x : NInf) : det (negS x) = x := ext fun n => by + show detSeq (negS x) n = x.1 n + cases hx : x.1 n + · cases hd : detSeq (negS x) n + · rfl + · have := (detSeq_eq_true_iff _ n).1 hd n le_rfl; simp [negS, hx] at this + · rw [detSeq_eq_true_iff]; intro k hk; simp [negS, true_le x hx k hk] + +/-- `Statement:` `negS` is antitone. -/ +theorem negS_antitone : Antitone negS := by + intro x y h + rw [tape_le_iff]; intro i hi + cases hx : x.1 i + · simp [negS, hx] + · have := h i hx; simp [negS, this] at hi + +/-- `Statement:` `x ≤ det r ↔ r ≤ negS x`; both directions. -/ +theorem le_det_iff (r : ℕ → Bool) (x : NInf) : x ≤ det r ↔ r ≤ negS x := by + rw [le_def, tape_le_iff] + constructor + · intro h i hr + cases hx : x.1 i + · simp [negS, hx] + · have := (detSeq_eq_true_iff r i).1 (h i hx) i le_rfl; rw [hr] at this; cases this + · intro h i hx + show detSeq r i = true + rw [detSeq_eq_true_iff]; intro k hk + cases hr : r k + · rfl + · have := h k hr; simp [negS, true_le x hx k hk] at this + +/-- `Statement:` `det` into the order dual of `NInf` is the lower adjoint of a Galois connection + (Mathlib `GaloisConnection`) with upper adjoint `negS`. -/ +theorem det_gc : + GaloisConnection (OrderDual.toDual ∘ det) (negS ∘ OrderDual.ofDual) := + fun r x => OrderDual.toDual_le.trans (le_det_iff r (OrderDual.ofDual x)) + +/-- `Statement:` and a Galois insertion (Mathlib `GaloisInsertion`): the upper adjoint `negS` is a + section of `det`. `Reading:` Tim's "bend" (2026-11-03). -/ +def det_gi : GaloisInsertion (OrderDual.toDual ∘ det) (negS ∘ OrderDual.ofDual) := + det_gc.toGaloisInsertion fun x => by + show x ≤ OrderDual.toDual (det (negS (OrderDual.ofDual x))) + rw [det_negS]; exact le_rfl +-- `Statement:` on 2-adic digit tapes `det` is the 2-adic valuation (`ZeroParadox/Category/IgnoranceSeam.lean` § VIII). + +-- `Statement:` `det r` is the bitwise complement of Mathlib's `partialSups r`, on `Bool` the running +-- "or" (has `r` fired by stage `n`), pointwise at every `n`. +example (r : ℕ → Bool) (n : ℕ) : (det r).1 n = !(partialSups r n) := by + induction n with + | zero => simp [det, detSeq] + | succ n ih => + have e : partialSups r (n + 1) = (partialSups r n || r (n + 1)) := by + rw [← Order.succ_eq_add_one, partialSups_succ, Order.succ_eq_add_one]; rfl + show (detSeq r n && !r (n + 1)) = _ + rw [show detSeq r n = (det r).1 n from rfl, ih, e] + cases partialSups r n <;> cases r (n + 1) <;> rfl + +-- `Statement:` Mathlib's `partialSups.gi`: a Galois insertion of `ℕ → Bool` onto its monotone sequences. +-- Axioms: `det_gi` `[propext, Quot.sound]`; `partialSups.gi` `[propext, Classical.choice, Quot.sound]`. +noncomputable example : GaloisInsertion (partialSups : (ℕ → Bool) → ℕ →o Bool) DFunLike.coe := + partialSups.gi + +-- `Statement:` `det r` is the first hitting time of `true` in `r`: `ofNat (Nat.find hw)` when `r` fires; +-- when it never fires, `det r = infty` (`det_eq_infty_iff`). +example (r : ℕ → Bool) (hw : ∃ k, r k = true) : det r = ofNat (Nat.find hw) := by + apply ext; intro i + show detSeq r i = decide (i < Nat.find hw) + cases hd : detSeq r i + · obtain ⟨k, hk, e⟩ := detSeq_false r i hd + have := Nat.find_min' hw e + exact (decide_eq_false (by omega)).symm + · have h := (detSeq_eq_true_iff r i).1 hd + symm; refine decide_eq_true ?_ + by_contra hc + have := h (Nat.find hw) (by omega); rw [Nat.find_spec hw] at this; cases this + +-- `Statement:` `det r` satisfies TypeTopology's two `force-decreasing` equations at `β = !r`: `!r 0` at +-- `0`, and `min₂ (β (n + 1)) (force-decreasing β n)` at `n + 1`, with `&&` for `min₂`. +example (r : ℕ → Bool) (n : ℕ) : + (det r).1 0 = !r 0 ∧ (det r).1 (n + 1) = (!r (n + 1) && (det r).1 n) := + ⟨rfl, Bool.and_comm _ _⟩ + +/-- `Statement:` `det` as a bounded order homomorphism (Mathlib `BoundedOrderHom`) from `ℕ → Bool` + into the order dual of `NInf`. -/ +def detHom : BoundedOrderHom (ℕ → Bool) NInfᵒᵈ where + toFun r := OrderDual.toDual (det r) + monotone' := fun _ _ h => det_antitone h + map_top' := congrArg OrderDual.toDual det_poles.2 + map_bot' := congrArg OrderDual.toDual det_poles.1 + +/-- `Statement:` no adjoint on the other side: no `g` has `g x ≤ r ↔ det r ≤ x` for all `x`, `r`. -/ +theorem no_lower_adjoint : ¬ ∃ g : NInf → ℕ → Bool, ∀ x r, g x ≤ r ↔ det r ≤ x := by + rintro ⟨g, hg⟩ + have h1 : det (fun n => decide (n = 0)) ≤ ofNat 1 := by + rw [le_def]; intro i hi + exact absurd ((detSeq_eq_true_iff _ i).1 hi 0 (Nat.zero_le _)) (by decide) + have h2 : det (fun n => decide (n = 1)) ≤ ofNat 1 := by + rw [le_def]; intro i hi + cases i with + | zero => rfl + | succ j => -- [ZP port] Lean 4.35: tape argument named; no longer inferred through `det` + exact absurd ((detSeq_eq_true_iff (fun n => decide (n = 1)) (j + 1)).1 hi 1 (by omega)) + (by decide) + have g1 := (tape_le_iff _ _).1 ((hg _ _).2 h1) + have g2 := (tape_le_iff _ _).1 ((hg _ _).2 h2) + have hbot : g (ofNat 1) ≤ (fun _ => false) := by + rw [tape_le_iff]; intro i hi + have a := g1 i hi; have b := g2 i hi + simp only [decide_eq_true_eq] at a b; subst a; cases b + have h3 := (hg _ _).1 hbot + have e := (det_eq_infty_iff (fun _ : ℕ => false)).2 fun _ => rfl + rw [e, le_def] at h3 + exact absurd (h3 1 rfl) (by decide) + +/-- `Statement:` the tape firing exactly at `n` has waiting time `ofNat n`. -/ +theorem det_fire (n : ℕ) : det (fun k => decide (k = n)) = ofNat n := ext fun i => by + show detSeq _ i = decide (i < n) + cases hd : detSeq (fun k => decide (k = n)) i + · obtain ⟨k, hk, e⟩ := detSeq_false _ i hd + simp only [decide_eq_true_eq] at e; subst e; exact (decide_eq_false (by omega)).symm + · have := (detSeq_eq_true_iff _ i).1 hd + symm; refine decide_eq_true ?_; by_contra hc; have := this n (by omega); simp at this + +/-- `Statement:` `det` is not injective. -/ +theorem det_not_injective : ¬ Function.Injective det := fun h => by + have e := h ((det_fire 0).trans det_poles.2.symm) + have := congrFun e 1; simp at this + +/-- `Statement:` the tape `true` at `n` iff `x.1 n = false` and (`n = 0` or `x.1 (n - 1) = true`): + at `ofNat j` the tape firing exactly at `j`, at `infty` the tape that never fires (examples below). -/ +def exactS (x : NInf) : ℕ → Bool := + fun n => !x.1 n && (match n with | 0 => true | m + 1 => x.1 m) + +-- `Statement:` `exactS (ofNat j)` fires exactly at `j`. +example (j : ℕ) : exactS (ofNat j) = fun k => decide (k = j) := by + funext k + cases k with + | zero => cases j <;> simp [exactS, ofNat] + | succ m => + show (!decide (m + 1 < j) && decide (m < j)) = decide (m + 1 = j) + by_cases h : m + 1 = j + · subst h; simp + · rw [decide_eq_false h]; by_cases h2 : m < j + · rw [decide_eq_true (show m + 1 < j by omega)]; rfl + · rw [decide_eq_false h2]; simp + +-- `Statement:` `exactS infty` is the all-`false` tape. +example : exactS infty = fun _ => false := by + funext k; cases k <;> rfl + +/-- `Statement:` `det (exactS x) = x`: `exactS` is a second section of `det`. -/ +theorem det_exactS (x : NInf) : det (exactS x) = x := ext fun n => by + show detSeq (exactS x) n = x.1 n + cases hx : x.1 n + · obtain ⟨j, hj, rfl⟩ := eq_ofNat_of_false x n hx + cases hd : detSeq (exactS (ofNat j)) n + · rfl + · have h := (detSeq_eq_true_iff _ n).1 hd j hj + cases j with + | zero => exact absurd h (by decide) + | succ m => + have e1 : (ofNat (m + 1)).1 (m + 1) = false := decide_eq_false (Nat.lt_irrefl _) + have e2 : (ofNat (m + 1)).1 m = true := decide_eq_true (Nat.lt_succ_self m) + have h' : exactS (ofNat (m + 1)) (m + 1) = true := by + show (!(ofNat (m + 1)).1 (m + 1) && (ofNat (m + 1)).1 m) = true + rw [e1, e2]; rfl + rw [h] at h'; cases h' + · rw [detSeq_eq_true_iff]; intro k hk + cases k with + | zero => show (!x.1 0 && true) = false; rw [true_le x hx 0 hk]; rfl + | succ m => show (!x.1 (m + 1) && x.1 m) = false; rw [true_le x hx _ hk]; rfl + +/-- `Statement:` `exactS` is neither antitone nor monotone. -/ +theorem exactS_not_mono : ¬ Antitone exactS ∧ ¬ Monotone exactS := by + have h01 : ofNat 0 ≤ ofNat 1 := bot_le + refine ⟨fun h => ?_, fun h => ?_⟩ + · exact absurd (h h01 1) (by decide) + · exact absurd (h h01 0) (by decide) + +/-- `Statement:` the tape `n ↦ x.1 n && !x.1 (n + 1)`. -/ +def naiveS (x : NInf) : ℕ → Bool := fun n => x.1 n && !x.1 (n + 1) + +/-- `Statement:` `naiveS` is not a section of `det`: `det (naiveS (ofNat 0)) = ∞ ≠ ofNat 0`. -/ +theorem naiveS_fails : det (naiveS (ofNat 0)) = infty ∧ det (naiveS (ofNat 0)) ≠ ofNat 0 := by + have h : det (naiveS (ofNat 0)) = infty := + (det_eq_infty_iff _).2 fun n => by simp [naiveS, ofNat] + exact ⟨h, by rw [h]; exact (ofNat_ne_infty 0).symm⟩ + +/-- `Statement:` CONTROL: the constant map `ofNat 0` is antitone and does not send ⊥ of `ℕ → Bool` + to ⊤ of `NInf`. -/ +theorem const0_fails : Antitone (fun _ : ℕ → Bool => (ofNat 0 : NInf)) ∧ + (fun _ : ℕ → Bool => (ofNat 0 : NInf)) ⊥ ≠ ⊤ := + ⟨fun _ _ _ => le_rfl, ofNat_ne_infty 0⟩ + +/-- `Statement:` CONTROL: the constant map `∞` is antitone and does not send ⊤ of `ℕ → Bool` to ⊥ + of `NInf`. -/ +theorem constInf_fails : Antitone (fun _ : ℕ → Bool => (infty : NInf)) ∧ + (fun _ : ℕ → Bool => (infty : NInf)) ⊤ ≠ ⊥ := + ⟨fun _ _ _ => le_rfl, fun h => ofNat_ne_infty 0 h.symm⟩ + +/-- `Statement:` the map reading only bit `0`: `ofNat 0` if it is `true`, else `∞`. -/ +def firstBitWait (r : ℕ → Bool) : NInf := cond (r 0) (ofNat 0) infty + +/-- `Statement:` CONTROL: `firstBitWait` is antitone, sends ⊥ of `ℕ → Bool` to ⊤ of `NInf` and ⊤ of + `ℕ → Bool` to ⊥ of `NInf`, and is not `det`. -/ +theorem head_also_poles : Antitone firstBitWait ∧ firstBitWait ⊥ = ⊤ ∧ + firstBitWait ⊤ = ⊥ ∧ firstBitWait ≠ det := by + refine ⟨fun r r' h => ?_, rfl, rfl, fun e => ?_⟩ + · cases h0 : r 0 + · show firstBitWait r' ≤ cond (r 0) (ofNat 0) infty + rw [h0]; exact le_top + · have : r' 0 = true := (tape_le_iff r r').1 h 0 h0 + show cond (r' 0) (ofNat 0) infty ≤ _ + rw [this]; exact bot_le + · have := congrArg (fun f => (f (fun n => decide (n = 1))).1 1) e + simp [firstBitWait, det, detSeq, infty] at this + exact absurd this (by decide) -- [ZP port] Lean 4.35: `simp` no longer reduces the `cond` + +/-- `Statement:` CONTROL for `det_poles`: no `b : ℕ` is a top of `ℕ`, so no map `(ℕ → Bool) → ℕ` sends + ⊥ of `ℕ → Bool` to a top, as `det` sends it to ⊤ of `NInf` (example below). -/ +theorem nat_no_top (b : ℕ) : ¬ IsTop b := not_isTop b + +-- `Statement:` no `f : (ℕ → Bool) → ℕ` sends ⊥ of `ℕ → Bool` to a top of `ℕ`. +example (f : (ℕ → Bool) → ℕ) : ¬ IsTop (f ⊥) := nat_no_top _ + +/-- `Statement:` CONTROL: no antitone `f : (ℕ → Bool) → ℕ` sends the tape firing exactly at `n` to + `n` for every `n`. -/ +theorem no_nat_wait : + ¬ ∃ f : (ℕ → Bool) → ℕ, Antitone f ∧ ∀ n, f (fun k => decide (k = n)) = n := by + rintro ⟨f, hf, hn⟩ + have := hf (tape_bot_le fun k => decide (k = f ⊥ + 1)) + rw [hn] at this; exact Nat.not_succ_le_self _ this + +/-- `Statement:` `det` of ⊥ of `ℕ → Bool` occupies `PinnedLimitUnique succ ofNat` + (`pinnedLimitUnique_succ`, § XXIV). -/ +theorem det_bot_pinnedLimitUnique : PinnedLimitUnique succ ofNat (det ⊥) := + det_poles.1 ▸ pinnedLimitUnique_succ.2 + +end NInf + end ZeroParadox section PurityCheck @@ -4731,5 +5622,80 @@ open ZeroParadox #print axioms Motion.loopAt_image_iff_leftInverse #print axioms Motion.loopAt_image_iff_loopAt_all #print axioms Motion.lpo_of_loopAt_image +#print axioms NInf.wlpo_of_discrete_tag +#print axioms NInf.RosPart +#print axioms NInf.toRos +#print axioms NInf.lpo_of_toRos_surjective +#print axioms NInf.toRos_surjective_of_lpo +#print axioms NInf.toRos_surjective_iff +#print axioms NInf.AllRosolini +#print axioms NInf.allRosolini_of_em +#print axioms NInf.em_of_allRosolini_lpo +#print axioms NInf.rosIncl_surjective_iff +#print axioms Motion.wem_of_selectedTotal_propStep +#print axioms Motion.em_of_trichotomy_propStep +#print axioms Motion.trichotomy_of_em +#print axioms PinnedLimit +#print axioms PinnedLimitUnique +#print axioms PinnedLimitAbove +#print axioms PinnedLimit.toAbove +#print axioms pinnedLimitAbove_iff_of_bot +#print axioms pinnedLimit_iff_closure_omega +#print axioms not_pinnedLimitAbove_of_finite +#print axioms not_pinnedLimit_of_finite +#print axioms NInf.instPartialOrder +#print axioms NInf.le_def +#print axioms NInf.instOrderBot +#print axioms NInf.instOrderTop +#print axioms NInf.bot_eq +#print axioms NInf.top_eq +#print axioms NInf.ofNat_le_iff +#print axioms NInf.le_succ +#print axioms NInf.eq_infty_of_succ_le +#print axioms NInf.succ_fixed_iff +#print axioms NInf.isLUB_range_ofNat +#print axioms NInf.infty_not_mem_range_ofNat +#print axioms NInf.pinnedLimitUnique_succ +#print axioms NInf.eq_or_eq_of_between +#print axioms NInf.ofNat_covBy +#print axioms NInf.everyStepCovered +#print axioms NInf.not_covBy_infty +#print axioms NInf.isSuccLimit_infty +#print axioms NInf.covered_limit_searchable +#print axioms NInf.wlpo_of_iso +#print axioms NInf.ofWithTop +#print axioms NInf.ofWithTop_strictMono +#print axioms NInf.orderIsoWithTopClassical +#print axioms pinnedLimitUnique_withTop + +#print axioms NInf.instBoundedOrder +#print axioms NInf.tape_le_iff +#print axioms NInf.detSeq_eq_true_iff +#print axioms NInf.tape_bot_le +#print axioms NInf.mathlib_bot_le_tape +#print axioms NInf.det_antitone +#print axioms NInf.det_poles +#print axioms NInf.negS +#print axioms NInf.det_negS +#print axioms NInf.negS_antitone +#print axioms NInf.le_det_iff +#print axioms NInf.det_gc +#print axioms NInf.det_gi +#print axioms NInf.detHom +#print axioms NInf.no_lower_adjoint +#print axioms NInf.det_fire +#print axioms NInf.det_not_injective +#print axioms NInf.exactS +#print axioms NInf.det_exactS +#print axioms NInf.exactS_not_mono +#print axioms NInf.naiveS +#print axioms NInf.naiveS_fails +#print axioms NInf.const0_fails +#print axioms NInf.constInf_fails +#print axioms NInf.firstBitWait +#print axioms NInf.head_also_poles +#print axioms NInf.nat_no_top +#print axioms NInf.no_nat_wait +#print axioms NInf.det_bot_pinnedLimitUnique end PurityCheck diff --git a/ZeroParadox/DieCannotBe.lean b/ZeroParadox/DieCannotBe.lean index 4fe2c4ed..0dfe2939 100644 --- a/ZeroParadox/DieCannotBe.lean +++ b/ZeroParadox/DieCannotBe.lean @@ -5,6 +5,7 @@ import ZeroParadox.Computability.GroundZero import ZeroParadox.Valuation.FloorWitness import ZeroParadox.Ordinal.Epsilon0LeastFP import ZeroParadox.Ordinal.Gentzen +import ZeroParadox.Ordinal.Incompleteness import ZeroParadox.Computability.Occurrence import ZeroParadox.Valuation.PoleRegistration import ZeroParadox.Valuation.PoleChartSelection @@ -48,6 +49,10 @@ import ZeroParadox.Order.LeastFixedPoint import ZeroParadox.Valuation.SemilatticeInstance import ZeroParadox.Settheory.OntBridge import ZeroParadox.Settheory.Model +import ZeroParadox.Order.SeamSchema +import ZeroParadox.Information.CrossingTrials +import ZeroParadox.Order.DieJoints +import ZeroParadox.Information.SnapEpsilonZero set_option maxHeartbeats 400000 @@ -103,12 +108,18 @@ example {α : Type} (f : α → α) : IsIdempotentElem (show Function.End α fro -- (p. 26). Neither is imposed here. No counterpart of the switches was located in these two sources -- as of 2026-10-18 (UP is total in both; their text, searched for "partial", "loop" and "cycle", has -- no hit bearing on a switch); the dated search for the pair is in `LEAN_CUSTOM_REGISTRY.md`. The --- loop/climb split as a named pair, not located closer than Meseguer and R. Diaconescu as of --- 2026-10-22, searched by theoremsearch alone (its null is uninformative on its own) in three --- phrasings: "rewrite step from a normal form followed by normalization returns to the same or a --- different normal form"; "stuttering step ... quotient transition system"; "closing a cover of a --- closed element yields the next closed element"; and by one web search the same day in rewriting, --- normal-form, stutter and closure-cover vocabulary. +-- loop/climb split has a standard name on transitions: within a corner, labelling each point by its +-- UP value, a loop step is a stutter step (Sharma, arXiv:1210.0408, Def. 5, p. 4: "Transition +-- s → s′ ... is a stutter step if L(s) = L(s′)"), and a climb step is one that is not; UP is +-- partial here, where a Kripke labelling is total. Sharma is cited as a locator for the term, not +-- as its origin; no source for its origin was read. Located 2026-10-31 by theoremsearch only, +-- three phrasings varied by axis, verbatim: "a rewrite step from a normal form followed by +-- normalization returns to the same normal form or reaches a different one" (rewriting +-- vocabulary); "after one rule application and renormalization the normal form never returns to the +-- original normal form" (polarity: the wording if the split were refused); "stuttering steps versus +-- visible steps of a transition system on equivalence classes of states" (concurrency vocabulary); +-- the third returned Sharma's definition, retrieved and read at the page cited. No web search is +-- recorded. -- Reading: the adjoined-points switch is a CHOICE OF CARRIER: `Option σ` adjoins one point and -- `Option (Option σ)` two (the `TriStep` example below). `Pointed` and `Bipointed` carry -- distinguished points, not adjoined ones, and `Bipointed`'s two may coincide. @@ -149,7 +160,33 @@ example : ¬ ∃ t : WithBot ℤ, IsTop t := by induction t using WithBot.recBotCoe with | bot => exact WithBot.not_coe_le_bot 0 (ht 0) | coe a => exact absurd (WithBot.coe_le_coe.1 (ht ((a + 1 : ℤ) : WithBot ℤ))) (by omega) -#check @ZeroParadox.Motion.UpTotal -- Statement: UP switch at total: `up` defined everywhere +-- Reading: CARRIER. An end approached from one side and not reached there is a cut point of this +-- shape: a joint from below, a dual joint from above (`ZeroParadox/Order/DieJoints.lean`). If an end +-- is adjoined as the limit of the finite stages, it is a joint with the stages as its lower side: ⊤ of `ℕ∞` +-- (`enat_top_isJoint`), NInf's `∞` (`NInf.infty_isJoint`); more generally every occupant of `PinnedLimit` +-- in a partial order is a joint (`PinnedLimit.isJoint`), ε₀ among them, which is neither end of `Ordinal`. +-- ⊥ of a well-founded linear order, ⊥ of `Ordinal` among them, is neither (`not_isJoint_of_isBot`, +-- `not_isDualJoint_of_wellFoundedLT`). "Joint" here names the order shape only (in a linear order, +-- Mathlib's successor limit at the canonical cut); it is not claimed to be the joint of +-- Tim's 2026-10-22 read below. +#check @ZeroParadox.IsCutPoint -- Statement: `A` lies below `B`, and `x` is the least upper bound of `A` and the greatest lower bound of `B` +#check @ZeroParadox.IsJoint -- Statement: a cut point of `(A, B)` lying in `B`, with `A` nonempty and without a greatest element +#check @ZeroParadox.IsDualJoint -- Statement: a cut point of `(A, B)` lying in `A`, with `B` nonempty and without a least element +#check @ZeroParadox.isJoint_toDual_iff -- Statement: a joint of `(B, A)` in `αᵒᵈ` iff a dual joint of `(A, B)` in `α`; both directions +#check @ZeroParadox.isDualJoint_toDual_iff -- Statement: a dual joint of `(B, A)` in `αᵒᵈ` iff a joint of `(A, B)` in `α`; both directions +#check @ZeroParadox.not_isJoint_of_isBot -- Statement: if `x` is least in a preorder, then `x` is a joint of no `(A, B)` +#check @ZeroParadox.not_isDualJoint_of_isTop -- Statement: if `x` is greatest in a preorder, then `x` is a dual joint of no `(A, B)` +#check @ZeroParadox.not_isDualJoint_of_wellFoundedLT -- Statement: if a linear order is well-founded, then nothing in it is a dual joint; `Ordinal` is an instance, and the `Finset Bool` CONTROL in the home file makes linearity a premise +#check @ZeroParadox.ennreal_top_isJoint -- Statement: ⊤ of `ℝ≥0∞` is a joint of (the finite values, `{⊤}`) +#check @ZeroParadox.ennreal_zero_isDualJoint -- Statement: 0 of `ℝ≥0∞` is a dual joint of (`{0}`, the positive values); as ⊥ of `ℝ≥0∞` it is a joint of no `(A, B)` (`not_isJoint_of_isBot`) +#check @ZeroParadox.ennreal_inv_exchanges -- Statement: on `ℝ≥0∞`, `x ↦ x⁻¹` reverses the order, sends ⊤ to 0 and 0 to ⊤, and `x⁻¹` is positive iff `x ≠ ⊤` +#check @ZeroParadox.isJoint_image_of_isDualJoint -- Statement: if `f` is onto and `f a ≤ f b ↔ b ≤ a`, then `f` sends a dual joint `x` of `(A, B)` to a joint `f x` of `(f '' B, f '' A)` +#check @ZeroParadox.isDualJoint_image_of_isJoint -- Statement: under the same hypotheses, a joint `x` of `(A, B)` goes to a dual joint `f x` of `(f '' B, f '' A)` +#check @ZeroParadox.q2Val_zero_isJoint -- Statement: `q2Val` reverses the norm order on ℤ_[2], ℤ_[2]'s 0 has least norm, and its `q2Val`, ⊤ of `ℕ∞`, is a joint of (the finite values, `{⊤}`) +-- Reading: INVERSION, no identity: 0 and ⊤ of `ℝ≥0∞` are two points (`ENNReal.zero_ne_top`) that +-- `x ↦ x⁻¹` exchanges. At ℤ_[2]'s 0 only the valuation side is a joint here: ℤ_[2] carries no order +-- instance, so the norm side is stated as least norm, not as a dual joint. +#check @ZeroParadox.Motion.UpTotal -- Statement: UP switch at total: `up` defined everywhere -- Statement: member and non-member: `ofTotal`; and UP undefined everywhere. #check @ZeroParadox.Motion.ofTotal_upTotal example : ∃ M : ZeroParadox.Motion ℕ, (∀ x, M.up x = Part.none) ∧ ¬ M.UpTotal := @@ -216,9 +253,13 @@ example : ∃ M : ZeroParadox.Motion (Fin 4), -- (`corner_iff_loop_or_climb`), not exclusively (`Fin 4` above). In a partial order agreeing legs give -- no loop (`not_loop_of_agree`), and the legs of `UpAndOver.toMotion`, whose OVER is every cover of the -- carrier (one chosen wiring, § XIX `cover_overs_differ`), agree (`toMotion_agree`), so that motion climbs --- and never loops (`toMotion_climb`, `toMotion_not_loop`). `phaseBelowCoverMotion` climbs (§ XXIII); the ℕ∞ --- model's join and scale loop, in both wirings below, and in each wiring, in ℕ∞'s own order and in --- ZP-A's induced order alike, one leg raises and the other lowers (the `example` after them). +-- and never loops (`toMotion_climb`, `toMotion_not_loop`). `phaseBelowCoverMotion` climbs +-- (§ XXIII). On the ℕ∞ model both wirings below loop: wiring one (UP the join with `c`, OVER the +-- scale step) if `c ≠ ⊤` of `ℕ∞`; wiring two (UP constant ⊤ of `ℕ∞`, OVER the join step) loops, +-- and the loop owes nothing specific to the join: with UP constant ⊤ the always-true step loops too +-- (the last CONTROL of this group, after the crossing-with-no-switch `example`). In each wiring, in +-- ℕ∞'s own order and in ZP-A's induced order alike, one leg raises and the other lowers (the +-- `example` after them). -- Reading: by the ruling above both kinds are legal up-and-over shapes, and the crossing of the joint -- is OVER leaving the set of landings and UP returning to a landing (the `Statement:` above). Tim's -- read, 2026-10-22, verbatim: "My gut reaction is that the joint might fill both of those rolls.. you @@ -228,9 +269,13 @@ example : ∃ M : ZeroParadox.Motion (Fin 4), -- legs that oppose in one order switch order, since the induced order is ℕ∞'s own order reversed (the -- `example` after that one, per leg: raising in the induced order iff lowering in ℕ∞'s own). A switch -- occurs with no corner (the `CONTROL` after that one), so these examples do not show the switch BEING --- the crossing; that the --- joint fills both roles stays Tim's read. Not claimed here: that the two roles coincide in general, or --- that every crossing is a switch of order. +-- the crossing; that the joint might fill both roles stays Tim's read. Not claimed here: that the two +-- roles coincide in general. And not every crossing is a switch of order: the die motion of any +-- `UpAndOver` fires the corner while its legs agree and oppose in neither the carrier's order nor its +-- dual (the `example` after that CONTROL), and `UpAndOver` is inhabited (`ordinalUpAndOver`, § V). +-- That inhabitant's carrier, `Ordinal.{u}`, lives in `Type (u+1)`, outside the `{α : Type}` the +-- `example` binds; at `Type` itself, `MemGraph.nonempty_upAndOver_hset2` (§ V) gives an inhabitant +-- on `(HSet 2)ᵒᵈ` (the `example` after the crossing-with-no-switch one). -- Reading: Q1: in the second wiring the loop's landing is the pole, ⊤ of `ℕ∞` (⊥ of the ZP order), which -- steps off the landings and is sent back to itself. Q2: run backwards (`reverse`, which keeps UP), a -- loop is a point `b ≠ y` from which OVER and UP both reach the landing `y`, and a climb one from which @@ -316,28 +361,44 @@ example (M : ZeroParadox.Motion ℕ∞) : fun x y => show min x y = y ↔ y ≤ x from min_eq_right_iff ⟨forall_congr' fun x => forall_congr' fun y => imp_congr_right fun _ => h x y, forall_congr' fun x => forall_congr' fun y => imp_congr_right fun _ => h x y⟩ --- Statement: CONTROL: on `ℕ∞`, UP the join with 0 of `ℕ∞` (every point sent to 0, which is ⊥ of ℕ∞'s --- own order and ⊤ of ZP-A's induced order), OVER the scale step only from points other than 0: UP --- moves 1 to 0, the legs oppose in ℕ∞'s own order (UP lowers, OVER raises), UP does not raise there and --- raises in the induced order, and the corner does not fire (the one landing, 0, has no step). +-- Statement: CONTROL: on `ℕ∞`, UP the join with 1 (`x ↦ min x 1`), OVER the scale step from 0 only +-- (`0 → 1`): the legs oppose in ℕ∞'s own order (UP lowers, OVER raises), UP does not raise there (it +-- moves 2 to 1) and raises in ZP-A's induced order, OVER fires at the landing 0, and the corner does +-- not fire, since OVER lands on 1, a landing. So the control fails the corner with OVER at a landing, +-- not only for want of one. example : - let M := ZeroParadox.Motion.ofTotal (fun x : ℕ∞ => ZeroParadox.ZPSemilattice.join x 0) - (fun x => show min (min x 0) 0 = min x 0 by rw [min_assoc, min_self]) - (fun a b => a ≠ 0 ∧ b = ZeroParadox.ValuationStructure.scale a) - (0 : ℕ∞) ∈ M.up 1 ∧ M.Oppose ∧ ¬ M.UpRaises ∧ - @ZeroParadox.Motion.UpRaises ℕ∞ M (ZeroParadox.zpSemilatticeSup ℕ∞).toLE ∧ ¬ M.Corner := by + let M := ZeroParadox.Motion.ofTotal (fun x : ℕ∞ => ZeroParadox.ZPSemilattice.join x 1) + (fun x => show min (min x 1) 1 = min x 1 by rw [min_assoc, min_self]) + (fun a b => a = 0 ∧ b = ZeroParadox.ValuationStructure.scale a) + M.Oppose ∧ ¬ M.UpRaises ∧ + @ZeroParadox.Motion.UpRaises ℕ∞ M (ZeroParadox.zpSemilatticeSup ℕ∞).toLE ∧ + M.OverAtLanding ∧ ¬ M.Corner := by intro M - refine ⟨Part.mem_some_iff.2 (by simp [ZeroParadox.ZPSemilattice.join]), - ⟨fun x y h => ?_, fun a b ⟨_, h⟩ => ?_⟩, fun h => ?_, fun x y h => ?_, ?_⟩ - · rw [Part.mem_some_iff.1 h]; exact min_le_left x 0 + refine ⟨⟨fun x y h => ?_, fun a b ⟨_, h⟩ => ?_⟩, fun h => ?_, fun x y h => ?_, + ⟨0, 1, Part.mem_some_iff.2 (by simp [ZeroParadox.ZPSemilattice.join]), rfl, rfl⟩, ?_⟩ + · rw [Part.mem_some_iff.1 h]; exact min_le_left x 1 · rw [(h : b = a + 1)]; exact le_self_add - · exact absurd (h 1 (min 1 0) (Part.mem_some _)) (by simp) + · exact absurd (h 2 (min 2 1) (Part.mem_some _)) (by decide) · rw [Part.mem_some_iff.1 h] - show min x (min x 0) = min x 0 + show min x (min x 1) = min x 1 rw [← min_assoc, min_self] - · rintro ⟨y, b, z, hy, ⟨hy0, -⟩, -, -⟩ - have : y = min y 0 := Part.mem_some_iff.1 hy - exact hy0 (this.trans (min_eq_right (zero_le y))) + · rintro ⟨y, b, z, -, ⟨rfl, hb⟩, hz, hzb⟩ + have hb' : b = 1 := by rw [hb]; rfl + subst hb' + exact hzb (Part.mem_some_iff.1 hz) +-- Statement: a crossing with no switch: for every `UpAndOver α`, its die motion fires the corner, its +-- legs agree, and they oppose neither in `α`'s order nor in the order dual `αᵒᵈ`. +example {α : Type} [PartialOrder α] (U : ZeroParadox.UpAndOver α) : + U.toMotion.Corner ∧ U.toMotion.Agree ∧ ¬ U.toMotion.Oppose ∧ + ¬ @ZeroParadox.Motion.Oppose αᵒᵈ U.toMotion _ := by + obtain ⟨y, b, -, hb, hne⟩ := U.corner + refine ⟨ZeroParadox.Motion.climb_corner _ U.toMotion_climb, U.toMotion_agree, fun h => ?_, + fun h => ?_⟩ + · exact hne (le_antisymm (h.1 b (U.up b) (Part.mem_some _)) (U.up.le_closure b)) + · exact lt_irrefl _ (lt_of_lt_of_le hb.lt (h.2 y b hb)) +-- Statement: and some `α : Type` carries an `UpAndOver`: `(HSet 2)ᵒᵈ`. +example : ∃ (α : Type) (_ : PartialOrder α), Nonempty (ZeroParadox.UpAndOver α) := + ⟨_, inferInstance, ZeroParadox.MemGraph.nonempty_upAndOver_hset2⟩ -- Statement: CONTROL: with UP constant ⊤ of `ℕ∞`, the always-true step loops too, so the loop kind -- there says nothing specific about the join. example : (ZeroParadox.Motion.ofTotal (fun _ : ℕ∞ => (⊤ : ℕ∞)) (fun _ => rfl) (fun _ _ => True)).Loop := @@ -424,10 +485,26 @@ example : Nonempty (ZeroParadox.Motion Empty) := ⟨⟨fun x => x.elim, fun x => /-! ### § III. The smallest step is DERIVED — unique successor, no way back ⇒ cover, one way -/ #check @ZeroParadox.unique_succ_covBy -- Statement: if `b` is `y`'s only successor and `b` does not reach `y`, then `y ⋖ b` in the reachability preorder; one way, the converse refuted on `Fin 3` below --- Reading: the closest classical frame is transitive reduction (Aho, Garey and Ullman, SIAM J. Comput. --- 1(2):131–137, 1972, doi 10.1137/0201008; cited, not retrieved). On a finite acyclic relation this --- lemma is the single-successor case of the standard criterion that an edge is in the reduction when --- it is the only path between its endpoints; the lemma itself assumes neither finiteness nor acyclicity. +-- Reading: the closest classical frame is transitive reduction. Source read: A. V. Aho, M. R. Garey +-- and J. D. Ullman, "The transitive reduction of a directed graph", SIAM J. Comput. 1(2):131–137, +-- 1972, doi 10.1137/0201008. Their Theorem 1 (p. 132): a finite acyclic directed graph `G` has a +-- unique graph `Gᵗ` with the same transitive closure such that no proper subset of `Gᵗ` has that +-- closure, namely the intersection of all graphs on its vertex set with that closure. Two of their +-- conventions differ from ours: `Gᵗ` is not required to be a subgraph of `G` (p. 131; for acyclic +-- `G` the two notions agree), and their "acyclic" admits loops, a cycle being required to pass +-- through another vertex (p. 132). After the proof (p. 133) they note that `Gᵗ` is obtained by +-- deleting, in any order, each arc `(u, v)` that is redundant: the graph has a directed path from `u` +-- to `v` not including it (also J. Bang-Jensen and G. Gutin, *Digraphs*, § 4.3, pp. 177-178). The +-- closest statement is AGU's, in the proof of Theorem 3 (p. 136): "arc (u, v) is in G₁ᵗ if and only if +-- (u, v) ∈ G₁, and there is no path from u to v which does not include arc (u, v)"; Bang-Jensen and +-- Gutin do not state the criterion used here as one sentence. It follows, since on an acyclic digraph without +-- loops a path from `u` to `v` that includes the arc `(u, v)` is that arc alone. So on a finite +-- acyclic digraph without loops an arc is in the reduction if and only if it is the only path between +-- its endpoints, and those arcs are exactly the covering pairs of the reachability order (a covering +-- pair has no vertex strictly between, so its only path is the arc). Under this lemma's hypotheses every path from `y` to `b` begins with the arc `y → b`, +-- so on a finite acyclic relation the lemma's `y ⋖ b` is such an arc. The lemma itself assumes +-- neither finiteness nor acyclicity, and on the `Fin 3` cycle below `0 ⋖ 2` holds with no arc +-- `0 → 2`: without acyclicity a covering pair need not be an arc. -- Statement: on `Fin 3` with steps `0 → 1`, `1 → 2`, `2 → 1` (a cycle), `unique_succ_covBy` gives -- `0 ⋖ 1` in the reachability preorder. example : let R : Fin 3 → Fin 3 → Prop := fun a b => (a = 0 ∧ b = 1) ∨ (a = 1 ∧ b = 2) ∨ (a = 2 ∧ b = 1) @@ -515,14 +592,14 @@ example : ZeroParadox.BotCovered Bool ∧ ZeroParadox.BotCovered ℕ := ⟨⟨true, covBy_of_eq_or_eq (by decide) fun c _ _ => by cases c <;> decide⟩, ⟨_, Order.covBy_succ (⊥ : ℕ)⟩⟩ example : ¬ ZeroParadox.BotCovered Unit ∧ ¬ ZeroParadox.BotCovered NNReal := - ⟨fun ⟨_, h⟩ => h.lt.ne (Subsingleton.elim _ _), fun ⟨_, h⟩ => not_covBy h⟩ + ⟨fun ⟨_, h⟩ => h.lt.ne (Subsingleton.elim _ _), fun ⟨_, h⟩ => not_covBy_of_denselyOrdered h⟩ #check @ZeroParadox.botCovered_withBot_iff -- Statement: ⊥ of `WithBot σ` has a cover iff `σ` has a minimal point (`[propext, Classical.choice, Quot.sound]`, through Mathlib's `WithBot.bot_covBy_coe`) #check @ZeroParadox.botCovered_withTop_iff -- Statement: with ⊥ of `σ` and no maximal point, ⊥ of `WithTop σ` has a cover iff ⊥ of `σ` has one -- Statement: the two adjoined-point orders can disagree: `NNReal` has the cut in `WithBot` and not in -- `WithTop`; ℕ has it in both. example : ZeroParadox.BotCovered (WithBot NNReal) ∧ ¬ ZeroParadox.BotCovered (WithTop NNReal) := ⟨ZeroParadox.botCovered_withBot_iff.2 ⟨⊥, isMin_bot⟩, - fun h => let ⟨_, ha⟩ := ZeroParadox.botCovered_withTop_iff.1 h; not_covBy ha⟩ + fun h => let ⟨_, ha⟩ := ZeroParadox.botCovered_withTop_iff.1 h; not_covBy_of_denselyOrdered ha⟩ example : ZeroParadox.BotCovered (WithBot ℕ) ∧ ZeroParadox.BotCovered (WithTop ℕ) := ⟨ZeroParadox.botCovered_withBot_iff.2 ⟨⊥, isMin_bot⟩, ZeroParadox.botCovered_withTop_iff.2 ⟨_, Order.covBy_succ (⊥ : ℕ)⟩⟩ @@ -535,7 +612,7 @@ example : ZeroParadox.BotIntervalTwo Bool ∧ ZeroParadox.BotIntervalTwo (Fin 3) ⟨⟨true, by decide, fun c _ => by cases c <;> decide⟩, ⟨1, by decide, by decide⟩⟩ example : ¬ ZeroParadox.BotIntervalTwo Unit ∧ ¬ ZeroParadox.BotIntervalTwo NNReal := ⟨fun ⟨_, h, _⟩ => h.ne (Subsingleton.elim _ _), - fun h => let ⟨_, hc⟩ := ZeroParadox.botIntervalTwo_botCovered h; not_covBy hc⟩ + fun h => let ⟨_, hc⟩ := ZeroParadox.botIntervalTwo_botCovered h; not_covBy_of_denselyOrdered hc⟩ #check @ZeroParadox.botIntervalTwo_botCovered -- Statement: piece ⇒ cut, no hypothesis #check @ZeroParadox.botCovered_botIntervalTwo -- Statement: cut ⇒ piece, given `DecidableEq` #check @ZeroParadox.botCovered_botIntervalTwo_classical -- Statement: cut ⇒ piece with no binder, proved with `classical` @@ -587,7 +664,7 @@ example : ZeroParadox.BotCovered (WithBot (WithBot ℚ)) ∧ -- `botCovered_of_finite` is not removable; `Unit` (finite, no cut, above) is the control for the -- point other than ⊥. example : (∃ a : NNReal, a ≠ ⊥) ∧ ¬ ZeroParadox.BotCovered NNReal := - ⟨⟨1, one_ne_zero⟩, fun ⟨_, h⟩ => not_covBy h⟩ + ⟨⟨1, one_ne_zero⟩, fun ⟨_, h⟩ => not_covBy_of_denselyOrdered h⟩ #check @ZeroParadox.axb1_fails_everywhere_iff_dense -- Statement: if `α` is a preorder, then `α` is densely ordered iff no point of `α` has a first step (`∀ bot, ¬ HasFirstStep bot`); both directions. ZP-F's restatement (`ZeroParadox/Reals/OrderedField.lean`) of Mathlib's `denselyOrdered_iff_forall_not_covBy` -- Statement: if `α` is a partial order with ⊥ and has the cut, then `α` is not densely ordered; the -- converse is refuted at the `WithTop (WithTop NNReal)` example below. @@ -694,7 +771,7 @@ example : = ((k : ℚ) / 2 ^ N + j / 2 ^ M) / 2 := by push_cast; field_simp; ring rw [e]; linarith - exact ⟨hd, fun ⟨_, h⟩ => not_covBy h⟩ + exact ⟨hd, fun ⟨_, h⟩ => not_covBy_of_denselyOrdered h⟩ -- Statement: if `S` is a finite set of precisions and `q` lies in the `n`-place grid for some `n ∈ S`, -- then `q` lies in the grid of precision `S.sup id`, the largest in `S`; one way; the converse is -- not claimed. @@ -1071,6 +1148,25 @@ example : ZeroParadox.ordinalTowerMotion.RegisteredDecidable := -- Statement: (a) takes `[Primcodable α]`, and `Ordinal` has no `Primcodable` structure (it is uncountable). example : IsEmpty (Primcodable Ordinal) := ⟨fun h => (Uncountable.not_countable : ¬ Countable Ordinal) (@Encodable.countable _ h.toEncodable)⟩ +-- Statement: (a) with an `ℕ`-valued test in place of the `Bool` one: if UP is total on a +-- `[Primcodable α]` carrier, some computable `d : α → ℕ` has `d a = 1` exactly where UP is +-- defined. The proof, like `registeredComputable_of_upTotal`'s, uses `Computable.const`, whose +-- footprint, printed next, includes `Classical.choice`. +example {α : Type} [Primcodable α] (M : ZeroParadox.Motion α) (h : M.UpTotal) : + ∃ d : α → ℕ, Computable d ∧ ∀ a, d a = 1 ↔ (M.up a).Dom := + ⟨fun _ => 1, Computable.const 1, fun _ => ⟨fun _ => h _, fun _ => rfl⟩⟩ +#check @Computable.const -- Statement: Mathlib, a constant map is computable; its footprint is printed next +#print axioms Computable.const +-- Reading: so this proof's footprint includes `Classical.choice`; no footprint is claimed here for +-- the `ℕ`-valued statement itself. +-- Statement: statement controls, one per codomain: each assumes only a computable map out of `ℕ`. +-- Measured 2026-11-05 in this pinned Mathlib by naming each as a theorem in a scratch file and +-- printing its axioms: the `Bool` one reports `[propext, Classical.choice, Quot.sound]` and the `ℕ` +-- one `[propext, Quot.sound]`, so the choice enters through the `Bool` codomain's encoding +-- (`Primcodable.bool` reports `[propext, Classical.choice, Quot.sound]`) and not through +-- `Computable` itself (`[propext]`). +example (_h : ∃ d : ℕ → Bool, Computable d) : True := trivial +example (_h : ∃ d : ℕ → ℕ, Computable d) : True := trivial #check @ZeroParadox.no_computable_registration_at_kleene_floor -- Statement: no computable test decides self-halting on `Nat.Partrec.Code` -- Statement: NON-MEMBER of (a): on `Nat.Partrec.Code`, UP defined (and fixing `c`) where `c` halts on -- its own code. @@ -1159,11 +1255,13 @@ example (uc : ∀ P : Bool → Prop, (∃! b, P b) → {b : Bool // P b}) : -- element is defined or else undefined is equivalent to the principle of excluded middle (every -- proposition is inhabited or empty)", and § 2.7, p. 21:6, "L X ≃ X + 1 iff the canonical map 2 → Ω -- is an equivalence iff excluded middle holds"; T. de Jong, arXiv:2407.06952, Prop. 5.7, p. 13, credits --- the equivalence to their § 2.2. In Lean's `Prop`/`Type` split their excluded middle sits on the data --- side, `∀ p, Decidable p`, equivalently the `Bool` choice fragment, and the PROVED legs above are --- instances of their equivalence on that side: registration on every `α : Type` ⇔ the fragment. The --- `Prop`-valued `ZeroParadox.ExcludedMiddle` is reached one way, and back with the unique-choice --- hypothesis of the previous `example`; without it the converse is not established in Lean +-- the equivalence to their § 2.2. In Lean's `Prop`/`Type` split their excluded middle sits where `Decidable` +-- is data, under one outer `Nonempty`: `Nonempty (∀ p, Decidable p)`, equivalently the `Bool` choice +-- fragment (the second `example` after `ChoiceFragment` in +-- `ZeroParadox/Category/ExcludedMiddleBridge.lean`), and the PROVED legs above are instances of their +-- equivalence there: registration on every `α : Type` ⇔ the fragment. The `Prop`-valued +-- `ZeroParadox.ExcludedMiddle` is reached one way, and back with the unique-choice hypothesis of the +-- previous `example`; without it the converse is not established in Lean -- (`ZeroParadox/Category/ChoiceCannotBe.md`). An instance of theirs, not a generalization. /-! ### § X. The OVER leg's WHICH — selection, in two variants -/ @@ -1215,12 +1313,15 @@ example (h : ∀ (α : Type) (M : ZeroParadox.Motion α), M.SelectedData) : · exact absurd hb hn · exact (key S).1 (of_decide_eq_true hd) -- Reading (cited, not claimed): Diaconescu's argument as in the Rocq standard library, --- `theories/Logic/Diaconescu.v` Part A (`pred_ext_and_rel_choice_imp_EM`, through --- `AC_bool_subset_to_bool`, a functional relation choosing in every inhabited subset of `bool`), which --- credits Diaconescu 1975 and Lacas and Werner 1999, run on the data side: there relational choice, a --- `Prop`, gives excluded middle; here a selector given as data gives the fragment (the `example` --- above) and excluded middle directly (`Motion.em_of_selectedData`, next line), the latter on Part A's --- own two classes `b = true ∨ p`, `b = false ∨ p`; an instance of theirs, not a generalization. +-- `theories/Logic/Diaconescu.v` Part A (rocq-prover/stdlib, retrieved 2026-10-31), in its section +-- `PredExt_RelChoice_imp_EM`, which the file marks "kept for backwards compatibility" +-- (`pred_ext_and_rel_choice_imp_EM`, through `AC_bool_subset_to_bool`, a functional relation choosing +-- in every inhabited subset of `bool`); the current Part A theorem, `prop_ext_and_rel_choice_imp_EM`, +-- uses the pairs `(True, P)` and `(P, True)` instead. The file credits Diaconescu 1975 and Lacas +-- and Werner 1999. Run on the data side: there relational choice, a `Prop`, gives excluded middle; +-- here a selector given as data gives the fragment (the `example` above) and excluded middle +-- directly (`Motion.em_of_selectedData`, next line), the latter on that section's own two classes +-- `b = true ∨ p`, `b = false ∨ p`; an instance of theirs, not a generalization. #check @ZeroParadox.Motion.em_of_selectedData -- Statement: (a) on every motion on every `α : Type` ⇒ excluded middle, directly #check @ZeroParadox.Motion.lpo_of_selectedTotal_nat_boolStep -- Statement: (b) on every motion on `ℕ` with a `Bool`-valued step ⇒ the limited principle of omniscience (`[propext]`) -- Statement: CONTROL: (a) there is free: a `Bool`-valued step on `ℕ` has a data selector, `Nat.find`. @@ -1257,6 +1358,53 @@ example (hf : ZeroParadox.ChoiceFragment) {α : Type} (M : ZeroParadox.Motion α rw [this] -- Reading: the converse, the fragment ⇒ a selector on every motion, is not established here: the -- fragment chooses in `Bool`, a selector in an arbitrary carrier. +#check @ZeroParadox.Motion.wem_of_selectedTotal_propStep -- Statement: if `α` has points `u ≠ v` and a `Bool` test true exactly at `u`, (b) for every `Prop`-valued step on `α` gives weak excluded middle (`[propext]`) +-- Statement: instances on `NInf` (at `NInf.ofNat 0` and `NInf.ofNat 1`, test `NInf.isAt 0`), on +-- `Option ℕ` (at `none` and `some 0`) and on `ℕ` (at `0` and `1`), each landing on +-- `ZeroParadox.WeakExcludedMiddle`. +example (H : ∀ s : ZeroParadox.NInf → ZeroParadox.NInf → Prop, + (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal) : + ZeroParadox.WeakExcludedMiddle := + ZeroParadox.Motion.wem_of_selectedTotal_propStep (ZeroParadox.NInf.ofNat 0) (ZeroParadox.NInf.ofNat 1) + (fun e => absurd (ZeroParadox.NInf.ofNat_injective e) (by decide)) (ZeroParadox.NInf.isAt 0) + (ZeroParadox.NInf.isAt_iff 0) H +example (H : ∀ s : Option ℕ → Option ℕ → Prop, + (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal) : + ZeroParadox.WeakExcludedMiddle := + ZeroParadox.Motion.wem_of_selectedTotal_propStep none (some 0) (by simp) (fun b => b.isNone) + (fun b => by cases b <;> simp) H +example (H : ∀ s : ℕ → ℕ → Prop, (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal) : + ZeroParadox.WeakExcludedMiddle := + ZeroParadox.Motion.wem_of_selectedTotal_propStep 0 1 (by decide) (fun b => b == 0) (fun b => by simp) H +-- Statement: CONTROL: on `Unit`, which has no `u ≠ v`, every step has a total selector, with no +-- hypothesis. +example (s : Unit → Unit → Prop) : (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal := + ⟨id, fun a ⟨b, hb⟩ => by cases a; cases b; exact hb⟩ +-- Statement: CONTROL: classically the hypothesis holds on every carrier +-- (`Motion.selectedTotal_of_classical`, above). +example {α : Type} : ∀ s : α → α → Prop, (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal := + fun _ => ZeroParadox.Motion.selectedTotal_of_classical +-- Reading: with a `Bool`-valued step the three carriers part: `NInf` is a member with no hypothesis +-- (`selectedTotal_ninf_boolStep`, § XXVII), and membership on `ℕ` and on `Option ℕ` gives LPO (this +-- section and § XXVII). With a `Prop`-valued step, the instances above share one hypothesis shape and +-- one conclusion. On `ℕ` and on `Option ℕ` the same hypothesis also gives LPO, since a +-- `Bool`-valued step is a `Prop`-valued one (the two `example`s next). On `NInf`, where a +-- `Bool`-valued step has a selector with no hypothesis, whether a selector for every +-- `Prop`-valued step gives more than weak excluded middle is not established here. +-- Statement: if every `Prop`-valued step on `ℕ` has a total selector, LPO holds. +example (H : ∀ s : ℕ → ℕ → Prop, (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal) : + ZeroParadox.LPO := + ZeroParadox.Motion.lpo_of_selectedTotal_nat_boolStep fun _ => H _ +-- Statement: if every `Prop`-valued step on `Option ℕ` has a total selector, LPO holds. +example (H : ∀ s : Option ℕ → Option ℕ → Prop, + (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).SelectedTotal) : + ZeroParadox.LPO := + ZeroParadox.Motion.lpo_of_selectedTotal_option_boolStep fun _ => H _ +-- Reading (cited, not claimed): Bell, J. Phil. Logic 22 (1993), as corrected in Baaz and Zach, +-- arXiv:1907.04477, § 5, p. 14 and fn. 5: intuitionistic ε-calculus with identity derives +-- ¬(B ∧ C) → ¬B ∨ ¬C from ∀x(x = a ∨ ¬x = a) and a ≠ b. Here the ε-term is the selector's value at +-- `u`, the decidable identity is the test `t`, and that De Morgan law is weak excluded middle; an +-- instance of that result (Bell 1993 itself not retrieved). /-! ### § XI. The OVER leg's WHETHER — what OVER does at a point -/ #check @ZeroParadox.Motion.NoStepAt -- Statement: no step leaves `y` @@ -1280,6 +1428,29 @@ example (H : ∀ (α : Type) (M : ZeroParadox.Motion α) (y : α), M.OverTrichot · exact Or.inr (h ()) · exact Or.inl hp · exact absurd (Subsingleton.elim b ()) hb +#check @ZeroParadox.Motion.em_of_trichotomy_propStep -- Statement: if, at a point `y` of `α`, the trichotomy holds for every `Prop`-valued step on `α`, excluded middle holds (`[propext]`) +#check @ZeroParadox.Motion.trichotomy_of_em -- Statement: if excluded middle holds, every motion meets the trichotomy at every point (no axioms) +-- Statement: the `Unit` example above follows from `em_of_trichotomy_propStep` at `y = ()`. +example (H : ∀ (α : Type) (M : ZeroParadox.Motion α) (y : α), M.OverTrichotomy y) : + ZeroParadox.ExcludedMiddle := + ZeroParadox.Motion.em_of_trichotomy_propStep () fun _ => H Unit _ () +-- Statement: at a point `y` of any `α : Type`, the trichotomy for every `Prop`-valued step and +-- excluded middle are inter-derivable; both directions. +example {α : Type} (y : α) : + (∀ s : α → α → Prop, (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).OverTrichotomy y) ↔ + ZeroParadox.ExcludedMiddle := + ⟨ZeroParadox.Motion.em_of_trichotomy_propStep y, + fun em _ => ZeroParadox.Motion.trichotomy_of_em em _ y⟩ +-- Statement: instance on `NInf` at `∞`. +example (H : ∀ s : ZeroParadox.NInf → ZeroParadox.NInf → Prop, + (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).OverTrichotomy ZeroParadox.NInf.infty) : + ZeroParadox.ExcludedMiddle := + ZeroParadox.Motion.em_of_trichotomy_propStep ZeroParadox.NInf.infty H +-- Statement: CONTROL: on `Empty` the trichotomy holds at every point, vacuously; the theorem takes a +-- point `y`. +example (s : Empty → Empty → Prop) : + ∀ y : Empty, (ZeroParadox.Motion.ofTotal id (fun _ => rfl) s).OverTrichotomy y := + fun y => y.elim -- Reading: the OVER-leg counterpart of § IX's Escardó–Knapp § 2.2 form ("every partial element is -- defined or else undefined"), there quoted; cited, not claimed. #check @ZeroParadox.Motion.lpo_of_trichotomy_nat_boolStep -- Statement: the trichotomy at every point of every motion on `ℕ` with a `Bool`-valued step ⇒ the limited principle of omniscience (`[propext]`) @@ -1382,7 +1553,8 @@ example {X : Type} {P : PFunctor.{0, 0}} (α : X → P.Obj X) (hwf : ZeroParadox have hx : x ∈ (∅ : Set X) := by rw [hu]; trivial exact hx⟩ -- Statement: on the leaf-free M-type (`idPF_Coalgebra`, not well-founded: `idPF_M_not_wellFounded`) --- every point steps to itself only, since any two points are equal (`PFunctor.M.bisim`) +-- every point steps to itself only, since any two points are equal (`PFunctor.M.bisim`; the same +-- argument over `QPF.Cofix` is `cofix_subsingleton`, `ZeroParadox/Settheory/Coalgebra.lean`) -- (`[propext, Classical.choice, Quot.sound]`). Reading: the root cut's two sides sit at two trichotomy -- values, no step (which an inhabited well-founded carrier cannot lack, previous `example`) and a step -- to itself only (this one); the root cut's seam half is not derived from them. @@ -1731,19 +1903,19 @@ example (h : ∀ (β : Type) [PartialOrder β] [OrderBot β], ZeroParadox.BotCov -- counterexamples in the "stable" form, a statement implying a principle quantified over all binary -- sequences (Diener, arXiv:1804.05495v3, § 0.3, p. 5); the excluded-middle and weak-excluded-middle -- reductions quantify over `Prop` instead. The die-shaped statements themselves were not located in the --- sources read, as of 2026-10-28. Decidable --- equality frees the corner split (`Motion.corner_iff_loop_or_climb`) and the cut --- (`botCovered_botIntervalTwo`); it does not free registration, whose taboo comes from a --- `Prop`-valued UP-definedness, is reached on `Unit` (`Motion.em_of_registeredDecidable`), and is --- decided when UP is total or presented as an `Option` (`registeredDecidable_of_upTotal`, +-- sources read, as of 2026-10-28. Decidable equality frees the corner split +-- (`Motion.corner_iff_loop_or_climb`) and the cut (`botCovered_botIntervalTwo`); it does not free +-- registration. Registration's taboo comes from a `Prop`-valued UP-definedness and is reached on +-- `Unit` (`Motion.em_of_registeredDecidable`); UP-definedness itself is decided when UP is total or +-- presented as an `Option` (`registeredDecidable_of_upTotal`, -- `ofOption_registeredDecidable`). On `ℕ`, the quantifier in the trichotomy, the selector and fan-in -- returns as LPO or Markov's principle; this is measured for `ℕ`, and for the trichotomy and the -- selector also on `Option ℕ` (§ XXVII). Escardó (preprint of JSL 78(3) (2013), p. 1) grades the -- same principle by the set searched, "For X finite this is trivial, and for X = ℕ, this is LPO", -- and exhibits infinite sets on which it holds, the first being ℕ∞ (`NInf.omniscient`, § XXVII). -- LPO and weak excluded middle are not shown comparable here: the model over ℝ shows that LPO does --- not imply weak excluded middle (`LawvereTaboo.lean` § V, last Reading), and the converse was not --- settled from the sources read. +-- not imply weak excluded middle (`ZeroParadox/Category/LawvereTaboo.lean` § V, last Reading), and +-- the converse was not settled from the sources read. -- Statement: `Prop`, UP double negation `p ↦ ¬¬p` (total, so registration is free, -- `registeredDecidable_of_upTotal`), OVER negation `p → ¬p`: a decidable proposition is a landing. example (p : Prop) [Decidable p] : @@ -1793,8 +1965,9 @@ example {α : Type} (M : ZeroParadox.Motion α) (σ : α → α) (hσ : Function ⟨fun h b hb => h _ (by rw [hr, hσ] at hb; exact hb), fun h a ha => h (σ a) ((hr _ _).1 ha)⟩ #check @ZeroParadox.Motion.bijOn_sources_sinks -- Statement: and the sources map one-to-one onto the sinks -- Reading (cited, not claimed): folklore, of which the theorem is an instance. A digraph isomorphic to --- its converse is self-converse (Harary and Palmer, "Enumeration of self-converse digraphs", --- Mathematika 13 (1966); bibliographic record only, not read), and the theorem says an involutive such +-- its converse is called self-converse; the term is in the title of Harary and Palmer, "Enumeration of +-- self-converse digraphs", Mathematika 13 (1966), whose text was not read (bibliographic record +-- only), so no definition or result is attributed to them here. The theorem says an involutive such -- isomorphism sends the sources onto the sinks; the poset form is Chajda and Länger, arXiv:2502.01266v1, Lemma 3.6, p. 5: for an antitone -- involution `'` and `A ⊆ P`, "(Max A)' = Min A' and (Min A)' = Max A'". The dynamical analogue is in -- Devaney's § IX (PDF page 26 of the copy read): for a symmetric hyperbolic critical point `p`, "by @@ -2227,7 +2400,8 @@ example (n : ℤ) : let M := (ZeroParadox.Motion.ofTotal (id : ZeroParadox.Spher -- from itself, INVARIANT under reversal (`Option.map`; ⊤ of `E0Note`; `∞` of `OnePoint ℚ_[2]` under -- `rScale n`, where `0`, not adjoined, behaves the same, `rInv` reverses the motion, and `rInv_swaps` -- exchanges the two). ⊤ of `E0Note` is the point `e0Repr` sends to ε₀, and ε₀ is the minimum step --- next to the pole, never the pole (`ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § III); it sits +-- next to the pole, never the pole, and the tower's supremum, both at once (`epsilon0_min_eq_max`, +-- `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § III); it sits -- in that list beside `∞` as a self-loop, not as the pole's infinity. An -- adjoined value in the step's codomain gives a sink instead (`runMotion`; both `TriStep` values, which -- the relation does not tell apart). Under a function a halted and a self-looping configuration share @@ -2379,17 +2553,18 @@ example : let M := (ZeroParadox.Motion.ofTotal (id : Fin 3 → Fin 3) (fun _ => -- form, for well-founded relations in general, is not built here. A rank dropping along every step is -- a well-foundedness argument, the kind a liveness proof rests on (Alpern and Schneider, IPL 21 (1985), -- p. 181). --- Statement: `ZFSet` with OVER `a → b` when `b ∈ a`: `x` steps to itself only iff `x = {x}`; both --- directions. No `ZFSet` does (`no_quine_atom`). -example (x : ZFSet) : - ((ZeroParadox.Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => b ∈ a)).SelfOnlyAt x ↔ x = {x}) ∧ - ¬ (ZeroParadox.Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => b ∈ a)).SelfOnlyAt x := by - refine ⟨⟨fun ⟨hx, hu⟩ => ZFSet.ext fun z => ?_, fun h => ⟨?_, fun b hb => ?_⟩⟩, - fun h => ZeroParadox.no_quine_atom x h.1⟩ - · rw [ZFSet.mem_singleton]; exact ⟨hu z, fun h => h ▸ hx⟩ - · have hs : x ∈ ({x} : ZFSet) := ZFSet.mem_singleton.2 rfl - rw [← h] at hs; exact hs - · rw [h] at hb; exact ZFSet.mem_singleton.1 hb +-- Reading: CARRIER — the Quine-atom role is `SelfOnlyAt`; of the two charts below one occupies it and one +-- provably does not, and no equation across the two carriers is stated. +#check @ZeroParadox.zfset_selfOnlyAt_mem_iff -- Statement: `ZFSet` with OVER `a → b` when `b ∈ a`: `x` steps to itself only iff `x = {x}`; both directions +#check @ZeroParadox.zfset_quine_role_unoccupied -- Statement: and no `ZFSet` does (`no_quine_atom`) +#check @ZeroParadox.cofix_quine_role_occupied -- Statement: `Cofix idPF_Coalgebra.Obj` with OVER `x → y` when `y` is a child of `x` under `Cofix.dest`: some point steps to itself only +#check @ZeroParadox.dest_cofixSelf -- Statement: that point, `cofixSelf`, unfolds to the one-slot node whose only child is itself +#check @ZeroParadox.cofix_subsingleton -- Statement: and `Cofix idPF_Coalgebra.Obj` has at most one point +-- Statement: CONTROL: OVER always true on `Unit` has a point stepping to itself only, and OVER empty +-- has none. Reading: occupancy alone discriminates nothing until OVER is the chart's own relation. +example : (ZeroParadox.Motion.ofTotal (id : Unit → Unit) (fun _ => rfl) (fun _ _ => True)).SelfOnlyAt () ∧ + ¬ ∃ y, (ZeroParadox.Motion.ofTotal (id : Unit → Unit) (fun _ => rfl) (fun _ _ => False)).SelfOnlyAt y := + ⟨⟨trivial, fun _ _ => rfl⟩, fun ⟨_, h⟩ => h.1⟩ -- Statement: `QuineHost`'s two fields give a self-step at ⊥ of the host and do not give `SelfOnlyAt`: -- on `Bool` with `mem x y := y = false` (the control in `ZeroParadox/Settheory/QuineHost.lean`), OVER -- `a → b` when `b` is a member of `a` steps `false` to itself and to `true`. @@ -2404,6 +2579,14 @@ example (x : ℤ_[2]) : (ZeroParadox.Motion.ofFun (· + (1 : ℤ_[2]))).LeavesAt , (ZeroParadox.Motion.selfOnlyAt_ofFun_iff _ x).trans ⟨fun h => by linear_combination h, fun h => by rw [h, mul_zero]⟩⟩ +-- Reading: CARRIER — two pairings through `snapEmbed` (`ZeroParadox/Ordinal/Incompleteness.lean` +-- § I-b), each a map, no equation across `MachinePhase` and ℤ_[2]. +#check @ZeroParadox.machineJoinMotion_selfOnlyAt_iff -- Statement: `MachinePhase` with OVER `a → join a z`: only `c₁` steps to itself only +#check @ZeroParadox.z2MulMotion_selfOnlyAt_iff -- Statement: ℤ_[2] with OVER `x → x * w`: only `0` steps to itself only +#check @ZeroParadox.snapEmbedHom -- Statement: `snapEmbed` is a strict map between those two motions (`snapEmbed_c1` sends `c₁` to `0`); it has no back clause at `c₀` (an `example` in Incompleteness.lean § I-b) +#check @ZeroParadox.snapEmbed_selfOnlyAt_c1 -- Statement: the role carries over at `c₁`: its image steps to itself only in the multiplication motion +#check @ZeroParadox.z2_double_selfOnlyAt_iff -- Statement: ℤ_[2] under doubling: `y` steps to itself only iff `y = 0`; both directions +#check @ZeroParadox.snapEmbed_doubling_noStepAt -- Statement: a motion on `MachinePhase` whose steps `snapEmbed` sends to doubling steps has no step at `c₀` -- Statement: partial digit streams (`ZeroParadox/Category/LawvereTwoAdic.lean`): `partialAddOne` steps -- to itself only exactly at `[]`; `partialDouble` steps elsewhere at every stream. example (w : List Bool) : ((ZeroParadox.Motion.ofFun ZeroParadox.partialAddOne).SelfOnlyAt w ↔ w = []) ∧ @@ -2417,6 +2600,16 @@ example {L : Type} [ZeroParadox.QuineAtomHost L] : (fun a b => ZeroParadox.QuineAtomHost.mem b a)).SelfOnlyAt ZeroParadox.QuineAtomHost.bot := ⟨(ZeroParadox.QuineAtomHost.bot_mem_iff _).2 rfl, fun b hb => (ZeroParadox.QuineAtomHost.bot_mem_iff b).1 hb⟩ +-- Reading: CARRIER — the seam role is exactly one point stepping to itself only (on a complete lattice, +-- `lfp = gfp`, the `fork_collapse_iff` entry above); each chart below occupies it or not by its own +-- theorem, and no equation across the charts is stated. +#check @ZeroParadox.selfApp_seam_role_unique -- Statement: `ofFun selfApp` on a `ZPSemilattice` with `AbstractSelfApp`: exactly one point steps to itself only; the type names no point, and `selfApp_fp_set_eq_singleton_bot` (with `Motion.selfOnlyAt_ofFun_iff`) identifies it as the least element `bot` of the `ZPSemilattice` +#check @ZeroParadox.seam_role_unique_iff_wellFounded -- Statement: `ofFun (nextTime α)` on `Set X`: exactly one set steps to itself only iff `α` is well-founded (`IsWellFoundedCoalg`); both directions. Reading (cited, not claimed): Adámek, Milius and Moss's definition of a well-founded coalgebra (arXiv:1910.09401v2, Def 4.3, p. 15: `id_A` is the only fixed point of the next time operator; they credit the characterisation to Taylor), restated in the die vocabulary for polynomial functors on types (`isWellFoundedCoalgCat_iff` relates it to their categorical form); not a new result +#check @ZeroParadox.constPF_seam_role_unique -- Statement: so on `Cofix (constPF A).Obj` (no recursive position) exactly one does +#check @ZeroParadox.idPF_seam_role_not_unique -- Statement: and on `Cofix idPF_Coalgebra.Obj` (one recursive position) not exactly one does +#check @ZeroParadox.not_seam_role_unique_of_step_self -- Statement: a point that is its own child rules uniqueness out; one way (converse-fails control in `ZeroParadox/Category/RootCutDegeneracy.lean`) +#check @ZeroParadox.moduleCat_seam_role_unique_iff_isZero -- Statement: elements of a module, OVER an endomorphism: every endomorphism has exactly one point stepping to itself only iff the module is a zero object; both directions +#check @ZeroParadox.hilbert_zero_seam_role_unique -- Statement: so at the Hilbert zero object `fD_functor.obj 0` every endomorphism does. Reading: that carrier has one point, so the occupancy restates `IsZero` #check @ZeroParadox.Motion.ofPartialFun -- Statement: a partial self-map `g : β → Option β`: UP the identity, OVER `g x = some y` #check @ZeroParadox.Motion.noStepAt_ofPartialFun_iff -- Statement: no step at `y` iff `g y = none`; both directions #check @ZeroParadox.Motion.selfOnlyAt_ofPartialFun_iff -- Statement: a step to itself only iff `g y = some y`; both directions @@ -2771,8 +2964,8 @@ example {L : Type} [ZeroParadox.ZPSemilattice L] (a : L) : example : (ZeroParadox.Motion.ofFun (fun x : ℕ∞ => x + 1)).reverse.SelfOnlyAt ⊤ := ZeroParadox.Motion.selfOnlyAt_of_step_self (fun b c (hb : ⊤ = b + 1) (hc : ⊤ = c + 1) => by - have hb' := (WithTop.add_eq_top.1 hb.symm).resolve_right (by decide) - have hc' := (WithTop.add_eq_top.1 hc.symm).resolve_right (by decide) + have hb' := (WithTop.add_eq_top.1 hb.symm).resolve_right WithTop.one_ne_top + have hc' := (WithTop.add_eq_top.1 hc.symm).resolve_right WithTop.one_ne_top rw [hb', hc']) (show (⊤ : ℕ∞) = ⊤ + 1 from rfl) #check @ZeroParadox.Motion.eq_of_step_to_ofFun_iff_iterate -- Statement: for a function step, `y` is in the first set iff no start other than `y` reaches `y` by iterating; both directions @@ -3184,8 +3377,8 @@ example {σ : Type} [PartialOrder σ] (g : σ → σ) (hg : ∀ x, x ≤ g x) : example : let M := ZeroParadox.Motion.ofTotal (id : Option ℕ → Option ℕ) (fun _ => rfl) (fun a b => b = Option.map Nat.succ a) ¬ @ZeroParadox.Motion.StepLowers (WithBot ℕ) M _ ∧ ¬ @ZeroParadox.Motion.StepLowers (WithTop ℕ) M _ := - ⟨fun h => absurd (h (some 0) (some 1) rfl) (by decide), - fun h => absurd (h (some 0) (some 1) rfl) (by decide)⟩ + ⟨fun h => absurd (WithBot.coe_le_coe.1 (h (some 0) (some 1) rfl)) (by decide), + fun h => absurd (WithTop.coe_le_coe.1 (h (some 0) (some 1) rfl)) (by decide)⟩ -- Statement: CONTROL, a motion moving `none`: OVER `none ↦ some 0`, `some n ↦ some (n + 1)` raises in -- the `WithBot` order and neither raises nor lowers in the `WithTop` order; `none` is in the first set -- and not in the second. @@ -3195,8 +3388,8 @@ example : let M := ZeroParadox.Motion.ofTotal (id : Option ℕ → Option ℕ) ( ¬ @ZeroParadox.Motion.StepLowers (WithTop ℕ) M _ ∧ (∀ a, M.step a none → a = none) ∧ ¬ (∀ b, M.step none b → b = none) := by intro M - refine ⟨?_, fun h => absurd (h none (some 0) rfl) (by decide), - fun h => absurd (h (some 0) (some 1) rfl) (by decide), fun a ha => ?_, + refine ⟨?_, fun h => absurd (h none (some 0) rfl) (WithTop.not_top_le_coe 0), + fun h => absurd (WithTop.coe_le_coe.1 (h (some 0) (some 1) rfl)) (by decide), fun a ha => ?_, fun h => absurd (h (some 0) rfl) (by decide)⟩ · rintro a b rfl rcases a with _ | n @@ -3250,8 +3443,8 @@ example : (fun i : Fin 3 => i + 1) ≠ (fun i => i + 2) ∧ #check @ZeroParadox.towerNONote_orbits -- Statement: the `n`-th stage maps to `towerImageStep^[n] 0` and to `fundamentalSeq n` #check @ZeroParadox.isEmpty_relHom_omegaPow_towerImageStep -- Statement: no relation homomorphism from the steps of `ofFun (ω^·)` on `Ordinal` to those of `ofFun towerImageStep` -- Reading: a span `Ordinal ← NONote → ℤ_[2]`, two maps out of one motion; no map of motions runs from --- `ofFun (ω^·)` on `Ordinal` to the image motion `ofFun towerImageStep`, and no equation between ε₀ and --- ℤ_[2]'s 0 is stated. +-- `ofFun (ω^·)` on `Ordinal` to `ofFun towerImageStep` on the 2-adic side, and no equation between +-- ε₀ and ℤ_[2]'s 0 is stated. #check @ZeroParadox.tower_polarity -- Statement: stage to stage, the ordinal value and the image's valuation rise; the image's norm rises and its `q2Val` falls at stage 0, the reverse from stage 1 #check @ZeroParadox.towerImageStep_no_polarity_norm_q2Val -- Statement: under the norm view and under the `q2Val` view the image step neither raises nor lowers #check @ZeroParadox.towerImageStep_nonzero_polarity -- Statement: on the nonzero points it lowers by norm and raises by `q2Val` @@ -3549,6 +3742,19 @@ example : (∀ a b, (ZeroParadox.Motion.ofFun (fun y : ℤ_[2] => 2 * y)).revers (FiniteMultiplicity.of_prime_left hp hp.ne_zero).emultiplicity_self, add_comm] exact ⟨hd, ZeroParadox.Motion.rank_eq_top_of_cycle _ hd (Relation.TransGen.single (show (0 : ℤ_[2]) = 2 * 0 by rw [mul_zero]))⟩ +-- Statement: and `emultiplicity 2 b + 1 = emultiplicity 2 a` along each such step, by the same +-- rewrite: off ℤ_[2]'s 0 a drop of exactly one; on the self-step at 0, whose order is ⊤ of `ℕ∞`, +-- the equation holds as `⊤ + 1 = ⊤` and nothing drops. +example : ∀ a b, (ZeroParadox.Motion.ofFun (fun y : ℤ_[2] => 2 * y)).reverse.step a b → + emultiplicity (2 : ℤ_[2]) b + 1 = emultiplicity (2 : ℤ_[2]) a := by + have hp : Prime (2 : ℤ_[2]) := by + have := PadicInt.irreducible_p (p := 2) + exact_mod_cast this.prime + intro a b h + have h' : a = 2 * b := h + subst h' + rw [emultiplicity_mul hp, + (FiniteMultiplicity.of_prime_left hp hp.ne_zero).emultiplicity_self, add_comm] -- Reading: the 2-adic order ranks the REVERSED motion; along doubling itself it rises. /-! ### § XXI. Orders on motions, one least-fixed-point shape, UP legs as nuclei -/ @@ -3646,7 +3852,7 @@ example (s : WithTop Ordinal → WithTop Ordinal → Prop) : ((⊥ : Ordinal) : WithTop Ordinal) := by rw [ZeroParadox.Motion.isLanding_ofNucleus_iff, ZeroParadox.snapNucleusTop_coe_bot] exact fun h => ZeroParadox.epsilon0_ne_bot (WithTop.coe_injective h) -#check @ZeroParadox.em_iff_ofNucleus_dneg_isLanding -- Statement: MEMBER: excluded middle iff every proposition is a landing of `ofNucleus (dnegNucleus Prop) s` (`em_iff_dnegNucleus_trivial` through `isLanding_ofNucleus_iff`); `[propext]`: the statement's `SemilatticeInf Prop` instance is read off the pinned `Prop.instHeytingAlgebra` and is choice-free, where the `SemilatticeInf Prop` instance synthesized under that file's imports carries `Classical.choice` through `Prop.instCompleteLinearOrder` (the parent instances `Prop.instHeytingAlgebra` and `Prop.instCompleteLinearOrder`, and the forced form `dnegLandingForcedInstance`, are printed in `ZeroParadox/Category/DieNucleus.lean`) +#check @ZeroParadox.em_iff_ofNucleus_dneg_isLanding -- Statement: MEMBER: excluded middle iff every proposition is a landing of `ofNucleus (dnegNucleus Prop) s` (`em_iff_dnegNucleus_trivial` through `isLanding_ofNucleus_iff`); `[propext]`: the statement's `SemilatticeInf Prop` instance is read off the pinned `Prop.instHeytingAlgebra` and is choice-free; the `SemilatticeInf Prop` instance synthesized under that file's imports goes through `Prop.instCompleteLattice`, and the forced form `dnegLandingForcedInstance` measures `[propext]`; `Prop.completeLinearOrder`, a definition and not an instance, carries `Classical.choice` (`Prop.instHeytingAlgebra`, `Prop.completeLinearOrder` and `dnegLandingForcedInstance` are printed in `ZeroParadox/Category/DieNucleus.lean`) #check @ZeroParadox.no_snap_nucleus -- Statement: NON-MEMBER: for every nucleus `j` on `SynONote`, not every closed point of `j` is fixed by `omegaPow`; so no `ofTotal j _ s` has only `omegaPow`-fixed landings (the die form in `ZeroParadox/Category/DieNucleus.lean` § IV, whose next `example` gives the landings as the closed points). The `Nucleus`-typed corollary of `no_snap_closure`; `SynONote` has no ⊤ over its order (`tower_no_upper_bound`), so `ofNucleus_top_up` is not stated there #check @ZeroParadox.no_snap_closure -- Statement: the order-free form: no idempotent endomap of `ONote` has only `omegaPow`-fixed fixed points; no order, no monotonicity, no inflation assumed @@ -3833,8 +4039,9 @@ example {L : Type*} [ZeroParadox.ZPSemilattice L] (S : ℕ → L) (hS : ZeroPara (fun _ => rfl) (fun a b => ∃ n, a = S n ∧ b = S (n + 1))).reverse) ?_ b hb rintro x y ⟨n, rfl, rfl⟩ exact ZeroParadox.ZPSemilattice.state_sequence_monotone S hS n --- Statement: from `hcc1` and `hcov` alone (`t_snap_given_cover`), ⊥ of `L` has a cover in ZP-A's --- induced order: `BotCovered L`; one way. +-- Statement: from `hcc1` and `hcov` alone, ⊥ of `L` has a cover in ZP-A's induced order: +-- `BotCovered L`; one way. The proof goes through `t_snap_given_cover`, whose premise `S 1 ≠ S 0` +-- it derives from `hcov`. example {L : Type*} [ZeroParadox.ZPSemilattice L] (S : ℕ → L) (hcc1 : S 0 = ZeroParadox.ZPSemilattice.bot) (hcov : letI := ZeroParadox.zpSemilatticeSup L; S 0 ⋖ S 1) : @@ -3861,6 +4068,17 @@ example : clear h1 h2 omega · exact h.2 (c := 1) ((key 0 1).2 (by decide)) ((key 1 2).2 (by decide)) +-- Statement: BRIDGE across the GAP above, one way. The GAP stands for an arbitrary run; the bridge +-- supplies one run from a tape. The tape's randomness is a hypothesis on `w`, its measure sits +-- beside the die (§ XXVIII), and ⊥ of `L` is not claimed random. +#check @ZeroParadox.snap_of_firstStep_MLRandom -- Statement: if ⊥ of `L` has a first step in ZP-A's induced order (`BotHasFirstStep L`) and `w` is Martin-Löf random for `trials p hp` with `0 < p`, then some `φ` and firing proof `hw` make `φ ∘ firedRun w hw` a state sequence meeting `hcc1`, `hocc` and `hcov`; one way +#check @ZeroParadox.linearMaxZPS_snap_target -- Statement: if `α` is linearly ordered with least element `b`, `b ⋖ a`, and `w` is as above, then under join `max` the run's `S 1` covers `b` in `α`'s order and equals `a`; one way +#check @ZeroParadox.phase_snap_of_MLRandom -- Statement: CORNER leg: if `w` is as above, then on `WithBot Ordinal` under join `max` some run's `S 1` covers ⊥ of `WithBot Ordinal`, equals the snap `↑0`, differs from `↑ε₀`, and `phaseUpAndOver.up` sends it to `↑ε₀`; one way +#check @ZeroParadox.epsilonOrZero_snap_of_MLRandom -- Statement: COVER leg: if `w` is as above, then on `EpsilonOrZero` (0 of `Ordinal` and the fixed points of `ω^·`) under join `max` some run's `S 1` covers 0 of `Ordinal` and has value ε₀, which is not 0; one way +#check @ZeroParadox.epsilonOrZeroIsoLanding_spec -- Statement: RELATION: the order isomorphism from `EpsilonOrZero` to the landings of `phaseUpAndOver.up` sends 0 of `Ordinal` to ⊥ of `WithBot Ordinal` (not to `↑0`) and ε₀ to `↑ε₀`, and carries the cover `0 ⋖ ε₀` to a cover among the landings +-- Reading: CARRIER, two views of one step, neither THE view. On the full carrier the first step +-- lands on `↑0` and `↑ε₀` is one UP further (the corner); on the view of landings the first step is +-- ε₀ itself (the cover). The isomorphism is the relation; in both, ε₀ is the step off a floor, not it. -- Statement: the other direction: if a motion on `L` steps elsewhere at ⊥ of `L`, some step `⊥ → b` -- carries T-SNAP's triple at `(⊥, b)`. No landing hypothesis is used, so the UP leg plays no part. example {L : Type*} [ZeroParadox.ZPSemilattice L] (M : ZeroParadox.Motion L) @@ -3967,7 +4185,9 @@ example : ZeroParadox.phaseBelowCoverMotion.Climb ∧ ZeroParadox.phaseBelowCove · exact fun e => ZeroParadox.epsilon0_ne_zero (ZeroParadox.Phase.up.inj e) · exact fun e => ZeroParadox.Phase.noConfusion e exact ⟨h, ZeroParadox.Motion.climb_corner _ h⟩ --- Reading: Q1: if `hcc1` and `hocc`, ⊥ of `L` is the source the run leaves (the constant run at ⊥ of +-- Reading: Q1 and Q2 restate, as answers to the two-pole questions, the `Statement:` examples above +-- and the CONTROLs below, which carry every conditional here; this gloss adds no claim of its own. +-- Q1: if `hcc1` and `hocc`, ⊥ of `L` is the source the run leaves (the constant run at ⊥ of -- `L`, a CONTROL below, never leaves); if moreover `S` is a state sequence, it never re-enters, and in -- the two-state runs above (`c₀, c₁, c₁, …` and `null, exist, exist, …`) the other end (`c₁`, `exist`) -- is where the run stays, stepping to itself only. @@ -4002,12 +4222,12 @@ example {L : Type*} [ZeroParadox.ZPSemilattice L] : exact ⟨hs, fun h => ZeroParadox.Motion.not_selfOnlyAt_and_leavesAt _ _ ⟨hs, h⟩⟩ -- Statement: CONTROL, an ordered field (ℝ is one), in the field's OWN linear order: it has no -- `OrderBot`, so `BotCovered` is not stated in that order (neither member nor non-member); no pair is --- a cover (`not_covBy`); and the field's 0 has no first step (`axb1_fails_in_ordered_field`). `hcov` +-- a cover (`not_covBy_of_denselyOrdered`); and the field's 0 has no first step (`axb1_fails_in_ordered_field`). `hcov` -- is typed in the order a `ZPSemilattice` induces, not this one, so this control is silent on `hcov`. example {F : Type*} [Field F] [LinearOrder F] [IsStrictOrderedRing F] (S : ℕ → F) : IsEmpty (OrderBot F) ∧ ¬ (S 0 ⋖ S 1) ∧ ¬ ZeroParadox.HasFirstStep (0 : F) := ⟨⟨fun h => by letI := h; exact not_lt.2 (bot_le : (⊥ : F) ≤ ⊥ - 1) (sub_one_lt ⊥)⟩, - not_covBy, ZeroParadox.axb1_fails_in_ordered_field⟩ + not_covBy_of_denselyOrdered, ZeroParadox.axb1_fails_in_ordered_field⟩ -- Statement: CONTROL, `Unit`: `hocc` has no member and no motion on `Unit` steps elsewhere. example : (¬ ∃ S : ℕ → Unit, S 1 ≠ S 0) ∧ ∀ M : ZeroParadox.Motion Unit, ¬ M.LeavesAt () := ⟨fun ⟨_, h⟩ => h rfl, fun _ ⟨_, _, h⟩ => h rfl⟩ @@ -4172,15 +4392,20 @@ example : -- p. 11 for this functor, for carriers in one universe; -- `isBisim_eq` is Proposition 5.1 and `isBisim_flip` Theorem 5.2 (p. 31), `isBisim_comp` Theorem* 5.4 -- (p. 32); `Bisimilar` with `isBisim_bisimilar` is the clause of Corollary 5.6 (p. 33) that the --- greatest bisimulation exists, and `bisimilar_equivalence` its last clause, that on one system it --- is an equivalence (its complete-lattice clause is not built); `isBisim_ker` is the bisimulation --- half of Proposition* 5.7 (p. 33), `isBisim_preimage` Proposition* 5.9(2) (p. 34). +-- greatest bisimulation exists; its last clause, that on one system the greatest bisimulation is a +-- bisimulation equivalence, is `bisimilar_equivalence` (the equivalence half) with `isBisim_bisimilar` +-- at `N := M` (the bisimulation half); its complete-lattice clause is not built; `isBisim_ker` is +-- the bisimulation half of Proposition* 5.7 (p. 33), `isBisim_preimage` Proposition* 5.9(2) (p. 34). /-! ### § XXVII. The adjoined point: tagged or a limit -/ -- Reading: a second coordinate on § I's adjoined-points switch: one point adjoined to `ℕ` as a -- constructor (`Option ℕ`, tagged) or as the limit of the finite stages (`NInf`, Escardó's ℕ∞, the -- one-point compactification of `ℕ`; untagged); `ℕ` adjoins none. Definitions and proofs: -- `ZeroParadox/Die.lean` § XXIII. +#check @ZeroParadox.enat_top_isJoint -- Statement: TAGGED: ⊤ of `ℕ∞` (`WithTop ℕ`) is a joint of (the finite values, `{⊤}`) +#check @ZeroParadox.NInf.infty_isJoint -- Statement: LIMIT: `NInf.infty` is a joint of (the finite stages, `{∞}`) +-- Reading: INVARIANT: the joint shape holds on both sides of this coordinate, so it does not separate +-- the tagged point from the limit point; identifying the two carriers is priced in § XXIX. #check @ZeroParadox.NInf -- Statement: decreasing sequences `ℕ → Bool`; finite stages `NInf.ofNat n` and the point `NInf.infty` #check @ZeroParadox.NInf.omniscient -- Statement: every `p : NInf → Bool` is `false` somewhere or `true` everywhere #check @ZeroParadox.NInf.eps_spec -- Statement: `eps` is a selection function: `p (eps p) = true` gives `p` true everywhere @@ -4242,7 +4467,7 @@ example : {t : ZeroParadox.NInf → Bool // ∀ b, t b = true ↔ b = ZeroParado -- Reading: compare the right side with TypeTopology `Taboos.WLPO`: `(u : ℕ∞) → (u ＝ ∞) + (u ≠ ∞)`. #check @ZeroParadox.NInf.isolating_infty_iff -- Statement: a `Bool` test isolates `∞` iff it is `false` at every `NInf.ofNat n` and `true` at `∞` #check @ZeroParadox.NInf.decEq_of_isolating_infty -- Statement: such a test gives `DecidableEq NInf` -#check @ZeroParadox.NInf.isolating_infty_of_decEq -- Statement: and `DecidableEq NInf` gives such a test +#check @ZeroParadox.NInf.isolating_infty_of_decEq -- Statement: and `DecidableEq NInf` gives that such a test exists -- Statement: such a test exists iff `WLPOData` is inhabited; both directions. example : Nonempty {t : ZeroParadox.NInf → Bool // ∀ b, t b = true ↔ b = ZeroParadox.NInf.infty} ↔ Nonempty ZeroParadox.WLPOData := @@ -4270,9 +4495,45 @@ example : ZeroParadox.WLPO ↔ ∀ x y : ZeroParadox.NInf, x = y ∨ x ≠ y := #check @ZeroParadox.NInf.mem_toPart_iff -- Statement: `n ∈ toPart x ↔ x = NInf.ofNat n` #check @ZeroParadox.NInf.toPart_injective -- Statement: `toPart` is one-to-one #check @ZeroParadox.NInf.toPart_ofOption -- Statement: `toPart ∘ ofOption = Part.ofOption` +-- Statement: between `NInf` and `Part ℕ`, the Rosolini partial elements: `toRos` is `toPart` with a +-- witness for its definedness, and the inclusion into `Part ℕ` undoes the witness. +#check @ZeroParadox.NInf.RosPart -- Statement: partial elements of `ℕ` defined iff `∃ n, α n = true`, for some `α : ℕ → Bool` +#check @ZeroParadox.NInf.toRos -- Statement: `toPart x`, with the witness `fun n => !x n` +example (x : ZeroParadox.NInf) : (ZeroParadox.NInf.toRos x).1 = ZeroParadox.NInf.toPart x := rfl +#check @ZeroParadox.NInf.toRos_surjective_iff -- Statement: `toRos` is onto iff LPO; both directions +example : Function.Surjective ZeroParadox.NInf.toRos ↔ ZeroParadox.LPO := + ZeroParadox.NInf.toRos_surjective_iff +#check @ZeroParadox.NInf.AllRosolini -- Statement: every `p : Prop` has some `α` with `p ↔ ∃ n, α n = true` +#check @ZeroParadox.NInf.rosIncl_surjective_iff -- Statement: the inclusion `RosPart → Part ℕ` is onto iff `AllRosolini`; both directions +#check @ZeroParadox.NInf.allRosolini_of_em -- Statement: excluded middle gives `AllRosolini`; one way +#check @ZeroParadox.NInf.em_of_allRosolini_lpo -- Statement: `AllRosolini` and LPO together give excluded middle +-- Reading: whether `AllRosolini` alone gives excluded middle, or any taboo, is not established here. +-- Reading (cited, not claimed): `AllRosolini` is Kripke's schema, "all propositions are Rosolini" +-- (Knapp, arXiv:2011.00272, § 5.12, p. 108, with "Kripke's Schema and Markov's Principle together +-- imply excluded middle"), and `BKS⁺` in TypeTopology `NotionsOfDecidability.SemiDecidable` (de Jong, +-- retrieved 2026-11-01), which has `EM→BKS⁺`, `BKS⁺→LPO→EM`, and for `Ω` the analogues of +-- `rosIncl_surjective_iff` (`BKS⁺-in-terms-of-Ωˢᵈ-and-Ω`) and of `toRos_surjective_iff` +-- (`LPO-in-terms-of-𝟚-and-Ωˢᵈ`). -- Statement: backward, each exact map gives a taboo. #check @ZeroParadox.NInf.lpo_of_exactTag -- Statement: `NInf → Option ℕ` with `g x = some n ↔ x = NInf.ofNat n` gives LPO #check @ZeroParadox.NInf.wlpo_of_tag -- Statement: `NInf → Option ℕ` with `g x = none ↔ x = ∞` gives WLPO +#check @ZeroParadox.NInf.wlpo_of_discrete_tag -- Statement: `g : NInf → D`, `D` with decidable equality, with `g x = g ∞ ↔ x = ∞` at every `x`, gives WLPO (`[propext, Quot.sound]`) +-- Reading (cited, not claimed): compare `disagreement-taboo'` (discrete `D`) and +-- `basic-discontinuity-taboo`, TypeTopology `Taboos.BasicDiscontinuity` (retrieved 2026-10-29). +-- Statement: `wlpo_of_tag`'s conclusion follows from it at `D = Option ℕ`. +example (g : ZeroParadox.NInf → Option ℕ) (hg : ∀ x, g x = none ↔ x = ZeroParadox.NInf.infty) : + ZeroParadox.WLPO := + ZeroParadox.NInf.wlpo_of_discrete_tag g fun x => by + rw [(hg ZeroParadox.NInf.infty).2 rfl]; exact hg x +-- Statement: CONTROL: a constant map into any type fails the hypothesis, at `NInf.ofNat 0`. +example {D : Type} (c : D) : + ¬ ∀ x : ZeroParadox.NInf, (fun _ => c) x = (fun _ => c) ZeroParadox.NInf.infty ↔ + x = ZeroParadox.NInf.infty := + fun h => ZeroParadox.NInf.ofNat_ne_infty 0 ((h (ZeroParadox.NInf.ofNat 0)).1 rfl) +-- Statement: CONTROL: `g = id` into `D = NInf` meets the hypothesis, so `DecidableEq NInf` alone gives +-- WLPO; `NInf.decEq_classical` (above) supplies that instance with no WLPO hypothesis. +example (d : DecidableEq ZeroParadox.NInf) : ZeroParadox.WLPO := + @ZeroParadox.NInf.wlpo_of_discrete_tag ZeroParadox.NInf d id fun _ => Iff.rfl #check @ZeroParadox.NInf.em_of_partToNInf -- Statement: `Part ℕ → NInf` with `g o = NInf.ofNat n ↔ n ∈ o` gives excluded middle example (g : Part ℕ → ZeroParadox.NInf) (hg : ∀ o n, g o = ZeroParadox.NInf.ofNat n ↔ n ∈ o) : ZeroParadox.ExcludedMiddle := ZeroParadox.NInf.em_of_partToNInf g hg @@ -4332,8 +4593,8 @@ example : Function.Surjective ZeroParadox.NInf.ofOption ↔ ZeroParadox.LPO := #check @ZeroParadox.NInf.rightInverse_ofLPOData -- Statement: it is a right inverse of `ofOption` #check @ZeroParadox.NInf.equivOptionOfLPOData -- Statement: `LPOData` gives `NInf ≃ Option ℕ`, inverse `ofOption` #check @ZeroParadox.NInf.equivOptionClassical -- Statement: CONTROL: `NInf ≃ Option ℕ` from `Classical.dec`, with no LPO hypothesis --- Statement: CONTROL: into `Part ℕ` instead of `Option ℕ`, `toPart` undoes `ofOption` up to --- `Part.ofOption` (`toPart ∘ ofOption = Part.ofOption`) with no hypothesis; a map back +-- Statement: CONTROL: into `Part ℕ` instead of `Option ℕ`, `toPart ∘ ofOption = Part.ofOption` +-- with no hypothesis; a map back -- `g : Part ℕ → NInf` with `g o = NInf.ofNat n ↔ n ∈ o`, which is then a two-sided inverse of -- `toPart` (the second `example` below), gives excluded middle (`NInf.em_of_partToNInf`). example (o : Option ℕ) : @@ -4370,6 +4631,150 @@ example (g : Part ℕ → ZeroParadox.NInf) (hg : ∀ o n, g o = ZeroParadox.NIn #check @ZeroParadox.Motion.loopAt_image_iff_leftInverse -- Statement: loops at every `inr (ofOption o)` iff `r` is a left inverse; both directions #check @ZeroParadox.Motion.loopAt_image_iff_loopAt_all -- Statement: loops at every `inr (ofOption o)` iff at every `inr x`; both directions #check @ZeroParadox.Motion.lpo_of_loopAt_image -- Statement: loops at every `inr (ofOption o)` give LPO +-- Statement: the limit map `L` into `Ordinal`. If `L : NInf → Ordinal.{0}` is +-- `L x = ⨆ n, (if x n then fundamentalSeq (n + 1) else 0)` at every `x`, then: (i) `L` sends +-- `NInf.ofNat k` to `fundamentalSeq k`, the `k`-th stage of the ω-tower; (ii) the image of +-- `NInf.infty` is not ⊥ of `Ordinal` (`epsilon0_ne_bot`), and the image of `NInf.ofNat 0` is; +-- (iii) `L` sends `NInf.infty` to `epsilonZero`, ε₀; (iv) `L x = ε₀ ↔ x = NInf.infty` at every `x`; +-- (v) on `Option ℕ`, `L ∘ ofOption` is the tagged map `none ↦ ε₀`, `some k ↦ fundamentalSeq k`; +-- (vi) any decidable equality on `Ordinal.{0}` gives WLPO, by `wlpo_of_discrete_tag` with (iv). +example (L : ZeroParadox.NInf → Ordinal.{0}) + (hL : ∀ x, L x = ⨆ n : ℕ, if x.1 n = true then ZeroParadox.fundamentalSeq (n + 1) else 0) : + (∀ k, L (ZeroParadox.NInf.ofNat k) = ZeroParadox.fundamentalSeq k) ∧ + (L ZeroParadox.NInf.infty ≠ ⊥ ∧ L (ZeroParadox.NInf.ofNat 0) = ⊥) ∧ + L ZeroParadox.NInf.infty = ZeroParadox.epsilonZero ∧ + (∀ x, L x = ZeroParadox.epsilonZero ↔ x = ZeroParadox.NInf.infty) ∧ + (∀ o : Option ℕ, L (ZeroParadox.NInf.ofOption o) = + o.elim ZeroParadox.epsilonZero ZeroParadox.fundamentalSeq) ∧ + (DecidableEq Ordinal.{0} → ZeroParadox.WLPO) := by + have mono : Monotone ZeroParadox.fundamentalSeq := + (strictMono_nat_of_lt_succ ZeroParadox.fundamentalSeq_strictMono).monotone + have zle : ∀ a : Ordinal.{0}, 0 ≤ a := fun a => by rw [← Ordinal.bot_eq_zero]; exact bot_le + have bdd : ∀ x : ZeroParadox.NInf, BddAbove (Set.range fun n : ℕ => + if x.1 n = true then ZeroParadox.fundamentalSeq (n + 1) else (0 : Ordinal.{0})) := fun x => + ⟨ZeroParadox.epsilonZero, by + rintro _ ⟨n, rfl⟩ + dsimp only + split + · exact le_of_lt (ZeroParadox.epsilonZero_tower_lt (n + 1)) + · exact zle _⟩ + have h1 : ∀ k, L (ZeroParadox.NInf.ofNat k) = ZeroParadox.fundamentalSeq k := fun k => by + rw [hL] + apply le_antisymm + · apply ciSup_le + intro n + show (if decide (n < k) = true then _ else _) ≤ _ + split + · next h => exact mono (by simpa using h) + · exact zle _ + · cases k with + | zero => exact zle _ + | succ j => + refine le_trans ?_ (le_ciSup (bdd (ZeroParadox.NInf.ofNat (j + 1))) j) + show _ ≤ (if decide (j < j + 1) = true then _ else _) + rw [if_pos (by simp)] + have h2 : L ZeroParadox.NInf.infty = ZeroParadox.epsilonZero := by + rw [hL] + apply le_antisymm + · apply ciSup_le + intro n + show (if true = true then _ else _) ≤ _ + rw [if_pos rfl]; exact le_of_lt (ZeroParadox.epsilonZero_tower_lt (n + 1)) + · rw [ZeroParadox.epsilonZero_eq_iSup] + apply ciSup_le + intro n + refine le_trans (mono (Nat.le_succ n)) + (le_trans ?_ (le_ciSup (bdd ZeroParadox.NInf.infty) n)) + show _ ≤ (if true = true then _ else _) + rw [if_pos rfl] + have h3 : ∀ x, L x = ZeroParadox.epsilonZero ↔ x = ZeroParadox.NInf.infty := fun x => by + constructor + · intro h + apply ZeroParadox.NInf.separated + intro hne + apply hne + apply ZeroParadox.NInf.eq_infty_of_ne_ofNat + intro k e + rw [e, h1] at h + exact absurd h (ne_of_lt (ZeroParadox.epsilonZero_tower_lt k)) + · rintro rfl; exact h2 + refine ⟨h1, ⟨fun e => ZeroParadox.epsilon0_ne_bot (h2.symm.trans e), + (h1 0).trans (Ordinal.bot_eq_zero).symm⟩, h2, h3, fun o => ?_, ?_⟩ + · cases o with + | none => exact h2 + | some k => exact h1 k + · intro d + exact @ZeroParadox.NInf.wlpo_of_discrete_tag Ordinal.{0} d L fun x => by rw [h2]; exact h3 x +-- Statement: CONTROL: under `classical`, WLPO holds with no `L` at all. +example : ZeroParadox.WLPO := by + classical + exact fun r => em _ +-- Statement: CONTROL: a decidable equality on `Ordinal.{0}` gives weak excluded middle with no `L`, +-- deciding `⨆ _ : p, 1 = 0`. +example (d : DecidableEq Ordinal.{0}) : ZeroParadox.WeakExcludedMiddle := by + intro p + let o : Ordinal.{0} := ⨆ _ : p, (1 : Ordinal.{0}) + have hb : BddAbove (Set.range fun _ : p => (1 : Ordinal.{0})) := Ordinal.bddAbove_of_small + cases d o 0 with + | isFalse h => + refine Or.inr fun hnp => h ?_ + have : IsEmpty p := ⟨hnp⟩ + simp [o] + | isTrue h => + refine Or.inl fun hp => ?_ + have h1 : (1 : Ordinal.{0}) ≤ o := le_ciSup hb hp + rw [h] at h1 + exact absurd h1 (by simp) +-- Statement: `epsilonZero` and `fundamentalSeq`, named in `hL` and in (i), (iii), (iv) and (v), each +-- depend on `Classical.choice`; their footprints are printed next. +#print axioms ZeroParadox.epsilonZero +#print axioms ZeroParadox.fundamentalSeq +-- Statement: weak excluded middle gives WLPO. +#check @ZeroParadox.wlpo_of_weakExcludedMiddle +-- Statement: (vi) also holds with no `L`: a decidable equality on `Ordinal.{0}` gives WLPO, by the +-- second CONTROL above's argument composed with `wlpo_of_weakExcludedMiddle`. +example (d : DecidableEq Ordinal.{0}) : ZeroParadox.WLPO := by + refine ZeroParadox.wlpo_of_weakExcludedMiddle fun p => ?_ + let o : Ordinal.{0} := ⨆ _ : p, (1 : Ordinal.{0}) + have hb : BddAbove (Set.range fun _ : p => (1 : Ordinal.{0})) := Ordinal.bddAbove_of_small + cases d o 0 with + | isFalse h => + refine Or.inr fun hnp => h ?_ + have : IsEmpty p := ⟨hnp⟩ + simp [o] + | isTrue h => + refine Or.inl fun hp => ?_ + have h1 : (1 : Ordinal.{0}) ≤ o := le_ciSup hb hp + rw [h] at h1 + exact absurd h1 (by simp) +-- Reading: in (vi) `L` tags `NInf.infty` through a decidable equality on `Ordinal.{0}`, as +-- `wlpo_of_tag` tags it through `Option ℕ`'s. `Option ℕ`'s decidable equality is an instance; the one +-- on `Ordinal.{0}` is a hypothesis here, and given one, weak excluded middle follows (the second +-- CONTROL above, and the `example` after `wlpo_of_weakExcludedMiddle`; both proofs print `Classical.choice` +-- from the ambient `Ordinal` API, so their constructive reading is not measured here). Read +-- constructively, the content of (vi) lies in its hypothesis: by de Jong and Escardó's argument (cited +-- next) a decidable equality gives weak excluded middle, and `wlpo_of_weakExcludedMiddle` gives WLPO; +-- neither Lean proof measures this. Classically WLPO needs no hypothesis (the first +-- CONTROL above). `L` is not claimed to be computable or choice-free. +-- Reading (cited, not claimed): T. de Jong and M. H. Escardó, "Predicative Aspects of Order Theory +-- in Univalent Foundations", FSCD 2021, arXiv:2102.08812, Theorem 37, p. 10: a nontrivial locally +-- small δ-complete poset with decidable equality gives weak excluded middle. The second CONTROL above meets +-- their hypothesis at `0 < 1` in `Ordinal.{0}`, with `⨆ _ : p, 1` their `Δ_{0,1}(p)` (Definition 29, +-- p. 9); its proof decides only `o = 0`, equality with ⊥ of `Ordinal.{0}`, and is the proof of T. de Jong, +-- "Apartness, sharp elements and the Scott topology of domains", MSCS (2023), arXiv:2106.05064v5, +-- Prop 22, p. 7 ("¬P holds if and only if ⨆ {x | P} = ⊥"). +-- Reading (cited, not claimed): N. Kraus, F. Nordvall Forsberg and C. Xu, "Type-theoretic approaches +-- to ordinals", TCS 957 (2023), arXiv:2208.03844, Theorem 17, p. 18: an ordinal structure with zero, +-- successors and limits of strictly increasing sequences, and with decidable equality, gives WLPO. +-- (vi) is a conclusion of that shape at `Ordinal.{0}`, reached here through `wlpo_of_discrete_tag`. +-- Reading (cited, not claimed): Escardó, preprint of JSL 78(3) (2013), § 11, p. 19: Coquand, +-- Hancock and Setzer's limit structures reach `γ`-transfinite iteration for any `γ < ε₀` in the +-- presence of simple types, and Escardó infers from that ("The argument of the first paragraph +-- shows ...") that "it is not possible to embed ε₀ in 2^ℕ using limit structures"; of embedding +-- `[0, ε₀]` in `2^ℕ` within HA^ω: "We do not dare to conjecture this or its negation". `L` is not +-- such an embedding: it runs the other way, from `NInf`, a subset of `2^ℕ`, into `Ordinal`, and at +-- `NInf.ofNat k` and `NInf.infty` it takes only the values `fundamentalSeq k` and `epsilonZero` +-- ((i), (iii)). -- Reading (cited, not claimed): Escardó, preprint of JSL 78(3) (2013): `NInf` is his `ℕ∞` (p. 1), -- `eps` his selection function (Theorem 3.5, p. 5), `exists_ne_infty_eq_false_or` his Lemma 8.1 by his -- proof (p. 14), `wlpo_of_eqOr_infty` the right-to-left half of his WLPO row (p. 4) and @@ -4378,7 +4783,8 @@ example (g : Part ℕ → ZeroParadox.NInf) (hg : ∀ o n, g o = ZeroParadox.NIn -- makes equivalent (`isolating_infty_iff`) to the basic discontinuity (p. 5; `basic-discontinuity` -- in TypeTopology `Taboos.BasicDiscontinuity`), which his WLPO row, with Lemma 3.3 again, turns -- into WLPO; compare de Jong and Escardó, arXiv:2601.12536, § 7.2, Lemma 7.2, p. 25, for a map --- `f : ℕ∞ → ℕ∞` with `f n̲ = 0` and `f ∞ = 1`. Escardó's Theorem 7.1(1) (p. 13) gets WLPO from +-- `f : ℕ∞ → ℕ∞` with `f n̲ = 0̲` and `f ∞ = 1̲`, values that are points of `ℕ∞`. Escardó's +-- Theorem 7.1(1) (p. 13) gets WLPO from -- any discontinuous map `ℕ∞ → 2` assuming countable choice. -- `wlpo_iff_eqOr`, `decEq_of_wlpoData` and `wlpoData_of_decEq`: compare Escardó's TypeTopology -- module `Taboos.WLPO` (retrieved 2026-10-29), `ℕ∞-discrete-gives-WLPO` and @@ -4392,8 +4798,15 @@ example (g : Part ℕ → ZeroParadox.NInf) (hg : ∀ o n, g o = ZeroParadox.NIn -- Escardó and Knapp, CSL 2017, LIPIcs 82, § 2.7, p. 21:6: lifting by the decidable dominance is -- `X + 1` and by all propositions is `L X`; § 2.8, pp. 21:6–21:7: "the decidability of Rosolini -- propositions is known as LPO", and the Rosolini structures sit in their `ℕ∞`, presented there --- as `Σ α, isProp ⟨α⟩`, which is not related to `NInf` in Lean here. The trichotomy route through --- `hmap` is constructed here, not from a source. +-- as `Σ α, isProp ⟨α⟩` (p. 21:7); that presentation is not formalized here. Their Rosolini +-- propositions (§ 2.4, p. 21:5) correspond to the definedness of `RosPart`, with the differences +-- stated below, and `toRos_surjective_iff` relates `NInf` to them: `toRos` is onto iff LPO; +-- compare the quoted sentence. There a proposition `A` is Rosolini when +-- `∃ α, isProp⟨α⟩ × (A = ⟨α⟩)` with `⟨α⟩ = Σ n, α n = 1` (p. 21:4); in `RosPart` the existential +-- is a `Prop`, definedness is `↔`, not `=`, and `isProp⟨α⟩` (`α` true at most once) is dropped, +-- as in TypeTopology `NotionsOfDecidability.SemiDecidable`, whose `is-semidecidable` "is called +-- isRosolini in [EK2017]" (retrieved 2026-11-01). The trichotomy route through `hmap` is +-- constructed here, not from a source. -- `ofOption` is `ι𝟙 : ℕ + 𝟙 → ℕ∞` in TypeTopology's module -- `TypeTopology.GenericConvergentSequence` (retrieved 2026-10-29), which also holds `ℕ∞-density`, -- `ι𝟙-dense` and `not-finite-is-∞`. `density` is the two-map form of Escardó's Lemma 3.4, by the @@ -4420,4 +4833,109 @@ example (g : Part ℕ → ZeroParadox.NInf) (hg : ∀ o n, g o = ZeroParadox.NIn -- statements of `density` and `rightInverse_of_leftInverse`, run against the corpus before these -- lemmas existed, closed neither (2026-10-30). +/-! ### § XXVIII. The slot machine: possibility on the motion, one run's crossing under typicality -/ +-- Reading: OVER's possibility of leaving a point is a fact about the motion; whether ONE run leaves +-- is a fact about that run. The measure sits beside the die, on the tapes that drive runs. +-- Definitions and proofs: `ZeroParadox/Information/CrossingTrials.lean` § IV–VII. +#check @ZeroParadox.slotMotion -- Statement: on `Bool`, UP the identity; every point steps to itself, and `false` steps to `true` +#check @ZeroParadox.slotMotion_leavesAt_false -- Statement: `false` steps elsewhere and steps to itself +#check @ZeroParadox.slotMotion_selfOnlyAt_true -- Statement: `true` steps to itself and to nothing else +#check @ZeroParadox.Motion.LaxHom.leavesAt -- Statement: along a one-to-one lax map, stepping elsewhere at `y` gives it at the image of `y` +#check @ZeroParadox.slotRun_isRun -- Statement: every tape drives a run of `slotMotion` +#check @ZeroParadox.slotRun_crosses_iff -- Statement: the run starts at `false`, and reaches `true` iff the tape fires somewhere; both directions +#check @ZeroParadox.exists_fires_io -- Statement: if `0 < p ≤ 1`, SOME tape fires infinitely often (measure one is nonempty) +#check @ZeroParadox.fires_io_of_avoids -- Statement: if `0 < p ≤ 1` and the tape avoids a class holding every zero-block test for `trials p hp`, it fires infinitely often; one way +#check @ZeroParadox.slotRun_image_departs_of_avoids -- Statement: under the same hypotheses and a one-to-one lax map, the image run is a run that leaves its start; one way +#check @ZeroParadox.squaresTape_not_avoids -- Statement: if `0 < p ≤ 1` and `𝒯` holds every zero-block test for `trials p hp`, the squares tape does not avoid `𝒯` +-- Statement: sufficient, not necessary: the second `example` after `slotRun_image_departs_of_avoids` +-- in `ZeroParadox/Information/CrossingTrials.lean` gives, for every one-to-one lax map `φ`, every +-- `0 < p ≤ 1` and every class `𝒯` holding the zero-block tests for `trials p hp`, the squares tape, +-- whose image run under `φ` leaves its start, yet which does not avoid `𝒯`. +-- Statement: CONTROL: with no typicality hypothesis, the all-`false` tape drives a run of +-- `slotMotion` that is `false` at every stage, though `false` steps elsewhere. +example : (∀ n, ZeroParadox.slotRun (fun _ => false) n = false) ∧ + ZeroParadox.slotMotion.LeavesAt false := + ⟨fun n => by simp [ZeroParadox.slotRun], ZeroParadox.slotMotion_leavesAt_false.1⟩ +-- Fired once gives T-SNAP's hypotheses: `ZeroParadox/Information/CrossingTrials.lean` § VIII. +#check @ZeroParadox.firedRun_spec -- Statement: if the tape fires somewhere, the shifted run is `false` at stage 0 and `true` at every later stage +#check @ZeroParadox.t_snap_of_fires_once -- Statement: if `φ` sends `false` to ⊥ of `L` and `true` elsewhere, and the tape fires somewhere (`hw`), `φ ∘ firedRun` meets `t_snap_given`'s `hcc1`, `hocc`; one way +#check @ZeroParadox.trials_fires_once -- Statement: if `0 < p ≤ 1`, the tapes that fire somewhere have `trials p hp` measure one +#check @ZeroParadox.t_snap_of_avoids -- Statement: § VI's hypotheses on a tape give its `hw` and `t_snap_of_fires_once`'s conclusion; one way +-- Reading: `hw` is the occurrence commitment in its slot chart (`ZeroParadox/Order/SnapCannotBe.lean` § II). +-- Statement: if ⊥ of `L` has a first step and the tape is Martin-Löf random for `trials p hp` with `0 < p`, some run from it also carries the cover `hcov`, one way: `snap_of_firstStep_MLRandom`, the carrier-to-run bridge in § XXIII. + +/-! ### § XXIX. A limit pinned from two directions: `PinnedLimit` -/ +-- Reading: Tim's role, "squishy" in his word: pinned from below by the stages of a run and from the +-- step map by its fixed points. Definitions and proofs: `ZeroParadox/Die.lean` § XXIV. +#check @ZeroParadox.PinnedLimit -- Statement: `c` is the least upper bound of `Set.range s`, is not in it, and is the least fixed point of `g`, and the run climbs (`Monotone s`) +#check @ZeroParadox.PinnedLimitUnique -- Statement: `PinnedLimit g s c`, and every fixed point of `g` is `c` +#check @ZeroParadox.PinnedLimitAbove -- Statement: `PinnedLimit` with clause (c) relative: the least fixed point of `g` at or above `s 0` +#check @ZeroParadox.PinnedLimit.toAbove -- Statement: `PinnedLimit g s c → PinnedLimitAbove g s c`, for every run; the converse fails (ε₁, the CONTROL in `ZeroParadox/Order/UpAndOver.lean` § V) +#check @ZeroParadox.pinnedLimitAbove_iff_of_bot -- Statement: when `s 0` is ⊥ of the carrier, the two are equivalent; both directions +#check @ZeroParadox.pinnedLimit_iff_closure_omega -- Statement: monotone `g`, run from ⊥ of a partial order: `PinnedLimit` at `c` iff `c` is the least upper bound of the stages, `g c = c`, and no stage is fixed; both directions +-- Reading (cited, not claimed): the right side is closure ordinal ω (A. Das and L. Melgaard, FSCD +-- 2023, doi:10.4230/LIPIcs.FSCD.2023.23, 23:4, Example 2.9). +#check @ZeroParadox.not_pinnedLimitAbove_of_finite -- Statement: on a finite partial order, `PinnedLimitAbove` has no occupant, at any step and any run +#check @ZeroParadox.not_pinnedLimit_of_finite -- Statement: on a finite partial order, `PinnedLimit` has no occupant, at any step and any run +#check @ZeroParadox.NInf.instPartialOrder -- Statement: tape-wise order on `NInf` +#check @ZeroParadox.NInf.bot_eq -- Statement: ⊥ of `NInf` is `NInf.ofNat 0`, the all-`false` tape +#check @ZeroParadox.NInf.top_eq -- Statement: ⊤ of `NInf` is `NInf.infty`, the all-`true` tape +#check @ZeroParadox.NInf.succ_fixed_iff -- Statement: `succ x = x ↔ x = ∞`; both directions +-- Reading (cited, not claimed): TypeTopology's `TypeTopology.GenericConvergentSequence` has both +-- halves, `unique-fixed-point-of-Succ : funext₀ → (u : ℕ∞) → u ＝ Succ u → u ＝ ∞` and +-- `Succ-∞-is-∞ : funext₀ → Succ ∞ ＝ ∞`; `TypeTopology.SquashedCantor` uses "the fact that ∞ is the +-- unique fixed point of Succ" (retrieved 2026-11-03). +#check @ZeroParadox.NInf.pinnedLimitUnique_succ -- Statement: `NInf.ofNat` is a run of `succ`, and `∞` occupies `PinnedLimitUnique succ NInf.ofNat` +#check @ZeroParadox.epsilon0_pinnedLimit -- Statement: ε₀ occupies `PinnedLimit (ω^·) fundamentalSeq`, the tower from ⊥ of `Ordinal` +#check @ZeroParadox.epsilon0_not_pinnedLimitUnique -- Statement: ε₀ does not occupy `PinnedLimitUnique`: ε₁ is another fixed point +-- Statement: CARRIER. The strong form `PinnedLimitUnique` holds at `NInf`'s `∞` +-- (`NInf.pinnedLimitUnique_succ`) and fails at ε₀ (`epsilon0_not_pinnedLimitUnique`); no identity +-- between `∞` and ε₀ is stated. +#check @ZeroParadox.pinnedLimit_opow_eq_epsilon0 -- Statement: under ω^·, every occupant of `PinnedLimit`, over any run, is ε₀ +#check @ZeroParadox.ordinalCornerStep_pinnedLimitAbove -- Statement: at every floor `f`, `ordinalCornerStep f` occupies `PinnedLimitAbove (ω^·)` at the run from `succ f` +#check @ZeroParadox.epsilon_succ_pinnedLimitAbove -- Statement: ε_(o+1) occupies `PinnedLimitAbove (ω^·)` at the run from `succ ε_o`, for every `o` +#check @ZeroParadox.NInf.covered_limit_searchable -- Statement: each `NInf.ofNat n ⋖ NInf.ofNat (n + 1)`, `BotCovered` and `EveryStepCovered` hold, `∞` is a successor limit, and some `e` has `p (e p) = true → ∀ x, p x = true` for every `p` +-- Statement: INVARIANT: `PinnedLimitUnique` holds at `NInf`'s `∞` and at `WithTop ℕ`'s `⊤` with +-- `· + 1`, so the predicate does not separate the two carriers. +#check @ZeroParadox.pinnedLimitUnique_withTop +#check @ZeroParadox.PinnedLimit.isJoint -- Statement: in a partial order, if `c` occupies `PinnedLimit g s c`, then `c` is a joint of (the stages, the fixed points of `g`); one way, and the `Bool` preorder CONTROL in `ZeroParadox/Order/DieJoints.lean` makes antisymmetry a premise +#check @ZeroParadox.epsilon0_isJoint -- Statement: ε₀ is a joint of (the ω-tower from ⊥ of `Ordinal`, the fixed points of `ω^·`), by `epsilon0_pinnedLimit`; CONTROLs in the home file: ω is a joint too, and against the fixed points at or above ε₁ the tower has no cut point at ε₀ +#check @ZeroParadox.NInf.wlpo_of_iso -- Statement: identifying the two carriers by an order isomorphism `NInf ≃o WithTop ℕ` gives WLPO (`[propext, Quot.sound]`) +#check @ZeroParadox.NInf.orderIsoWithTopClassical -- Statement: CONTROL: such an isomorphism from `Classical.propDecidable`, with no WLPO hypothesis + +/-! ### § XXX. First-occurrence time as a Galois insertion: tapes onto `NInf`, order reversed -/ +-- Reading: Tim's "bend" (2026-11-03): one tape, a firing record in `ℕ → Bool` (pointwise order) and a +-- waiting time `NInf.det` in `NInf`. "Time" is his reading, not a claim. Definitions and proofs: +-- `ZeroParadox/Die.lean` § XXV. +#check @ZeroParadox.NInf.det_antitone -- Statement: `det` is antitone: `r ≤ r'` gives `det r' ≤ det r` +#check @ZeroParadox.NInf.det_poles -- Statement: `det ⊥ = ⊤` and `det ⊤ = ⊥`, ⊥ and ⊤ of `ℕ → Bool` to ⊤ and ⊥ of `NInf` +-- Statement: CARRIER. The all-`false` tape is ⊥ of `ℕ → Bool`; its waiting time is ⊤ of `NInf`, `∞` +-- (`det_poles`), and that point occupies `PinnedLimitUnique succ ofNat`: +#check @ZeroParadox.NInf.det_bot_pinnedLimitUnique +#check @ZeroParadox.NInf.le_det_iff -- Statement: `x ≤ det r ↔ r ≤ negS x`; both directions +#check @ZeroParadox.NInf.det_gi -- Statement: `det` into `NInfᵒᵈ` and `negS` form a Galois insertion (Mathlib `GaloisInsertion`) +-- Statement: `(det r).1 n = !(partialSups r n)` at every `n`, pointwise against Mathlib's `partialSups` +-- (the `example` after `det_gi`, `ZeroParadox/Die.lean` § XXV). Axioms: `det_gi` `[propext, Quot.sound]`, +-- Mathlib's `partialSups.gi` `[propext, Classical.choice, Quot.sound]`. +-- Statement: `det r = ofNat (Nat.find hw)` when `r` fires (the `example` in `ZeroParadox/Die.lean` § XXV) +-- and `det r = infty` iff it never does (`NInf.det_eq_infty_iff`): `det r` is the first hitting time +-- of `true` in `r`, as `Nat.find` is in `firedRun` (`ZeroParadox/Information/CrossingTrials.lean`). +#check @ZeroParadox.NInf.detHom -- Statement: `det` as a `BoundedOrderHom` from `ℕ → Bool` into `NInfᵒᵈ` +#check @ZeroParadox.NInf.no_lower_adjoint -- Statement: no `g` has `g x ≤ r ↔ det r ≤ x` +#check @ZeroParadox.NInf.det_not_injective -- Statement: `det` is not injective +#check @ZeroParadox.NInf.det_exactS -- Statement: `exactS` is a second section of `det`; `exactS (ofNat j)` fires exactly at `j`, `exactS infty` never (examples in `ZeroParadox/Die.lean` § XXV) +#check @ZeroParadox.NInf.exactS_not_mono -- Statement: and `exactS` is neither antitone nor monotone +#check @ZeroParadox.NInf.naiveS_fails -- Statement: `naiveS` is not a section: `det (naiveS (ofNat 0)) = ∞` +#check @ZeroParadox.NInf.head_also_poles -- Statement: CONTROL: `firstBitWait` is antitone with both poles and is not `det` +#check @ZeroParadox.NInf.const0_fails -- Statement: CONTROL: the constant `ofNat 0` is antitone and misses `det ⊥ = ⊤` +#check @ZeroParadox.NInf.constInf_fails -- Statement: CONTROL: the constant `∞` is antitone and misses `det ⊤ = ⊥` +#check @ZeroParadox.NInf.no_nat_wait -- Statement: CONTROL: no antitone `f : (ℕ → Bool) → ℕ` sends the tape firing exactly at `n` to `n` +#check @ZeroParadox.NInf.nat_no_top -- Statement: CONTROL for `det_poles`: no `b : ℕ` is a top of `ℕ`, so no map into `ℕ` sends ⊥ of `ℕ → Bool` to a top +#check @ZeroParadox.NInf.tape_bot_le -- Statement: `⊥ ≤ r` on `ℕ → Bool` with axioms `[propext]`; Mathlib's `bot_le` there carries `Classical.choice` (`NInf.mathlib_bot_le_tape`) +-- Statement: TypeTopology `TypeTopology.GenericConvergentSequence` has +-- `ℕ∞-retract-of-Cantor : funext₀ → retract ℕ∞ of (ℕ → 𝟚)`, with retraction `ℕ→𝟚-to-ℕ∞` built from +-- `force-decreasing` and section `ι` (retrieved 2026-11-04). `det` is `ℕ→𝟚-to-ℕ∞` after bitwise +-- complement: `det r` satisfies `force-decreasing`'s two defining equations at `β = !r` (the `example` +-- in `ZeroParadox/Die.lean` § XXV). `negS` is complement after `ι`, by its definition. + end DieCannotBeIndex diff --git a/ZeroParadox/Information/BrudnoBridge.lean b/ZeroParadox/Information/BrudnoBridge.lean new file mode 100644 index 00000000..ba45c146 --- /dev/null +++ b/ZeroParadox/Information/BrudnoBridge.lean @@ -0,0 +1,156 @@ +-- EXPERIMENTAL (bridge): our `trials` and `MLRandom` against Milovanov's `kolmogorov-complexity-lean` (commit 7e71116), to cite its entropy-rate theorems and its prefix-complexity Levin–Schnorr criterion. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Information.TwoRequirements +import KolmogorovMathlib.Entropy.Complexity.RandomSequences +import KolmogorovMathlib.MonotoneComplexity.LevinSchnorr.Criteria +import Mathlib.Tactic + +/-! +# Brudno bridge: `trials` and `MLRandom` against `kolmogorov-complexity-lean` + +## Engineer's Take + +There is a specific proof we were aiming to use, written in the new version of Lean, and that is why we upgraded to 4.35. It fills in a substantial gap. Maximum entropy sounds exactly like infinite randomness from the other side. + +--- + +## Formal Overview (AI-assisted) +§ I: `trials p hp` is his `Kolmogorov.bernoulliMeasure p hp`; `prefixCyl` is his `cantorCylinder`. +§ II: `MLTest μ` and his `IsMartinLofTest μ` are the same tests, for every `μ`: both bound level `m` +by `2⁻ᵐ` and list cylinders by a computable function with no access to `μ` (blind). § III: its +entropy-rate theorems (SUV Thm 148, Problems 238, 239) and Levin–Schnorr criterion (SUV Thm 94(d)). -/ + +set_option maxHeartbeats 400000 + +namespace ZeroParadox + +open MeasureTheory Filter + +/-! ## § I. The measure and the cylinders -/ + +/-- `Statement:` our trial measure is his Bernoulli measure, at every `p ≤ 1`, endpoints included. -/ +theorem trials_eq_bernoulliMeasure (p : NNReal) (hp : p ≤ 1) : + trials p hp = Kolmogorov.bernoulliMeasure p hp := by + unfold trials Kolmogorov.bernoulliMeasure + congr 1 + funext _ + refine Measure.ext_of_singleton fun b => ?_ + rw [PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton b)] + cases b + · rw [ProbabilityTheory.bernoulliMeasure_apply_of_notMem_of_mem _ (measurableSet_singleton _) + (by simp) (by simp)] + simp only [unitInterval.toNNReal, unitInterval.symm] + change ((1 - p : NNReal) : ENNReal) = _ + congr 1 + ext + simp only [NNReal.coe_sub hp, NNReal.coe_one] + rfl + · rw [ProbabilityTheory.bernoulliMeasure_apply_of_mem_of_notMem _ (measurableSet_singleton _) + (by simp) (by simp)] + rfl + +/-- `Statement:` our prefix cylinder is his `cantorCylinder`. -/ +theorem prefixCyl_eq_cantorCylinder (l : List Bool) : + prefixCyl l = _root_.cantorCylinder l := rfl + +/-! ## § II. The tests, both directions, at every measure -/ + +/-- `Statement:` our `none`-skipping union over an optional word is his `Option.elim`. -/ +private theorem iUnion_mem_option_prefixCyl (o : Option (List Bool)) : + (⋃ l ∈ o, prefixCyl l) = o.elim ∅ _root_.cantorCylinder := by + cases o with + | none => simp + | some l => ext w; simp [prefixCyl, _root_.cantorCylinder, _root_.IsCantorPrefix] + +/-- `Statement:` each of his Martin-Löf tests for `μ` is one of ours. -/ +theorem mlTest_of_isMartinLofTest {μ : Measure (ℕ → Bool)} {U : ℕ → Set (ℕ → Bool)} + (h : Kolmogorov.IsMartinLofTest μ U) : MLTest μ U := by + obtain ⟨⟨f, hf, hU⟩, hb⟩ := h + refine ⟨fun m => ?_, fun q => f q.1 q.2, hf, fun m => ?_⟩ + · rw [← Kolmogorov.dyadicValue_one_eq_inv_two_pow']; exact hb m + · rw [hU m]; simp only [iUnion_mem_option_prefixCyl] + +/-- `Statement:` each of our Martin-Löf tests for `μ` is one of his. -/ +theorem isMartinLofTest_of_mlTest {μ : Measure (ℕ → Bool)} {U : ℕ → Set (ℕ → Bool)} + (h : MLTest μ U) : Kolmogorov.IsMartinLofTest μ U := by + obtain ⟨hb, g, hg, hU⟩ := h + refine ⟨⟨fun m j => g (m, j), hg, fun m => ?_⟩, fun m => ?_⟩ + · rw [hU m]; simp only [iUnion_mem_option_prefixCyl] + · rw [Kolmogorov.dyadicValue_one_eq_inv_two_pow']; exact hb m + +/-- `Statement:` random for our tests implies random for his (uses `mlTest_of_isMartinLofTest`). -/ +theorem isMartinLofRandom_of_MLRandom {μ : Measure (ℕ → Bool)} {w : ℕ → Bool} + (h : MLRandom μ w) : Kolmogorov.IsMartinLofRandom μ w := + fun U hU => h U (mlTest_of_isMartinLofTest hU) + +/-- `Statement:` random for his tests implies random for ours (uses `isMartinLofTest_of_mlTest`). -/ +theorem MLRandom_of_isMartinLofRandom {μ : Measure (ℕ → Bool)} {w : ℕ → Bool} + (h : Kolmogorov.IsMartinLofRandom μ w) : MLRandom μ w := + fun U hU => h U (isMartinLofTest_of_mlTest hU) + +/-! ## § III. His theorems in our vocabulary + +SUV: Shen, Uspensky, Vereshchagin, *Kolmogorov Complexity and Algorithmic Randomness*, AMS 2017. +"Brudno" in the names below is this corpus's label: neither SUV pp. 229-230 nor the library uses it. -/ + +/-- `Statement:` SUV Thm 148 (p. 229), binary, a pointwise form along Martin-Löf random tapes of the +Bernoulli case of Brudno's theorem: at computable `p` with `0 < p < 1`, along every +`MLRandom (trials p hp)` tape, plain complexity per bit tends to the binary entropy in bits. -/ +theorem brudno_of_MLRandom (D : Kolmogorov.Map) (hD : Kolmogorov.isOptimalConditional D) + {p : NNReal} (hp : p ≤ 1) (hp0 : 0 < p) (hp1 : p < 1) + (hcomp : Kolmogorov.ComputableReals.IsComputableReal (p : ℝ)) + {w : ℕ → Bool} (hw : MLRandom (trials p hp) w) : + Tendsto (fun N : ℕ => ((Kolmogorov.plainK D (_root_.cantorPrefix w N)).toNat : ℝ) / N) + atTop (nhds (Kolmogorov.negMulLog2 (p : ℝ) + Kolmogorov.negMulLog2 (1 - (p : ℝ)))) := by + rw [trials_eq_bernoulliMeasure] at hw + exact Kolmogorov.tendsto_plainK_cantorPrefix_div D hD hp hp0 hp1 hcomp + (isMartinLofRandom_of_MLRandom hw) + +/-- `Statement:` SUV Problem 239 (p. 229), binary, the almost-everywhere Bernoulli case of Brudno's +theorem: at any `p ≤ 1`, the tapes +where plain complexity per bit fails to tend to the entropy are `trials p hp`-null. -/ +theorem brudno_ae_trials (D : Kolmogorov.Map) (hD : Kolmogorov.isOptimalConditional D) + {p : NNReal} (hp : p ≤ 1) : + trials p hp {w : ℕ → Bool | ¬ Tendsto + (fun N : ℕ => ((Kolmogorov.plainK D (_root_.cantorPrefix w N)).toNat : ℝ) / N) atTop + (nhds (Kolmogorov.negMulLog2 (p : ℝ) + Kolmogorov.negMulLog2 (1 - (p : ℝ))))} = 0 := by + rw [trials_eq_bernoulliMeasure] + exact Kolmogorov.measure_setOf_not_tendsto_plainK_cantorPrefix_div D hD hp + +/-- `Statement:` SUV Problem 238 (p. 229), binary, Thm 148's pointwise form for the fair coin: along every `MLRandom` fair tape, +plain complexity per bit tends to 1. -/ +theorem brudno_fair_of_MLRandom (D : Kolmogorov.Map) (hD : Kolmogorov.isOptimalConditional D) + {w : ℕ → Bool} (hw : MLRandom (trials (1 / 2) (by norm_num)) w) : + Tendsto (fun N : ℕ => ((Kolmogorov.plainK D (_root_.cantorPrefix w N)).toNat : ℝ) / N) + atTop (nhds 1) := by + rw [trials_eq_bernoulliMeasure] at hw + exact Kolmogorov.tendsto_plainK_cantorPrefix_div_uniform D hD _ + (isMartinLofRandom_of_MLRandom hw) + +/-- `Statement:` the prefix-complexity form of the Levin–Schnorr criterion (SUV Thm 94(d), p. 151; +SUV's Levin–Schnorr theorem is Thm 90, p. 146, in monotone complexity): a tape is `MLRandom` for the fair coin iff its +prefix-free complexity stays within a constant of length, `n ≤ K(w↾n) + c` for all `n`. -/ +theorem MLRandom_fair_iff_le_KPPlain {U : Kolmogorov.Map} + (hU : Kolmogorov.IsOptimalPrefixConditional U) (w : ℕ → Bool) : + MLRandom (trials (1 / 2) (by norm_num)) w ↔ + ∃ c : ℕ, ∀ n : ℕ, (n : ℕ∞) ≤ Kolmogorov.KPPlain U (_root_.cantorPrefix w n) + c := by + rw [trials_eq_bernoulliMeasure] + exact ⟨fun h => (Kolmogorov.isMartinLofRandom_uniform_iff_le_KPPlain_cantorPrefix hU w).1 + (isMartinLofRandom_of_MLRandom h), + fun h => MLRandom_of_isMartinLofRandom + ((Kolmogorov.isMartinLofRandom_uniform_iff_le_KPPlain_cantorPrefix hU w).2 h)⟩ + +section PurityCheck +#print axioms trials_eq_bernoulliMeasure +#print axioms prefixCyl_eq_cantorCylinder +#print axioms iUnion_mem_option_prefixCyl +#print axioms mlTest_of_isMartinLofTest +#print axioms isMartinLofTest_of_mlTest +#print axioms isMartinLofRandom_of_MLRandom +#print axioms MLRandom_of_isMartinLofRandom +#print axioms brudno_of_MLRandom +#print axioms brudno_ae_trials +#print axioms brudno_fair_of_MLRandom +#print axioms MLRandom_fair_iff_le_KPPlain +end PurityCheck + +end ZeroParadox diff --git a/ZeroParadox/Information/CrossingTrials.lean b/ZeroParadox/Information/CrossingTrials.lean index 664eeec5..e10eaa7b 100644 --- a/ZeroParadox/Information/CrossingTrials.lean +++ b/ZeroParadox/Information/CrossingTrials.lean @@ -2,7 +2,10 @@ import Mathlib.Probability.ProductMeasure import Mathlib.Probability.Independence.InfinitePi import Mathlib.Probability.BorelCantelli import Mathlib.Probability.ProbabilityMassFunction.Constructions +import Mathlib.Topology.MetricSpace.PiNat import Mathlib.Tactic +import ZeroParadox.Die +import ZeroParadox.Order.Snap set_option maxHeartbeats 400000 @@ -96,7 +99,7 @@ formalization of a published characterization. - § I The trial space, and that it is a probability space - § II The per-stage events: measurable, independent, marginal exactly `p` -- § III The payoff — constant positive `p` gives firing with probability one +- § III The payoff; § IV–VIII to one run and `t_snap_given`'s hypotheses; § IX topology (`.md`) -/ namespace ZeroParadox @@ -179,6 +182,594 @@ theorem crossing_almost_surely (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : trials p hp (Filter.limsup fires Filter.atTop) = 1 := measure_limsup_eq_one fires_measurable (fires_iIndepSet p hp) (trials_tsum_top p hp hp0) +/-! ## § IV. Almost surely gives some run, never every run + +§ IV–VII: prior art, open items and the two-chart reading are in +`ZeroParadox/Information/CrossingTrials.md`. -/ + +/-- **`Statement:` if `p ≤ 1` and `0 < p`, then some tape fires infinitely often.** A set of measure +one under a probability measure is nonempty (`nonempty_of_measure_ne_zero`); the antecedent is +`crossing_almost_surely`'s. The conclusion is an existential: it names no tape. -/ +theorem exists_fires_io (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + ∃ w : ℕ → Bool, w ∈ Filter.limsup fires Filter.atTop := + nonempty_of_measure_ne_zero (by rw [crossing_almost_surely p hp hp0]; exact one_ne_zero) + +-- Statement: CONTROL: not every tape fires even once; the all-`false` tape never fires. +example : ¬ ∀ w : ℕ → Bool, ∃ n, w ∈ fires n := fun h => by + obtain ⟨n, hn⟩ := h (fun _ => false) + simp [fires] at hn + +/-! ## § V. Zero blocks -/ + +/-- **`Statement:` the tapes that do not fire at any stage in `[N, N + n)`.** -/ +def zeroBlock (N n : ℕ) : Set (ℕ → Bool) := {w | ∀ k ∈ Finset.Ico N (N + n), w k = false} + +/-- **`Statement:` a zero block is the cylinder over the finite window `[N, N + n)`.** -/ +theorem zeroBlock_eq_pi (N n : ℕ) : + zeroBlock N n = (↑(Finset.Ico N (N + n)) : Set ℕ).pi (fun _ => ({false} : Set Bool)) := by + ext w; simp [zeroBlock] + +/-- **`Statement:` if `p ≤ 1`, a zero block of length `n` has measure `(1 - p) ^ n`.** -/ +theorem trials_zeroBlock (p : NNReal) (hp : p ≤ 1) (N n : ℕ) : + trials p hp (zeroBlock N n) = ((1 - p : NNReal) : ENNReal) ^ n := by + rw [zeroBlock_eq_pi, trials, Measure.infinitePi_pi _ (fun i _ => measurableSet_singleton false)] + simp [PMF.bernoulli] + +/-- **`Statement:` if `0 < p`, some `K > 0` has `(1 - p) ^ K ≤ 1/2`.** Existential: `K` is not +computed from `p` here. -/ +theorem exists_halving_block (p : NNReal) (hp0 : 0 < p) : + ∃ K : ℕ, 0 < K ∧ ((1 - p : NNReal) : ENNReal) ^ K ≤ 2⁻¹ := by + have hlt : ((1 - p : NNReal) : ENNReal) < 1 := by + have : (1 - p : NNReal) < 1 := tsub_lt_self one_pos hp0 + exact_mod_cast this + have ht := ENNReal.tendsto_pow_atTop_nhds_zero_of_lt_one hlt + have hev := (ht.eventually (gt_mem_nhds (show (0 : ENNReal) < 2⁻¹ by simp))).and + (eventually_gt_atTop 0) + obtain ⟨K, hK, hK0⟩ := hev.exists + exact ⟨K, hK0, hK.le⟩ + +/-- **`Statement:` if `(1 - p) ^ K ≤ 1/2`, the zero block of length `K * m` has measure at most +`2⁻ᵐ`.** -/ +theorem trials_zeroBlock_le (p : NNReal) (hp : p ≤ 1) {K : ℕ} + (hK : ((1 - p : NNReal) : ENNReal) ^ K ≤ 2⁻¹) (N m : ℕ) : + trials p hp (zeroBlock N (K * m)) ≤ 2⁻¹ ^ m := by + rw [trials_zeroBlock, pow_mul] + exact pow_le_pow_left₀ zero_le hK m + +/-- **`Statement:` the tapes that fire at no stage from `N` on.** `silentFrom 0` never fires. -/ +def silentFrom (N : ℕ) : Set (ℕ → Bool) := {w | ∀ k, N ≤ k → w k = false} + +/-- **`Statement:` if `0 < K`, `silentFrom N` is the intersection over `m` of the zero blocks of +length `K * m` from `N`.** -/ +theorem silentFrom_eq_iInter (N : ℕ) {K : ℕ} (hK : 0 < K) : + silentFrom N = ⋂ m, zeroBlock N (K * m) := by + ext w + simp only [silentFrom, zeroBlock, Set.mem_setOf_eq, Set.mem_iInter, Finset.mem_Ico] + constructor + · intro h m k hk; exact h k hk.1 + · intro h k hk + exact h (k + 1) k ⟨hk, by nlinarith⟩ + +/-- **`Statement:` a tape fails to fire infinitely often iff it is silent from some `N`; both +directions.** -/ +theorem not_mem_limsup_fires_iff (w : ℕ → Bool) : + w ∉ Filter.limsup fires Filter.atTop ↔ ∃ N, w ∈ silentFrom N := by + rw [mem_limsup_iff_frequently_mem, Filter.not_frequently, Filter.eventually_atTop] + simp [fires, silentFrom] + +/-! ## § VI. Typicality as an explicit hypothesis -/ + +/-- **`Statement:` `U` is a zero-block test for `μ`: level `m` has `μ`-measure at most `2⁻ᵐ`, and +level `m` is the zero block `zeroBlock (w m).1 (w m).2` for a primitive recursive `w`.** -/ +def ZeroBlockTest (μ : Measure (ℕ → Bool)) (U : ℕ → Set (ℕ → Bool)) : Prop := + (∀ m, μ (U m) ≤ 2⁻¹ ^ m) ∧ + ∃ w : ℕ → ℕ × ℕ, Primrec w ∧ ∀ m, U m = zeroBlock (w m).1 (w m).2 + +/-- **`Statement:` `w` lies outside `⋂ m, U m` for every `U` in the class `𝒯`.** A predicate on a +tape, used only as a hypothesis. -/ +def AvoidsTests (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (w : ℕ → Bool) : Prop := + ∀ U, 𝒯 U → w ∉ ⋂ m, U m + +/-- **`Statement:` if `p ≤ 1` and `0 < p`, then for every `N` some zero-block test for +`trials p hp` has intersection `silentFrom N`.** -/ +theorem zeroBlockTest_silentFrom (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (N : ℕ) : + ∃ U, ZeroBlockTest (trials p hp) U ∧ ⋂ m, U m = silentFrom N := by + obtain ⟨K, hK0, hK⟩ := exists_halving_block p hp0 + refine ⟨fun m => zeroBlock N (K * m), ⟨fun m => trials_zeroBlock_le p hp hK N m, + fun m => (N, K * m), ?_, fun m => rfl⟩, (silentFrom_eq_iInter N hK0).symm⟩ + exact Primrec.pair (Primrec.const N) (Primrec.nat_mul.comp (Primrec.const K) Primrec.id) + +/-- **`Statement:` if `p ≤ 1`, `0 < p`, the class `𝒯` contains every zero-block test for +`trials p hp`, and `w` avoids `𝒯`, then `w` fires infinitely often.** One way: the squares tape +below fires infinitely often, and at every `0 < p ≤ 1` is caught by a zero-block test +(`squaresTape_not_avoids`). `Reading:` `htyp` is the typicality commitment written as a hypothesis +on one tape. -/ +theorem fires_io_of_avoids (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) + (w : ℕ → Bool) (htyp : AvoidsTests 𝒯 w) : + w ∈ Filter.limsup fires Filter.atTop := by + by_contra h + obtain ⟨N, hN⟩ := (not_mem_limsup_fires_iff w).1 h + obtain ⟨U, hU, hUeq⟩ := zeroBlockTest_silentFrom p hp hp0 N + exact htyp U (h𝒯 U hU) (hUeq ▸ hN) + +/-- **`Statement:` the tape that is `true` exactly at the perfect squares.** -/ +def squaresTape (k : ℕ) : Bool := decide (Nat.sqrt k * Nat.sqrt k = k) + +/-- **`Statement:` if `p ≤ 1`, `0 < p`, and the class `𝒯` contains every zero-block test for +`trials p hp`, then the squares tape does not avoid `𝒯`.** Level `m` is the first `K * m` +non-squares after `(K * m)²`, with `K` from `exists_halving_block`; `p = 1` is included. -/ +theorem squaresTape_not_avoids (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) : + ¬ AvoidsTests 𝒯 squaresTape := by + obtain ⟨K, -, hK⟩ := exists_halving_block p hp0 + intro h + refine h (fun m => zeroBlock (K * m * (K * m) + 1) (K * m)) + (h𝒯 _ ⟨fun m => trials_zeroBlock_le p hp hK _ m, fun m => (K * m * (K * m) + 1, K * m), ?_, + fun m => rfl⟩) ?_ + · have hKm : Primrec (fun m : ℕ => K * m) := Primrec.nat_mul.comp (Primrec.const K) Primrec.id + exact Primrec.pair (Primrec.succ.comp (Primrec.nat_mul.comp hKm hKm)) hKm + · simp only [Set.mem_iInter, zeroBlock, Set.mem_setOf_eq, Finset.mem_Ico] + intro m k hk + have hs : Nat.sqrt k = K * m := by + obtain ⟨j, rfl⟩ : ∃ j, k = K * m * (K * m) + j := ⟨k - K * m * (K * m), by omega⟩ + exact Nat.sqrt_add_eq (K * m) (by omega) + simp only [squaresTape, hs, decide_eq_false_iff_not] + omega + +/-- **`Statement:` the tapes that fire at every stage in `[0, n)`.** -/ +def oneBlock (n : ℕ) : Set (ℕ → Bool) := {w | ∀ k ∈ Finset.range n, w k = true} + +/-- **`Statement:` if `p ≤ 1`, a one block of length `n` has measure `p ^ n`.** -/ +theorem trials_oneBlock (p : NNReal) (hp : p ≤ 1) (n : ℕ) : + trials p hp (oneBlock n) = (p : ENNReal) ^ n := by + have : oneBlock n = (↑(Finset.range n) : Set ℕ).pi (fun _ => ({true} : Set Bool)) := by + ext w; simp [oneBlock] + rw [this, trials, Measure.infinitePi_pi _ (fun i _ => measurableSet_singleton true)] + simp [PMF.bernoulli] + +-- Statement: CONTROL, the converse of `fires_io_of_avoids` fails inside the zero-block class: at +-- `p = 1/2` the squares tape fires infinitely often and lies in a zero-block test's intersection +-- (level `m` the first `m` non-squares after `m * m`; every `0 < p ≤ 1`: `squaresTape_not_avoids`). +example : squaresTape ∈ Filter.limsup fires Filter.atTop ∧ + ¬ AvoidsTests (ZeroBlockTest (trials (1/2) (by norm_num))) squaresTape := by + have half : (1 - (1/2 : NNReal) : NNReal) = 2⁻¹ := by + rw [one_div]; exact tsub_eq_of_eq_add (by rw [← two_mul, mul_inv_cancel₀ two_ne_zero]) + refine ⟨?_, fun h => ?_⟩ + · rw [mem_limsup_iff_frequently_mem, Filter.frequently_atTop] + intro a + exact ⟨a * a, Nat.le_mul_self a, by simp [fires, squaresTape]⟩ + · refine h (fun m => zeroBlock (m * m + 1) m) + ⟨fun m => ?_, fun m => (m * m + 1, m), ?_, fun m => rfl⟩ ?_ + · have := trials_zeroBlock_le (1/2) (by norm_num) (K := 1) (by rw [half]; simp) (m * m + 1) m + simpa using this + · exact Primrec.pair (Primrec.succ.comp (Primrec.nat_mul.comp Primrec.id Primrec.id)) Primrec.id + · simp only [Set.mem_iInter, zeroBlock, Set.mem_setOf_eq, Finset.mem_Ico] + intro m k hk + have hs : Nat.sqrt k = m := by + obtain ⟨j, rfl⟩ : ∃ j, k = m * m + j := ⟨k - m * m, by omega⟩ + exact Nat.sqrt_add_eq m (by omega) + simp only [squaresTape, hs, decide_eq_false_iff_not] + omega + +-- Statement: CONTROL, firing infinitely often is not typicality against a class holding one-block +-- tests: the all-`true` tape fires infinitely often and lies in every one block, whose measures at +-- `p = 1/2` are at most `2⁻ᵐ`. +example : (fun _ => true : ℕ → Bool) ∈ Filter.limsup fires Filter.atTop ∧ + (fun _ => true : ℕ → Bool) ∈ ⋂ m, oneBlock m ∧ + ∀ m, trials (1/2) (by norm_num) (oneBlock m) ≤ 2⁻¹ ^ m := by + refine ⟨?_, ?_, fun m => ?_⟩ + · rw [mem_limsup_iff_frequently_mem]; exact Filter.Frequently.of_forall (fun n => rfl) + · simp [oneBlock] + · rw [trials_oneBlock]; simp + +-- Statement: the zero-block hypothesis is weak: for every `p ≤ 1` the all-`true` tape, a constant +-- tape, avoids the class of zero-block tests for `trials p hp` (level 1 of a test has measure at +-- most `1/2`, so its window has positive length, and the all-`true` tape lies in no zero block over a +-- window of positive length). +-- Reading (cited, not claimed): so meeting this hypothesis does not give Kurtz randomness at +-- `p = 1/2`: the all-`true` tape is computable, and no computable sequence is Kurtz random for the +-- fair coin (Freer, `algorithmic-randomness`, `ComputableCantorPoint.not_isKurtzRandom`). Reading +-- it as "not Martin-Löf random" needs `p < 1`, since the cited result (Reimann and Slaman, Thm 4.4) +-- concerns non-atoms. Both sources: `ZeroParadox/Information/CrossingTrials.md`. +example (p : NNReal) (hp : p ≤ 1) : + AvoidsTests (ZeroBlockTest (trials p hp)) (fun _ => true) := by + rintro U ⟨hμ, f, -, hf⟩ hmem + have h1 := hμ 1 + rw [hf 1] at h1 + have hm : (fun _ => true : ℕ → Bool) ∈ zeroBlock (f 1).1 (f 1).2 := by + rw [← hf 1]; exact Set.mem_iInter.1 hmem 1 + rcases Nat.eq_zero_or_pos (f 1).2 with h0 | hpos + · have : zeroBlock (f 1).1 (f 1).2 = Set.univ := by + ext w; simp [zeroBlock, h0] + rw [this, measure_univ] at h1 + norm_num at h1 + · have := hm (f 1).1 (by simp [Finset.mem_Ico]; omega) + simp at this + +/-! ## § VII. The slot machine as a die motion -/ + +/-- **`Statement:` the motion on `Bool` with UP the identity and OVER: every point steps to itself, +and `false` steps to `true`.** `Reading:` `false` is not yet crossed, `true` crossed. -/ +def slotMotion : Motion Bool := + Motion.ofTotal id (fun _ => rfl) (fun a b => a = b ∨ (a = false ∧ b = true)) + +/-- **`Statement:` the stage-`n` state driven by `w`: `true` iff `w` fires below stage `n`.** -/ +def slotRun (w : ℕ → Bool) (n : ℕ) : Bool := decide (∃ k < n, w k = true) + +/-- **`Statement:` for every tape `w`, `slotRun w` is a run of `slotMotion`.** -/ +theorem slotRun_isRun (w : ℕ → Bool) : slotMotion.IsRun (slotRun w) := by + intro n + show slotRun w n = slotRun w (n + 1) ∨ (slotRun w n = false ∧ slotRun w (n + 1) = true) + by_cases h : ∃ k < n, w k = true + · left + have h' : ∃ k < n + 1, w k = true := let ⟨k, hk, e⟩ := h; ⟨k, by omega, e⟩ + simp only [slotRun, h, h', decide_true] + · by_cases hn : w n = true + · right + have h' : ∃ k < n + 1, w k = true := ⟨n, by omega, hn⟩ + simp only [slotRun, h, h', decide_true, decide_false, and_self] + · left + have h' : ¬ ∃ k < n + 1, w k = true := by + rintro ⟨k, hk, e⟩ + rcases Nat.lt_succ_iff_lt_or_eq.1 hk with hk | rfl + · exact h ⟨k, hk, e⟩ + · exact hn e + simp only [slotRun, h, h'] + +/-- **`Statement:` in `slotMotion`, `false` steps elsewhere (`LeavesAt`) and steps to itself.** +`Reading:` the possibility of crossing, with no measure and no tape. -/ +theorem slotMotion_leavesAt_false : slotMotion.LeavesAt false ∧ slotMotion.step false false := + ⟨⟨true, Or.inr ⟨rfl, rfl⟩, by decide⟩, Or.inl rfl⟩ + +/-- **`Statement:` in `slotMotion`, `true` steps to itself and to nothing else (`SelfOnlyAt`).** -/ +theorem slotMotion_selfOnlyAt_true : slotMotion.SelfOnlyAt true := + ⟨Or.inl rfl, fun _ h => h.elim Eq.symm (fun h => absurd h.1 (by decide))⟩ + +/-- **`Statement:` `slotRun w` starts at `false`, and reaches `true` iff `w` fires at some stage; +both directions.** -/ +theorem slotRun_crosses_iff (w : ℕ → Bool) : + slotRun w 0 = false ∧ ((∃ n, slotRun w n = true) ↔ ∃ k, w k = true) := by + refine ⟨by simp [slotRun], ⟨fun ⟨n, hn⟩ => ?_, fun ⟨k, e⟩ => ⟨k + 1, ?_⟩⟩⟩ + · simp only [slotRun, decide_eq_true_eq] at hn + obtain ⟨k, -, e⟩ := hn; exact ⟨k, e⟩ + · simp only [slotRun, decide_eq_true_eq]; exact ⟨k, by omega, e⟩ + +/-- **`Statement:` if `p ≤ 1`, `0 < p`, `𝒯` contains every zero-block test for `trials p hp`, `w` +avoids `𝒯`, and `φ` is a one-to-one lax map from `slotMotion` to `N`, then `φ ∘ slotRun w` is a +run of `N` that reaches a state other than its start.** One way: the `example` after it gives the +departure for any tape that fires once (the run half needs no hypothesis on the tape). Without +`htyp` the all-`false` tape's run never leaves `false`. -/ +theorem slotRun_image_departs_of_avoids {β : Type*} {N : Motion β} + (φ : Motion.LaxHom slotMotion N) (hi : Function.Injective φ.toFun) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) + (w : ℕ → Bool) (htyp : AvoidsTests 𝒯 w) : + N.IsRun (φ.toFun ∘ slotRun w) ∧ ∃ n, (φ.toFun ∘ slotRun w) n ≠ (φ.toFun ∘ slotRun w) 0 := by + refine ⟨fun n => φ.map_step (slotRun_isRun w n), ?_⟩ + have h := fires_io_of_avoids p hp hp0 𝒯 h𝒯 w htyp + rw [mem_limsup_iff_frequently_mem] at h + obtain ⟨k, -, hk⟩ := h.forall_exists_of_atTop 0 + obtain ⟨n, hn⟩ := (slotRun_crosses_iff w).2.2 ⟨k, hk⟩ + exact ⟨n, fun e => by + have := hi e; rw [hn, (slotRun_crosses_iff w).1] at this; cases this⟩ + +-- Statement: if `φ` is a one-to-one lax map and `w` fires at some stage, the image run leaves its +-- start, with no measure and no typicality hypothesis. +example {β : Type*} {N : Motion β} (φ : Motion.LaxHom slotMotion N) + (hi : Function.Injective φ.toFun) (w : ℕ → Bool) (hw : ∃ k, w k = true) : + ∃ n, (φ.toFun ∘ slotRun w) n ≠ (φ.toFun ∘ slotRun w) 0 := by + obtain ⟨n, hn⟩ := (slotRun_crosses_iff w).2.2 hw + exact ⟨n, fun e => by have := hi e; rw [hn, (slotRun_crosses_iff w).1] at this; cases this⟩ + +-- Statement: CONTROL, the converse of `slotRun_image_departs_of_avoids` fails: for every one-to-one +-- lax map `φ`, every `0 < p ≤ 1` and every class `𝒯` holding the zero-block tests for +-- `trials p hp`, the squares tape's image run leaves its start, yet the squares tape does not avoid +-- `𝒯` (`squaresTape_not_avoids`). +example {β : Type*} {N : Motion β} (φ : Motion.LaxHom slotMotion N) + (hi : Function.Injective φ.toFun) (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) : + (∃ n, (φ.toFun ∘ slotRun squaresTape) n ≠ (φ.toFun ∘ slotRun squaresTape) 0) ∧ + ¬ AvoidsTests 𝒯 squaresTape := by + refine ⟨?_, squaresTape_not_avoids p hp hp0 𝒯 h𝒯⟩ + obtain ⟨n, hn⟩ := (slotRun_crosses_iff squaresTape).2.2 ⟨0, by simp [squaresTape]⟩ + exact ⟨n, fun e => by + have := hi e; rw [hn, (slotRun_crosses_iff squaresTape).1] at this; cases this⟩ + +-- Statement: CONTROL: without the typicality hypothesis, the all-`false` tape drives a run that +-- stays at `false` at every stage. +example : ∀ n, slotRun (fun _ => false) n = false := fun n => by simp [slotRun] + +/-! ## § VIII. Fired at least once gives `t_snap_given`'s hypotheses + +Direction: a tape that has fired at least once gives a state sequence meeting `t_snap_given`'s +`hcc1` and `hocc`; the cover `hcov` of `t_snap_given_cover` is not supplied. "Fired at least once" +holds on a set of `trials p hp` measure one when `0 < p ≤ 1` (`trials_fires_once`) and for every +tape meeting § VI's hypotheses (`t_snap_of_avoids`); neither statement names a tape. -/ + +/-- **`Statement:` `slotRun w` with the stages before the first firing dropped.** `Nat.find hw` is +the least `k` with `w k = true`, a first hitting time (Mathlib: `MeasureTheory.hittingAfter`). -/ +def firedRun (w : ℕ → Bool) (hw : ∃ k, w k = true) (n : ℕ) : Bool := + slotRun w (Nat.find hw + n) + +-- Statement: if `w` fires at some stage, `Nat.find hw` is Mathlib's `hittingAfter` of the coordinate +-- process at `{true}` from time 0. +example (w : ℕ → Bool) (hw : ∃ k, w k = true) : + MeasureTheory.hittingAfter (fun (j : ℕ) (x : ℕ → Bool) => x j) {true} 0 w = + (Nat.find hw : WithTop ℕ) := by + rw [MeasureTheory.hittingAfter_def] + have : ∃ j, 0 ≤ j ∧ w j ∈ ({true} : Set Bool) := by + obtain ⟨k, hk⟩ := hw; exact ⟨k, Nat.zero_le _, hk⟩ + simp only [this, if_true] + congr 1 + apply le_antisymm + · exact Nat.sInf_le ⟨Nat.zero_le _, Nat.find_spec hw⟩ + · apply le_csInf + · obtain ⟨k, hk⟩ := hw; exact ⟨k, Nat.zero_le _, hk⟩ + · rintro b ⟨-, hb⟩; exact Nat.find_min' hw hb + +/-- **`Statement:` if `w` fires at some stage, `firedRun w hw` is `false` at stage 0 and `true` at +every later stage.** -/ +theorem firedRun_spec (w : ℕ → Bool) (hw : ∃ k, w k = true) : + firedRun w hw 0 = false ∧ ∀ n, firedRun w hw (n + 1) = true := by + refine ⟨?_, fun n => ?_⟩ + · simp only [firedRun, slotRun, Nat.add_zero, decide_eq_false_iff_not] + rintro ⟨k, hk, e⟩ + exact Nat.find_min hw hk e + · simp only [firedRun, slotRun, decide_eq_true_eq] + exact ⟨Nat.find hw, by omega, Nat.find_spec hw⟩ + +/-- **`Statement:` if `w` fires at some stage, `firedRun w hw` is a run of `slotMotion`.** A shift of +the run `slotRun w` (`slotRun_isRun`). -/ +theorem firedRun_isRun (w : ℕ → Bool) (hw : ∃ k, w k = true) : + slotMotion.IsRun (firedRun w hw) := fun n => + slotRun_isRun w (Nat.find hw + n) + +/-- **`Statement:` if `φ : Bool → L` sends `false` to ⊥ of `L` and `true` to a point other than ⊥ of +`L`, and the tape `w` fires at some stage (`hw`), then `S := φ ∘ firedRun w hw` has `S 0 = ⊥` (CC-1, +`t_snap_given`'s `hcc1`), `S 1 ≠ S 0` (`t_snap_given`'s `hocc`), is a state sequence (ZP-A's D3), and +carries `t_snap_given`'s triple.** One way: having fired at least once gives the hypotheses; the +converse is not claimed. Every firing tape gives the same `firedRun w hw`, `false` at stage 0 and `true` after +(`firedRun_spec`): the tape contributes one bit, that it fired. `S` steps once, at index 1, and +stays, so it is not an `IsStrictStateSequence` (the last `example` of the file). Without `hw` the +all-`false` tape's run `φ ∘ slotRun` stays at ⊥ of `L` at every stage (the first `example` below). +`Reading:` `hw` is the occurrence commitment in its slot chart, written as one hypothesis on the +realized tape; it is a hypothesis here, never a field of a structure. -/ +theorem t_snap_of_fires_once {L : Type*} [ZPSemilattice L] (φ : Bool → L) + (hφ0 : φ false = ZPSemilattice.bot) (hφ1 : φ true ≠ ZPSemilattice.bot) + (w : ℕ → Bool) (hw : ∃ k, w k = true) : + let S := φ ∘ firedRun w hw + S 0 = ZPSemilattice.bot ∧ S 1 ≠ S 0 ∧ ZPSemilattice.IsStateSequence S ∧ + (S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ ZPSemilattice.join (S 0) (S 1) = S 1) := by + intro S + obtain ⟨h0, hs⟩ := firedRun_spec w hw + have hS0 : S 0 = ZPSemilattice.bot := by simp [S, h0, hφ0] + have hS1 : S 1 ≠ S 0 := by + simp only [S, Function.comp, hs 0, h0, hφ0]; exact hφ1 + refine ⟨hS0, hS1, ⟨fun _ => φ true, fun n => ?_⟩, t_snap_given S hS0 hS1⟩ + cases n with + | zero => simp only [S, Function.comp, hs 0, h0, hφ0]; exact (ZPSemilattice.bot_join _).symm + | succ n => simp only [S, Function.comp, hs]; exact (ZPSemilattice.join_idem _).symm + +/-- **`Statement:` if `p ≤ 1` and `0 < p`, the tapes that fire at some stage have `trials p hp` +measure one.** They contain the tapes that fire infinitely often, a set of measure one +(`crossing_almost_surely`). The conclusion is about a set of tapes and names no tape. -/ +theorem trials_fires_once (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + trials p hp {w | ∃ k, w k = true} = 1 := by + refine le_antisymm prob_le_one ?_ + rw [← crossing_almost_surely p hp hp0] + refine measure_mono fun w hw => ?_ + rw [mem_limsup_iff_frequently_mem] at hw + obtain ⟨k, -, hk⟩ := hw.forall_exists_of_atTop 0 + exact ⟨k, hk⟩ + +/-- **`Statement:` if `p ≤ 1`, `0 < p`, `𝒯` contains every zero-block test for `trials p hp`, `w` +avoids `𝒯`, and `φ` is as in `t_snap_of_fires_once`, then `w` fires at some stage and +`t_snap_of_fires_once`'s conclusion holds for it.** From `fires_io_of_avoids`. One way: the squares +tape fires at stage 0 and does not avoid `𝒯` (the fourth CONTROL `example` below), so § VI's +hypotheses are sufficient for `hw`, not necessary. `Reading:` `htyp`, like `hw`, is a hypothesis on +one tape. -/ +theorem t_snap_of_avoids {L : Type*} [ZPSemilattice L] (φ : Bool → L) + (hφ0 : φ false = ZPSemilattice.bot) (hφ1 : φ true ≠ ZPSemilattice.bot) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) + (w : ℕ → Bool) (htyp : AvoidsTests 𝒯 w) : + ∃ hw : ∃ k, w k = true, + let S := φ ∘ firedRun w hw + S 0 = ZPSemilattice.bot ∧ S 1 ≠ S 0 ∧ ZPSemilattice.IsStateSequence S ∧ + (S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ ZPSemilattice.join (S 0) (S 1) = S 1) := by + have h := fires_io_of_avoids p hp hp0 𝒯 h𝒯 w htyp + rw [mem_limsup_iff_frequently_mem] at h + obtain ⟨k, -, hk⟩ := h.forall_exists_of_atTop 0 + exact ⟨⟨k, hk⟩, t_snap_of_fires_once φ hφ0 hφ1 w ⟨k, hk⟩⟩ + +-- Statement: CONTROL, the tape-driven run needs `hw`: the all-`false` tape fires at no stage, and for any `φ` +-- with `φ false = ⊥` the sequence `φ ∘ slotRun` it drives starts at ⊥ of `L` and never steps. +example {L : Type*} [ZPSemilattice L] (φ : Bool → L) (hφ0 : φ false = ZPSemilattice.bot) : + (¬ ∃ k, (fun _ => false : ℕ → Bool) k = true) ∧ + (φ ∘ slotRun (fun _ => false)) 0 = ZPSemilattice.bot ∧ + ∀ n, (φ ∘ slotRun (fun _ => false)) n = (φ ∘ slotRun (fun _ => false)) 0 := + ⟨fun ⟨_, h⟩ => Bool.false_ne_true h, by simp [slotRun, hφ0], fun n => by simp [slotRun]⟩ + +-- Statement: CONTROL, the shift is needed for `hocc` at index 1: the tape firing only at stage 1 +-- drives `φ ∘ slotRun` with `S 1 = S 0`. +example {L : Type*} [ZPSemilattice L] (φ : Bool → L) : + (φ ∘ slotRun (fun k => decide (k = 1))) 1 = (φ ∘ slotRun (fun k => decide (k = 1))) 0 := by + simp [slotRun] + +-- Statement: CONTROL, `Unit`: it carries a `ZPSemilattice` (as `trivialZPSemilattice`, +-- `ZeroParadox/Valuation/Scale.lean`), and under any such instance no `φ : Bool → Unit` has +-- `φ true ≠ ⊥`, so `hφ1` has no member. +example : Nonempty (ZPSemilattice Unit) := + ⟨⟨fun _ _ => (), (), fun _ _ _ => rfl, fun _ _ => rfl, fun _ => rfl, fun _ => rfl⟩⟩ +example [ZPSemilattice Unit] (φ : Bool → Unit) : ¬ φ true ≠ ZPSemilattice.bot := fun h => h rfl + +-- Statement: CONTROL, fired at least once does not imply typical: for every `0 < p ≤ 1` and every +-- class `𝒯` holding the zero-block tests for `trials p hp`, the squares tape fires at stage 0 and +-- does not avoid `𝒯`. +example (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) + (𝒯 : (ℕ → Set (ℕ → Bool)) → Prop) (h𝒯 : ∀ U, ZeroBlockTest (trials p hp) U → 𝒯 U) : + (∃ k, squaresTape k = true) ∧ ¬ AvoidsTests 𝒯 squaresTape := + ⟨⟨0, by simp [squaresTape]⟩, squaresTape_not_avoids p hp hp0 𝒯 h𝒯⟩ + +-- Statement: CONTROL, measure one is not every tape: if `0 < p ≤ 1`, the set of tapes that fired at +-- least once has measure one and the all-`false` tape is not in it. +example (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + trials p hp {w | ∃ k, w k = true} = 1 ∧ ¬ ∀ w : ℕ → Bool, ∃ k, w k = true := + ⟨trials_fires_once p hp hp0, fun h => by obtain ⟨k, hk⟩ := h (fun _ => false); simp at hk⟩ + +-- Statement: occurrence once: under `t_snap_of_fires_once`'s hypotheses, `S := φ ∘ firedRun w hw` +-- has `S 2 = S 1`, so `S` is not an `IsStrictStateSequence` (ZP-A's proper ascent at every step). +example {L : Type*} [ZPSemilattice L] (φ : Bool → L) (w : ℕ → Bool) (hw : ∃ k, w k = true) : + ¬ ZPSemilattice.IsStrictStateSequence (φ ∘ firedRun w hw) := fun h => by + have a : firedRun w hw 1 = true := (firedRun_spec w hw).2 0 + have b : firedRun w hw 2 = true := (firedRun_spec w hw).2 1 + exact h.2 1 (show φ (firedRun w hw 1) = φ (firedRun w hw 2) by rw [a, b]) + +/-! ## § IX. Fired at least once is open, and no continuous test decides it + +Topology: the product (Cantor) topology on `ℕ → Bool`, with `Bool` discrete. Direction: a test +`f : (ℕ → Bool) → Bool` is continuous iff one prefix length `N` fixes its value on every tape +(both directions below); "fired at least once" is open and not closed, and no continuous test +decides it. That computable implies continuous is cited, not proved here: Weihrauch, *Computable +Analysis* (Springer 2000), Thm 2.2.3, p. 30. Mathlib's `Computable` takes `Primcodable` types, and +`ℕ → Bool` carries none (the first `example` below). Prior art, the search and the footprints: +`ZeroParadox/Information/CrossingTrials.md`. -/ + +-- Statement: `ℕ → Bool` has no `Primcodable` instance (diagonal argument), so Mathlib's `Computable` +-- does not apply to tests on tapes. +example : IsEmpty (Primcodable (ℕ → Bool)) := + ⟨fun h => by + haveI := h.toEncodable + obtain ⟨f, hf⟩ := exists_surjective_nat (ℕ → Bool) + obtain ⟨m, hm⟩ := hf fun n => !(f n n) + have := congrFun hm m + cases h' : f m m <;> simp [h'] at this⟩ + +/-- **`Statement:` if `f : (ℕ → Bool) → Bool` is continuous, one `N` has: tapes agreeing below `N` +get the same value.** By compactness of `ℕ → Bool`; the Baire-space `example` below shows +continuity alone does not give the uniform `N`. -/ +theorem prefixDetermined_of_continuous (f : (ℕ → Bool) → Bool) (hf : Continuous f) : + ∃ N, ∀ w w' : ℕ → Bool, (∀ i < N, w i = w' i) → f w = f w' := by + have hn : ∀ w : ℕ → Bool, ∃ n, PiNat.cylinder w n ⊆ f ⁻¹' {f w} := by + intro w + obtain ⟨_, ⟨x, n, rfl⟩, hw, hsub⟩ := + (PiNat.isTopologicalBasis_cylinders (fun _ : ℕ => Bool)).exists_subset_of_mem_open + (show w ∈ f ⁻¹' {f w} from rfl) ((isOpen_discrete _).preimage hf) + exact ⟨n, (PiNat.mem_cylinder_iff_eq.1 hw) ▸ hsub⟩ + choose n hn using hn + obtain ⟨t, -, ht⟩ := isCompact_univ.elim_nhds_subcover (fun w => PiNat.cylinder w (n w)) + (fun w _ => (PiNat.isOpen_cylinder (fun _ : ℕ => Bool) w (n w)).mem_nhds + (PiNat.self_mem_cylinder _ _)) + refine ⟨t.sup n, fun w w' hww' => ?_⟩ + obtain ⟨x, hx, hwx⟩ := Set.mem_iUnion₂.1 (ht (Set.mem_univ w)) + have hle : n x ≤ t.sup n := Finset.le_sup hx + have hw'x : w' ∈ PiNat.cylinder x (n x) := fun i hi => + (hww' i (hi.trans_le hle)).symm.trans (hwx i hi) + have e1 : f w = f x := hn x hwx + have e2 : f w' = f x := hn x hw'x + rw [e1, e2] + +/-- **`Statement:` the converse: if one `N` fixes `f`'s value on tapes agreeing below `N`, `f` is +continuous.** -/ +theorem continuous_of_prefixDetermined (f : (ℕ → Bool) → Bool) + (h : ∃ N, ∀ w w' : ℕ → Bool, (∀ i < N, w i = w' i) → f w = f w') : Continuous f := by + obtain ⟨N, hN⟩ := h + let ext : (Fin N → Bool) → ℕ → Bool := fun v i => if hi : i < N then v ⟨i, hi⟩ else false + let r : (ℕ → Bool) → Fin N → Bool := fun w i => w i + have hr : Continuous r := continuous_pi fun i => continuous_apply _ + have hf : f = (f ∘ ext) ∘ r := by + funext w + exact hN w _ (fun i hi => by simp [ext, r, hi]) + rw [hf] + exact continuous_of_discreteTopology.comp hr + +/-- **`Statement:` the tapes that fired at least once form an open set.** The set is +`trials_fires_once`'s; it is not closed (the never-fired CONTROL `example`). -/ +theorem isOpen_fires_once : IsOpen {w : ℕ → Bool | ∃ k, w k = true} := by + have : {w : ℕ → Bool | ∃ k, w k = true} = ⋃ k, (fun w : ℕ → Bool => w k) ⁻¹' {true} := by + ext w; simp + rw [this] + exact isOpen_iUnion fun k => (isOpen_discrete _).preimage (continuous_apply k) + +/-- **`Statement:` if `f w = true ↔ ∃ k, w k = true` for every tape `w`, then `f` is not continuous +at ⊥ of `ℕ → Bool` (pointwise order), the all-`false` tape.** Every prefix of ⊥ is also a prefix of +a tape that fires one stage later. -/ +theorem not_continuousAt_bot_of_decides_fires_once (f : (ℕ → Bool) → Bool) + (hf : ∀ w, f w = true ↔ ∃ k, w k = true) : ¬ ContinuousAt f ⊥ := by + intro hc + have hbot : f ⊥ = false := by + cases h : f ⊥ + · rfl + · obtain ⟨k, hk⟩ := (hf _).1 h; cases hk + have hmem : f ⁻¹' {f ⊥} ∈ nhds (⊥ : ℕ → Bool) := hc ((isOpen_discrete _).mem_nhds rfl) + obtain ⟨_, ⟨x, n, rfl⟩, hb, hsub⟩ := + (PiNat.isTopologicalBasis_cylinders (fun _ : ℕ => Bool)).mem_nhds_iff.1 hmem + have hw : (fun k => decide (k = n)) ∈ PiNat.cylinder x n := by + rw [← PiNat.mem_cylinder_iff_eq.1 hb] + intro i hi; simp [Nat.ne_of_lt hi] + have h1 : f (fun k => decide (k = n)) = f ⊥ := hsub hw + rw [hbot] at h1 + have h2 : f (fun k => decide (k = n)) = true := (hf _).2 ⟨n, by simp⟩ + rw [h1] at h2; cases h2 + +/-- **`Statement:` no continuous `f : (ℕ → Bool) → Bool` has `f w = true ↔ ∃ k, w k = true` for +every tape `w`.** `Reading:` `hw` in `t_snap_of_fires_once` is one tape's instance of the +predicate decided here by no continuous test (`CrossingTrials.md` § IX). -/ +theorem no_continuous_test_fires_once : + ¬ ∃ f : (ℕ → Bool) → Bool, Continuous f ∧ ∀ w, f w = true ↔ ∃ k, w k = true := + fun ⟨f, hc, hf⟩ => not_continuousAt_bot_of_decides_fires_once f hf hc.continuousAt + +/-- **`Statement:` "some test on `ℕ → Bool` is continuous", bare: the statement control for § IX, +whose statements all mention `Continuous` or `IsOpen` on this space.** -/ +def ContinuousTestStatement : Prop := ∃ f : (ℕ → Bool) → Bool, Continuous f + +-- Statement: CONTROL, fired at stage 0 is decided by a one-bit prefix: `w ↦ w 0` is continuous. +example : Continuous fun w : ℕ → Bool => w 0 := continuous_apply 0 + +-- Statement: CONTROL, the complement, never fired, is closed and not open. +example : IsClosed {w : ℕ → Bool | ∀ k, w k = false} ∧ + ¬ IsOpen {w : ℕ → Bool | ∀ k, w k = false} := by + have hc : {w : ℕ → Bool | ∀ k, w k = false} = {w | ∃ k, w k = true}ᶜ := by + ext w; simp + refine ⟨hc ▸ isOpen_fires_once.isClosed_compl, fun ho => ?_⟩ + obtain ⟨_, ⟨x, n, rfl⟩, hb, hsub⟩ := + (PiNat.isTopologicalBasis_cylinders (fun _ : ℕ => Bool)).mem_nhds_iff.1 + (ho.mem_nhds (show (⊥ : ℕ → Bool) ∈ {w : ℕ → Bool | ∀ k, w k = false} from fun _ => rfl)) + have hw : (fun k => decide (k = n)) ∈ PiNat.cylinder x n := by + rw [← PiNat.mem_cylinder_iff_eq.1 hb] + intro i hi; simp [Nat.ne_of_lt hi] + have := hsub hw n + simp at this + +-- Statement: CONTROL, the theorem is about continuity, not definability: classically, a Boolean +-- function on `ℕ → Bool` that is not continuous exists. +example : ∃ f : (ℕ → Bool) → Bool, ¬ Continuous f := by + classical + exact ⟨fun w => decide (∃ k, w k = true), fun hc => + no_continuous_test_fires_once ⟨_, hc, fun w => by simp⟩⟩ + +-- Statement: CONTROL, continuity alone does not give the uniform `N`: on `ℕ → ℕ`, `w ↦ (w (w 0) = 0)` is +-- continuous and no single prefix length fixes its value. +example : ∃ f : (ℕ → ℕ) → Bool, Continuous f ∧ + ¬ ∃ N, ∀ w w' : ℕ → ℕ, (∀ i < N, w i = w' i) → f w = f w' := by + refine ⟨fun w => decide (w (w 0) = 0), ?_, ?_⟩ + · rw [continuous_iff_continuousAt] + intro w + have hmem : PiNat.cylinder w (w 0 + 1) ∈ nhds w := + (PiNat.isOpen_cylinder (fun _ : ℕ => ℕ) w _).mem_nhds (PiNat.self_mem_cylinder _ _) + rw [ContinuousAt, nhds_discrete Bool, Filter.tendsto_pure] + refine Filter.mem_of_superset hmem fun y hy => ?_ + have h0 : y 0 = w 0 := hy 0 (Nat.succ_pos _) + have h1 : y (w 0) = w (w 0) := hy (w 0) (Nat.lt_succ_self _) + show decide (y (y 0) = 0) = decide (w (w 0) = 0) + rw [h0, h1] + · rintro ⟨N, hN⟩ + have := hN (fun i => if i = 0 then N + 1 else 0) + (fun i => if i = 0 then N + 1 else if i = N + 1 then 1 else 0) + (fun i hi => by by_cases h : i = 0 <;> simp [h]; omega) + simp at this + end ZeroParadox /-! ## Axiom Purity Check -/ @@ -195,5 +786,41 @@ open ZeroParadox #print axioms trials_fires #print axioms trials_tsum_top #print axioms crossing_almost_surely +#print axioms exists_fires_io +#print axioms zeroBlock +#print axioms zeroBlock_eq_pi +#print axioms trials_zeroBlock +#print axioms exists_halving_block +#print axioms trials_zeroBlock_le +#print axioms silentFrom +#print axioms silentFrom_eq_iInter +#print axioms not_mem_limsup_fires_iff +#print axioms ZeroBlockTest +#print axioms AvoidsTests +#print axioms zeroBlockTest_silentFrom +#print axioms fires_io_of_avoids +#print axioms squaresTape +#print axioms squaresTape_not_avoids +#print axioms oneBlock +#print axioms trials_oneBlock +#print axioms slotMotion +#print axioms slotRun +#print axioms slotRun_isRun +#print axioms slotMotion_leavesAt_false +#print axioms slotMotion_selfOnlyAt_true +#print axioms slotRun_crosses_iff +#print axioms slotRun_image_departs_of_avoids +#print axioms firedRun +#print axioms firedRun_spec +#print axioms firedRun_isRun +#print axioms t_snap_of_fires_once +#print axioms trials_fires_once +#print axioms t_snap_of_avoids +#print axioms prefixDetermined_of_continuous +#print axioms continuous_of_prefixDetermined +#print axioms isOpen_fires_once +#print axioms not_continuousAt_bot_of_decides_fires_once +#print axioms no_continuous_test_fires_once +#print axioms ContinuousTestStatement end PurityCheck diff --git a/ZeroParadox/Information/CrossingTrials.md b/ZeroParadox/Information/CrossingTrials.md new file mode 100644 index 00000000..c8be10f4 --- /dev/null +++ b/ZeroParadox/Information/CrossingTrials.md @@ -0,0 +1,218 @@ +# Crossing trials, § IV–IX: from almost surely to one run, from one firing to a state sequence, and why a finite reading can confirm a firing (`isOpen_fires_once`) and never refute one + +Ride-along for `ZeroParadox/Information/CrossingTrials.lean`. The Lean file holds the declarations, the +Engineer's Take and the per-declaration glosses; this file holds the prior art, the open items and the +two-chart reading for § IV–VII (`Reading:` CARRIER, § Two charts below), and the conditionals of § VIII and § IX below. + +## What the sections establish, as conditionals + +- § IV. If `0 < p ≤ 1`, some tape fires infinitely often (`exists_fires_io`). Not every tape fires even + once (the `example` after it, the all-`false` tape). Measure one buys an existential, never a universal. +- § V. If `0 < p ≤ 1`, the tapes silent from stage `N` on (`silentFrom N`) are the intersection of zero + blocks whose measures are at most `2⁻ᵐ` (`trials_zeroBlock_le`, `silentFrom_eq_iInter`); a tape fails + to fire infinitely often iff it is silent from some `N` (`not_mem_limsup_fires_iff`). +- § VI. If `0 < p ≤ 1`, a class `𝒯` of tests contains every zero-block test for `trials p hp`, and the + tape `w` avoids `𝒯`, then `w` fires infinitely often (`fires_io_of_avoids`). The avoidance is the + hypothesis `htyp` on one tape. For `𝒯` the zero-block tests it is weak: the all-`true` tape, a + constant tape, meets it at every `p ≤ 1` (the third `example`); for `p < 1` it is not Martin-Löf + randomness (open item 1 concerns that), and at `p = 1/2` it does not give Kurtz randomness either, + since the all-`true` tape is computable (Kurtz and Reimann–Slaman entries below). One way: the squares tape + fires infinitely often (the first `example`), and for every `0 < p ≤ 1` and every such `𝒯` it does + not avoid `𝒯` (`squaresTape_not_avoids`; the first `example` is the case `p = 1/2`); at `p = 1/2` + the all-`true` tape fires infinitely often and lies in every one block, each of measure at most + `2⁻ᵐ` (the second `example`), so it does not avoid a class that also holds those one-block tests. +- § VII. In `slotMotion`, `false` steps elsewhere and to itself (`slotMotion_leavesAt_false`); `true` + steps to itself only (`slotMotion_selfOnlyAt_true`). Every tape drives a run (`slotRun_isRun`). Along + a one-to-one lax map, stepping elsewhere carries to the image (`Motion.LaxHom.leavesAt`, in + `ZeroParadox/Die.lean`), with no tape and no measure. `slotRun_image_departs_of_avoids` gives an image + run that leaves its start for a tape meeting § VI's hypotheses. Those hypotheses are sufficient, not + necessary: any tape that fires once gives such a run (`slotRun_crosses_iff`; the `example` after the + theorem), and the squares tape gives one while failing them at every `0 < p ≤ 1` (the second + `example`, from `squaresTape_not_avoids`). `Reading:` what § VI adds is a guarantee stated through + test sets, naming no stage at which the tape fires. The all-`false` tape drives a run that never leaves `false` (the + closing `example`). +- § VIII. If a tape fires at some stage (`hw`) and `φ : Bool → L`, `L` a `ZPSemilattice`, sends + `false` to ⊥ of `L` and `true` to a point other than ⊥ of `L`, then `φ` applied to the run with the + stages before the first firing dropped is a state sequence meeting `t_snap_given`'s `hcc1` and + `hocc` (`t_snap_of_fires_once`). It steps once, at index 1, and stays, so it is not an + `IsStrictStateSequence` (the file's last `example`). If `0 < p ≤ 1`, the tapes that fired at least + once have `trials p hp` measure one (`trials_fires_once`), and § VI's hypotheses give `hw` + (`t_snap_of_avoids`). `Reading:` `hw` is the occurrence commitment in its slot chart, as one + hypothesis on the realized tape (`ZeroParadox/Order/Snap.lean` states both charts). +- § IX. Topology: the product (Cantor) topology on `ℕ → Bool`, `Bool` discrete; ⊥ of `ℕ → Bool` + (pointwise order) is the all-`false` tape. If a test `f : (ℕ → Bool) → Bool` is continuous, one + prefix length `N`, the same for every tape, fixes its value (`prefixDetermined_of_continuous`, by + compactness of `ℕ → Bool`); if one such `N` exists, `f` is continuous + (`continuous_of_prefixDetermined`). The tapes that fired at least once form an open set + (`isOpen_fires_once`); its complement, the tapes that never fire, is closed and not open (a CONTROL + `example`). If `f w = true` exactly when `w` has a `true`, `f` is not continuous at ⊥ of `ℕ → Bool` + (`not_continuousAt_bot_of_decides_fires_once`), so no continuous test decides firing on every tape + (`no_continuous_test_fires_once`). Controls: `w ↦ w 0` is continuous (fired at stage 0 is read off one + bit); classically a Boolean function on `ℕ → Bool` that is not continuous exists, so § IX is about + continuity, not definability; on `ℕ → ℕ` (Baire space) `w ↦ (w (w 0) = 0)` is continuous with no + single prefix length for every tape, so the uniform `N` is not a consequence of continuity alone. + Direction: fixed by one finite prefix length ⇔ continuous (both proved); computable ⇒ continuous + (cited below, not proved). A Type-2 machine is Weihrauch's machine model for computing on infinite tapes; + the proof of his Theorem 2.2.3 (p. 30) rests on its reading only a finite prefix of each infinite + input tape before it halts or produces each finite piece of output (its definition, § 2.1, was not retrieved here). `Reading:` (cited, not + claimed) since every computable function on these tapes is continuous (Weihrauch, Thm 2.2.3, p. 30, + read with a Boolean answer as a one-letter word of Σ*), no Type-2 machine computes a total test + deciding firing. Asking that every tape be decided, as a proposition rather than by a Boolean + function, is `LPO` (`ZeroParadox/Category/LawvereTaboo.lean` § V); the split `LPO ↔ WLPO ∧ MP` at + ⊥ of `ℕ → Bool` is the `example` in `ZeroParadox/Category/ChoiceCannotBe.lean` § II. `Reading:` + `hw` in `t_snap_of_fires_once` is one tape's instance of the predicate that no continuous test + decides uniformly over all tapes: at a tape that has fired, a finite prefix settles it + (`isOpen_fires_once`); at ⊥ of `ℕ → Bool`, no finite prefix does + (`not_continuousAt_bot_of_decides_fires_once`). The occurrence commitment's slot chart is a bit that + a finite reading can confirm and never refute. + Footprints: every § IX declaration measures `[propext, Classical.choice, Quot.sound]`, and so does + `ContinuousTestStatement`, the bare proposition that some test on `ℕ → Bool` is continuous + (STATEMENT-CARRIED, `ZeroParadox/Category/ChoiceCannotBe.md`); a statement control for each § IX theorem is not recorded + here. `t_snap_of_fires_once` itself measures `[propext, Quot.sound]`. + +## Prior art + +- **Effective second Borel–Cantelli lemma.** G. Davie, "The Borel-Cantelli lemmas, probability laws and + Kolmogorov complexity", Ann. Probab. 29(4) (2001) 1426–1434. Davie's text was not retrieved; it is cited + as restated in P. Potgieter, arXiv:1612.09492v1, p. 2, Lemma 1.1, attributed there to [2] = Davie + (reference list, p. 13): for "a uniform sequence of Σ⁰₁ sets" {A_k}, "(ii) If the events {A_k} are + pairwise independent and ∑_k λ(A_k) = ∞, then A_k must occur infinitely often for each α ∈ KC", with λ + the Lebesgue (fair-coin) measure and KC the Kolmogorov–Chaitin complex sequences (p. 1: prefixes + incompressible up to a constant, `∃k ∀n K(α(n)) ≥ n − k`). With `K` prefix-free complexity, these are + exactly the Martin-Löf random sequences (Levin–Schnorr: Franklin and Porter, arXiv:2004.02851, p. 16, + Theorem 2.5); Potgieter's p. 1 does not say whether its `K` is prefix-free. § VI has the shape of + (ii) for the events `fires n`, with two differences: the measure is Bernoulli(`p`) for any + `0 < p ≤ 1`, computable or not, and the hypothesis is avoidance of a parameter class `𝒯` holding the + zero-block tests. At `p = 1/2` the weakest such hypothesis (`𝒯` the zero-block tests) is implied + by Martin-Löf randomness granted open item 1, which includes that `trials (1/2)` is the fair-coin + measure; a larger `𝒯` can make the hypothesis stronger (no tape avoids the class of all families). + The credit runs from Davie to here. +- **Computable non-atoms are not random.** J. Reimann and T. Slaman, "Measures and their random reals", + arXiv:0802.2705, p. 9, Theorem 4.4, (i) ⇒ (ii): a computable sequence that is not an atom of a + probability measure `µ` is not `µ`-random (Martin-Löf randomness relative to a representation of `µ`). + `squaresTape_not_avoids` has that shape at Bernoulli(`p`), where the squares tape is not an atom for + any `0 < p ≤ 1`; its test is a zero-block test needing only the integer `K`, and that zero-block tests + are tests in their sense is not proved here (open item 1, stated at `p = 1/2`). The credit runs from + Reimann and Slaman to here. +- **Kurtz null tests.** J. Franklin and C. Porter, "Key developments in algorithmic randomness", + arXiv:2004.02851, p. 32, Definition 4.24 (citing Wang): "A Kurtz null test is a Martin-Löf test ⟨V_i⟩ + such that for some computable function f : ω → (2^{<ω})^{<ω}, V_n = [f(n)] for all n"; p. 33, Theorem + 4.26 (credited there to Wang and to Downey, Griffiths and Reid): a sequence is Kurtz random iff it + passes all Kurtz null tests. Each level of a `ZeroBlockTest` is a finite union of cylinders, chosen + by a primitive recursive index, so at `p = 1/2` a zero-block test has the shape of a Kurtz null test + (open item 1). +- **Kurtz randomness in Lean.** C. Freer, `algorithmic-randomness` + (github.com/cameronfreer/algorithmic-randomness, commit `863da3d`, + `AlgorithmicRandomness/Randomness/Kurtz.lean`, retrieved 2026-11-01): `IsKurtzRandom x := ∀ T : + ComputableTree, fairCoin T.paths = 0 → x ∉ T.paths`, with `IsMartinLofRandom.isKurtzRandom` and + `ComputableCantorPoint.not_isKurtzRandom`. Fair-coin measure only. +- **Martin-Löf randomness in Lean.** A. Milovanov, `kolmogorov-complexity-lean` + (github.com/AlexeyMilovanov/kolmogorov-complexity-lean, commit `28da513`, + `KolmogorovMathlib/AlgorithmicRandomness/MartinLof.lean`, retrieved 2026-11-01): + `IsMartinLofTest μ U := IsUniformlyEffectiveOpen U ∧ ∀ n, μ (U n) ≤ dyadicValue 1 n`, "a uniformly + effective open sequence of sets whose measures decrease as `2⁻ⁿ`"; `IsMartinLofRandom μ w := ∀ U, + IsMartinLofTest μ U → w ∉ ⋂ n, U n`. `AvoidsTests` has the shape of `IsMartinLofRandom` with the test + class left as a parameter. The same library's `EffectiveSLLNBernoulli.lean` states + `tendsto_freqOne_of_isMartinLofRandom_bernoulli'` ("SUV Theorem 34"): for `p ≤ 1` with + `IsComputableReal (p : ℝ)` and `x` Martin-Löf random for its `bernoulliMeasure p hp`, the frequency of + ones in `x` tends to `p`; for `p > 0` that gives infinitely many ones. Its hypothesis needs a + computable `p`, which § VI does not; that Martin-Löf randomness meets § VI's `htyp` for `𝒯` = the + zero-block tests is open item 1 at `p = 1/2` and is not stated here for other `p`, and its + `bernoulliMeasure` was not compared with `trials`. For the uniform measure the same library has + `exists_isMartinLofRandom_uniform` (a Martin-Löf random sequence exists, `EffectiveLaws.lean`) and + `isEffectivelyNull_singleton_of_computable` (no computable sequence is, `EffectiveNull.lean`); given + open item 1, the first gives a Martin-Löf random tape meeting `htyp` at `p = 1/2` for `𝒯` = the + zero-block tests. A tape meeting that `htyp` needs no open item: the all-`true` tape meets it at every + `p ≤ 1` (§ VI's third `example`), so that hypothesis is weak, and Martin-Löf randomness is the + stronger property open item 1 is about. None of these libraries is a dependency here. +- **Mathlib.** The pin was searched 2026-11-01 for `Martin-L`, `MartinLof`, `algorithmic(ally)? random`, + `Kurtz` (case-insensitive, `.lake/packages/mathlib/Mathlib`): zero matches. Not located as of + 2026-11-01, searched as stated. theoremsearch, four phrasings (Kurtz null test; Martin-Löf random for + Bernoulli `p > 0` has infinitely many ones; a formal-only phrasing; effective Borel–Cantelli), found the + Franklin–Porter and Potgieter passages above; LeanExplore, two phrasings, returned no randomness + declaration (an uninformative null). +- **§ IX: computable implies continuous on Cantor space.** K. Weihrauch, *Computable Analysis: An + Introduction* (Springer 2000), p. 30, Theorem 2.2.3 (computable ⇒ continuous): "Every computable + string function f :⊆ Y₁ × … × Y_k → Y₀ is continuous", each Yᵢ being Σ* or Σ^ω with the Cantor + topology on Σ^ω (Def. 2.2.2, p. 29). Not formalized here. p. 32, Theorem 2.2.6: (1) "A subset + X ⊆ Σ^ω is clopen, iff it is decidable, iff X = AΣ^ω for some finite set A ⊆ Σ*"; (2) "A (total) + function f : Σ^ω → Σ* is continuous, iff it is computable, iff" it is a finite prefix-free table, by + compactness. `prefixDetermined_of_continuous` has the shape of (2)'s continuous-to-table direction + with Σ = Bool and one-letter outputs, with one prefix length in place of a prefix-free table. p. 32, + Exercises 2.2.2–2.2.3: "Show that the characteristic function of the set {0^ω} ⊆ Σ^ω is not + continuous (Example 2.1.4.6)", "Show that Σ^ω \ {0^ω} is open but not closed"; at Σ = {0, 1} with 0 + read as `false`, {0^ω} is {⊥ of `ℕ → Bool`} and Σ^ω \ {0^ω} is the set of tapes that fired. + `not_continuousAt_bot_of_decides_fires_once` has the shape of Exercise 2.2.2, for the negated + characteristic function and stated pointwise at ⊥ of `ℕ → Bool`; `isOpen_fires_once` with the + never-fired CONTROL `example` has the shape of Exercise 2.2.3. The credit runs from Weihrauch to here. +- **Mathlib, for § IX.** Used: `PiNat.cylinder`, `PiNat.isTopologicalBasis_cylinders`, + `PiNat.isOpen_cylinder`, `PiNat.mem_cylinder_iff_eq`, `PiNat.self_mem_cylinder` + (`Mathlib/Topology/MetricSpace/PiNat.lean`). Neighbours: `continuous_boolIndicator_iff_isClopen` + (`Mathlib/Topology/Clopen.lean`), a set's Boolean indicator is continuous iff the set is clopen, the + general form of `no_continuous_test_fires_once` given that the fired set is not clopen (Weihrauch's + Theorem 2.2.6(1) is the decidable-iff-clopen counterpart); `Profinite.exists_locallyConstant` + (`Mathlib/Topology/Category/Profinite/CofilteredLimit.lean`), a locally constant function on a + cofiltered limit of profinite spaces factors through one stage, which Mathlib instantiates on closed + subsets of `I → Bool` as `Profinite.NobelingProof.fin_comap_jointlySurjective` for a linearly + ordered `I` (`Mathlib/Topology/Category/Profinite/Nobeling/Span.lean`, `ℤ`-valued, through a finite + set of coordinates), a Mathlib form near `prefixDetermined_of_continuous`, which uses one prefix + length instead. The § IX statements as written were not located as of 2026-11-03, + searched as follows: `exact?` on the prefix form, on a `DependsOn` form and on `¬ IsClopen` of the + fired set (no hit, an uninformative null); LeanExplore, three phrasings (continuous map from Cantor + space depends on a finite prefix; locally constant map on a compact product factors through finitely + many coordinates; clopen subsets of Cantor space as finite unions of cylinders), which returned + `Profinite.exists_locallyConstant` and `TopologicalSpace.Clopens.surjective_finset_sup_prod` + (`Mathlib/Topology/ClopenBox.lean`, binary products only). Computability on tapes: Mathlib's + `Computable` takes `Primcodable` types and `ℕ → Bool` has none (the first § IX `example`); the nearest + Mathlib notion, `RecursiveIn` / `ComputableIn` (`Mathlib/Computability/RecursiveIn.lean`), is + computability relative to a fixed oracle set, still between `Primcodable` types, not a machine taking + a tape as input. A case-sensitive grep of the pinned `Mathlib/` for `Weihrauch`, `Type-2`, the word + `TTE`, `computable analysis`, `represented space` and `oracle machine` returned no match, and + LeanExplore (one phrasing, type-two computability) returned only `Computable` on `Primcodable` types. + +## What remains open (2026-11-01) + +1. **Zero-block tests and the standard test classes.** That every `ZeroBlockTest` at `p = 1/2` is a Kurtz + null test, hence a Martin-Löf test, is read off the definitions above and is not proved in Lean here; + nor is it proved that `trials (1/2)` is the fair-coin measure those definitions use. No + effective-open-set notion was located in `ZeroParadox/**` as of 2026-11-01 (searched for + `effective(ly) open`, `EffectiveOpen`, `Σ⁰₁`, `Sigma01`, `computably enumerable`, `IsKurtz`, + `MartinLof`: hits only in prose), and neither library is imported. +2. **Uniformity in `p`.** `exists_halving_block` gives the block length `K` by an existence proof; it is + not computed from `p`. For one fixed `p` the test needs only the number `K`, so the primitive-recursive + index holds for every `0 < p` (`zeroBlockTest_silentFrom`). Computability of `p` would matter for a + test uniform in `p`, and for Milovanov's universal test, which assumes a computable measure. +3. **The bridge to the framework.** No map from ⊥ of a `ZPSemilattice` to a tape is claimed + (`ZeroParadox/Information/Disjunctive.md` fence 3; fence 1 of the Lean header: nothing here says the + structureless referent ⊥ is the trial space). `htyp` is a hypothesis on a tape. + +## Two charts + +`Reading:` CARRIER — Tim's sentence "the bottom is infinitely complex, and somewhere in that complexity +movement is possible" reads here as: if the tape driving a run is typical (it avoids the tests), and the +per-stage chance is positive, the run it drives crosses. Possibility (`LeavesAt` at `false`) is a property +of the motion; crossing is a property of one run; typicality is a property of a tape, a point of +`ℕ → Bool`, never of a state of `slotMotion`, a point of `Bool`. + +`Reading:` CARRIER — the tension. In the valuation chart, `infinitude_forces_infinite_complexity` +(`ZeroParadox/Valuation/InfinitudeFloor.lean`) gives complexity ⊤ (the top of `ℕ∞`) at the floor of any +`InfinitudeFloor`; at the 2-adic instance `q2InfinitudeFloor`, on `ℚ_[2]`, the floor is 0 and its +complexity is `cxQ2 0 = ⊤` (`cxQ2_zero`, from the explicit `if x = 0` in the definition of `cxQ2`), +matching the additive-valuation convention that the valuation of 0 is ⊤. Read as a digit tape (a +reading; no map from `ℚ_[2]` to tapes is built here), 0 is the all-`false` tape, the sole member of +`silentFrom 0`, and § VI's hypothesis excludes it at `N = 0` for every `0 < p ≤ 1` +(`zeroBlockTest_silentFrom`). In the tape chart, under the pointwise order, the least element of +`ℕ → Bool` is the same all-`false` tape (the `example` at `ZeroParadox/BottomCannotBe.lean`, +`(⊥ : ℕ → Bool) = fun _ => false`), which is not disjunctive (`allFalse_not_disjunctive`, +`ZeroParadox/Information/Disjunctive.lean`). Tim's maximally complex reading +(`ZeroParadox/Information/Disjunctive.md` fence 3) places the occupant of ⊥ of a `ZPSemilattice`, read as +a tape, among the maximally complex tapes, which by standard theory (Levin–Schnorr; not proved here, +Disjunctive.md fence 2) are Martin-Löf random for the fair coin; that such tapes meet § VI's hypothesis at +`p = 1/2` for `𝒯` = the zero-block tests is open item 1. That hypothesis is weak and does not single +them out: the all-`true` tape meets it too (§ VI's third `example`). The two readings put different tapes in the +role, and nothing in Lean identifies them. + +Not claimed: that the realized tape is typical or has fired, or that ⊥ of any carrier is a tape. The +theorem moves "almost surely" (`crossing_almost_surely`, which already assumes `0 < p`) to "this run +crosses" by adding two premises: a class `𝒯` holding the zero-block tests for `trials p hp`, and `htyp`. +§ VIII's `t_snap_of_avoids` derives `hw` from `htyp`; neither is supplied for the realized tape. diff --git a/ZeroParadox/Information/MaxEntropy.lean b/ZeroParadox/Information/MaxEntropy.lean new file mode 100644 index 00000000..a36dfea0 --- /dev/null +++ b/ZeroParadox/Information/MaxEntropy.lean @@ -0,0 +1,479 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the fair coin maximizes entropy, missing information vanishes exactly there, and for each prefix-free decoder almost every fair-coin tape is incompressible. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Information.TwoRequirements +import Mathlib.Analysis.SpecialFunctions.BinaryEntropy +import Mathlib.Analysis.Convex.Jensen +import Mathlib.InformationTheory.KullbackLeibler.Basic +import Mathlib.InformationTheory.Coding.KraftMcMillan +import Mathlib.Tactic + +set_option maxHeartbeats 400000 + +/-! +# Maximum entropy: the fair coin, missing information, and incompressible tapes + +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. + +--- + +## Formal Overview (AI-assisted) +§ I–II: entropy on `Fin n` is at most `log n`, equal iff uniform; `log 2 - binEntropy p` is 0 iff +`p = 1/2`. § III: that coin is `fairTape`; with a first step at ⊥ of `L`, almost every tape is +Martin-Löf random and gives the snap. § IV: any prefix-free decoder; almost every fair tape is +incompressible up to a constant. -/ + +namespace ZeroParadox + +open MeasureTheory Filter ZPSemilattice + +/-! ## § I. Entropy is maximal exactly at the uniform law + +Binary case in Mathlib (the first `example`). The `n`-symbol case is Jensen on the strictly concave +`Real.negMulLog`; not located in the pinned Mathlib as of 2026-11-06 (grep of `negMulLog`, `log_card`). +Standard (Gibbs' inequality); a formal version outside the closure is the PFR project's +`ProbabilityTheory.measureEntropy_le_log_card` (located by theoremsearch, not read, not compared +here). -/ + +section Entropy + +open Real + +-- Statement: Mathlib, `Real.binEntropy_le_log_two` and `Real.binEntropy_eq_log_two`: binary entropy +-- is at most `log 2`, with equality iff `p = 1/2`; both directions of the equality. +example (p : ℝ) : binEntropy p ≤ log 2 ∧ (binEntropy p = log 2 ↔ p = 2⁻¹) := + ⟨binEntropy_le_log_two, binEntropy_eq_log_two⟩ + +/-- `Statement:` Shannon entropy, in nats, of a weight vector on `Fin n`. -/ +noncomputable def shannonEntropy {n : ℕ} (q : Fin n → ℝ) : ℝ := ∑ i, negMulLog (q i) + +/-- `Statement:` `negMulLog (1/n) = (1/n) log n`. -/ +theorem negMulLog_inv_natCast (n : ℕ) : + negMulLog ((n : ℝ)⁻¹) = (n : ℝ)⁻¹ * log n := by + simp [negMulLog, log_inv] + +/-- `Statement:` Jensen for `negMulLog` at the uniform weights `1/n`. -/ +theorem avg_negMulLog_le {n : ℕ} (hn : 0 < n) (q : Fin n → ℝ) (hq0 : ∀ i, 0 ≤ q i) : + (∑ i : Fin n, (n : ℝ)⁻¹ • negMulLog (q i)) ≤ + negMulLog (∑ i : Fin n, (n : ℝ)⁻¹ • q i) := + concaveOn_negMulLog.le_map_sum (fun _ _ => by positivity) + (by simp [Finset.card_univ, Fintype.card_fin]; field_simp) + (fun i _ => Set.mem_Ici.2 (hq0 i)) + +/-- `Statement:` the uniform average of a probability vector on `Fin n` is `1/n`. -/ +theorem avg_eq_inv_card {n : ℕ} (q : Fin n → ℝ) (hq1 : ∑ i, q i = 1) : + (∑ i : Fin n, (n : ℝ)⁻¹ • q i) = (n : ℝ)⁻¹ := by + simp [smul_eq_mul, ← Finset.mul_sum, hq1] + +/-- `Statement:` the uniform average of `negMulLog ∘ q` is `shannonEntropy q / n`. -/ +theorem avg_negMulLog_eq {n : ℕ} (q : Fin n → ℝ) : + (∑ i : Fin n, (n : ℝ)⁻¹ • negMulLog (q i)) = (n : ℝ)⁻¹ * shannonEntropy q := by + simp [smul_eq_mul, ← Finset.mul_sum, shannonEntropy] + +/-- `Statement:` a probability vector on `Fin n`, `0 < n`, has entropy at most `log n`. -/ +theorem shannonEntropy_le_log {n : ℕ} (hn : 0 < n) (q : Fin n → ℝ) (hq0 : ∀ i, 0 ≤ q i) + (hq1 : ∑ i, q i = 1) : shannonEntropy q ≤ log n := by + have h := avg_negMulLog_le hn q hq0 + rw [avg_eq_inv_card q hq1, avg_negMulLog_eq, negMulLog_inv_natCast n] at h + have hpos : (0 : ℝ) < (n : ℝ)⁻¹ := by positivity + exact le_of_mul_le_mul_left h hpos + +/-- `Statement:` under the same hypotheses, entropy equals `log n` iff `q` is uniform; both +directions. -/ +theorem shannonEntropy_eq_log_iff {n : ℕ} (hn : 0 < n) (q : Fin n → ℝ) (hq0 : ∀ i, 0 ≤ q i) + (hq1 : ∑ i, q i = 1) : shannonEntropy q = log n ↔ ∀ i, q i = (n : ℝ)⁻¹ := by + have hiff := strictConcaveOn_negMulLog.map_sum_eq_iff (t := Finset.univ) + (w := fun _ : Fin n => (n : ℝ)⁻¹) (p := q) (fun _ _ => by positivity) + (by simp [Finset.card_univ, Fintype.card_fin]; field_simp) + (fun i _ => Set.mem_Ici.2 (hq0 i)) + rw [avg_eq_inv_card q hq1, avg_negMulLog_eq, negMulLog_inv_natCast n] at hiff + have hne : (n : ℝ)⁻¹ ≠ 0 := by positivity + constructor + · intro h + have := hiff.1 (by rw [h]) + exact fun i => this i (Finset.mem_univ i) + · intro h + have := hiff.2 (fun j _ => h j) + exact (mul_left_cancel₀ hne this).symm + +-- Statement: CONTROL, a point mass on `Fin 2` has entropy 0, below `log 2`. +example : shannonEntropy (fun i : Fin 2 => if i = 0 then (1 : ℝ) else 0) = 0 := by + simp [shannonEntropy, Fin.sum_univ_two] + +end Entropy + +/-! ## § II. Missing information: zero exactly at the fair coin + +`missingInfo p` is the gap between the maximum entropy `log 2` and `binEntropy p`. On `(0, 1)` it is +the Kullback–Leibler divergence of Bernoulli(`p`) from the fair coin, written out; the measure-level +`klDiv μ ν = 0 ↔ μ = ν` is Mathlib's (the `example` closing this section). -/ + +section Missing + +open Real + +/-- `Statement:` missing information, in nats, about a coin of bias `p`. -/ +noncomputable def missingInfo (p : ℝ) : ℝ := log 2 - binEntropy p + +/-- `Statement:` missing information is non-negative. -/ +theorem missingInfo_nonneg (p : ℝ) : 0 ≤ missingInfo p := + sub_nonneg.2 binEntropy_le_log_two + +/-- `Statement:` missing information is zero iff `p = 1/2`, iff `binEntropy p = log 2`; both +directions. `Reading:` INVERSION: the observer's zero sits where the ensemble's entropy is maximal. +For `0 ≤ p ≤ 1` both sides are finite, in `[0, log 2]` per symbol; the pole, zero coinciding with +infinity, has its own coincidence witness, `infinitude_forces_infinite_complexity`. -/ +theorem missingInfo_eq_zero_iff (p : ℝ) : + (missingInfo p = 0 ↔ p = 2⁻¹) ∧ (missingInfo p = 0 ↔ binEntropy p = log 2) := by + have h : missingInfo p = 0 ↔ binEntropy p = log 2 := by + unfold missingInfo; constructor <;> intro h <;> linarith + exact ⟨h.trans binEntropy_eq_log_two, h⟩ + +/-- `Statement:` on `(0, 1)`, `missingInfo p = p log (p / ½) + (1-p) log ((1-p) / ½)`. -/ +theorem missingInfo_eq_kl (p : ℝ) (h0 : 0 < p) (h1 : p < 1) : + missingInfo p = p * log (p / 2⁻¹) + (1 - p) * log ((1 - p) / 2⁻¹) := by + have h1' : 0 < 1 - p := by linarith + unfold missingInfo binEntropy + rw [log_div h0.ne' (by norm_num), log_div h1'.ne' (by norm_num), log_inv, log_inv, log_inv] + ring + +/-- `Statement:` `n` symbols: `log n - shannonEntropy q = 0` iff `q` is uniform; both directions. -/ +theorem missingInfo_fin_eq_zero_iff {n : ℕ} (hn : 0 < n) (q : Fin n → ℝ) (hq0 : ∀ i, 0 ≤ q i) + (hq1 : ∑ i, q i = 1) : log n - shannonEntropy q = 0 ↔ ∀ i, q i = (n : ℝ)⁻¹ := by + rw [sub_eq_zero, eq_comm]; exact shannonEntropy_eq_log_iff hn q hq0 hq1 + +-- Statement: Mathlib, `InformationTheory.klDiv_eq_zero_iff`: for finite measures, `klDiv μ ν = 0` +-- iff `μ = ν`; both directions. +example {α : Type*} [MeasurableSpace α] (μ ν : Measure α) [IsFiniteMeasure μ] + [IsFiniteMeasure ν] : InformationTheory.klDiv μ ν = 0 ↔ μ = ν := + InformationTheory.klDiv_eq_zero_iff + +end Missing + +/-! ## § III. The maximizer is `fairTape`, and the chain to the snap -/ + +/-- `Statement:` a bias in `NNReal` maximizing binary entropy is `1/2`. -/ +theorem eq_half_of_maxEntropy (p : NNReal) (h : Real.binEntropy (p : ℝ) = Real.log 2) : + p = 2⁻¹ := + NNReal.eq (by simpa using Real.binEntropy_eq_log_two.1 h) + +/-- `Statement:` exactly one bias `p` in `NNReal` maximizes binary entropy, and it has `0 < p ≤ 1`: +the hypotheses `hp0`, `hp` of `snap_ae_of_firstStep`. -/ +theorem maximizer_admissible : + ∃ p : NNReal, Real.binEntropy (p : ℝ) = Real.log 2 ∧ 0 < p ∧ p ≤ 1 ∧ + ∀ q : NNReal, Real.binEntropy (q : ℝ) = Real.log 2 → q = p := + ⟨2⁻¹, by simp, by norm_num, by norm_num, fun q hq => eq_half_of_maxEntropy q hq⟩ + +/-- `Statement:` if `p` maximizes binary entropy, `trials p hp` is `fairTape`. -/ +theorem trials_eq_fairTape_of_maxEntropy (p : NNReal) (hp : p ≤ 1) + (h : Real.binEntropy (p : ℝ) = Real.log 2) : trials p hp = fairTape := by + have key : ∀ (q : NNReal) (hq : q ≤ 1), q = 1 / 2 → trials q hq = fairTape := by + rintro q hq rfl; rfl + exact key p hp (by rw [eq_half_of_maxEntropy p h]; norm_num) + +/-- `Statement:` if ⊥ of `L` has a first step and `p` maximizes binary entropy, then `trials p hp`- +almost every tape is Martin-Löf random and gives the snap; `mlRandom_and_snap_ae`. One way. +`Reading:` CARRIER: the occurrence commitment is reduced to "the bottom's tape law is the +maximum-entropy coin", one sufficient choice: any `0 < p` gives the snap (`mlRandom_and_snap_ae`); +the fair coin is the one § IV ties to incompressibility. That ⊥ of `L` has a tape law, is unconstrained, or is random is not proved; +`BotHasFirstStep L` stays a hypothesis, and almost every is not every. -/ +theorem maxEntropy_mlRandom_and_snap_ae {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (p : NNReal) (hp : p ≤ 1) (hmax : Real.binEntropy (p : ℝ) = Real.log 2) : + ∀ᵐ w ∂(trials p hp), MLRandom (trials p hp) w ∧ ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := + mlRandom_and_snap_ae hR1 p hp (by rw [eq_half_of_maxEntropy p hmax]; norm_num) + +-- Statement: CONTROL, the bias `0` does not maximize binary entropy. +example : Real.binEntropy ((0 : NNReal) : ℝ) ≠ Real.log 2 := by + rw [NNReal.coe_zero, Real.binEntropy_zero]; exact (Real.log_pos one_lt_two).ne + +/-! ## § IV. Incompressibility without a machine + +A decoder is any `D : List Bool → Option (List Bool)`; `D d = some x` reads "`d` describes `x`". +`kraft_measure` is Kraft's inequality, measure form, prefix-free domain; finite sibling: Mathlib's +`InformationTheory.kraft_mcmillan_inequality` (the `example` after it). Closer siblings in Milovanov +(§ V, not compared): `domainWeight_le_one`, and `card_compressibleWordsLt` for `compressible_card`. +The `2⁻ᶜ` bound is the easy half of Schnorr's theorem. `Reading:` CARRIER: with the optimal prefix +machine `U` as `D`, `ae_incompressible` is the almost-every form of "`K(w↾n) ≥ n − c`"; `U` is not +defined here. "Maximally complex" means PREFIX-FREE incompressible: for plain complexity no tape has +constant deficiency (`ZeroParadox/Information/Disjunctive.md`). -/ + +/-- `Statement:` a prefix cylinder is a box over the first `l.length` coordinates. -/ +theorem prefixCyl_eq_pi (l : List Bool) : + prefixCyl l = (↑(Finset.range l.length) : Set ℕ).pi (fun i => ({l.getD i false} : Set Bool)) := by + ext w + simp only [prefixCyl, Set.mem_setOf_eq, Set.mem_pi, Finset.coe_range, Set.mem_Iio, + Set.mem_singleton_iff] + constructor + · intro h i hi; rw [h i hi]; simp [List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hi] + · intro h i hi; rw [h i hi]; simp [List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hi] + +/-- `Statement:` prefix cylinders are measurable. -/ +theorem prefixCyl_measurable (l : List Bool) : MeasurableSet (prefixCyl l) := by + rw [prefixCyl_eq_pi] + exact MeasurableSet.pi (Set.to_countable _) (fun _ _ => measurableSet_singleton _) + +/-- `Statement:` a word of length `n` has fair-coin measure `2⁻ⁿ`. -/ +theorem fairTape_prefixCyl (l : List Bool) : fairTape (prefixCyl l) = 2⁻¹ ^ l.length := by + rw [prefixCyl_eq_pi, fairTape, trials, Measure.infinitePi_pi _ (fun i _ => measurableSet_singleton _)] + have : ∀ i, (PMF.bernoulli (1/2) (by norm_num)).toMeasure {l.getD i false} = (2⁻¹ : ENNReal) := by + intro i; cases l.getD i false <;> simp [PMF.bernoulli] + rw [Finset.prod_congr rfl (fun i _ => this i), Finset.prod_const, Finset.card_range] + +/-- `Statement:` the first `n` bits of a tape. -/ +def prefixOf (w : ℕ → Bool) (n : ℕ) : List Bool := List.ofFn (fun i : Fin n => w i) + +/-- `Statement:` `w` lies in the cylinder of `x` iff `x` is the first `x.length` bits of `w`; both +directions. -/ +theorem mem_prefixCyl_iff (w : ℕ → Bool) (x : List Bool) : + w ∈ prefixCyl x ↔ x = prefixOf w x.length := by + constructor + · intro h + apply List.ext_getElem (by simp [prefixOf]) + intro i h1 h2 + simp [prefixOf, h i h1] + · intro h i hi + have h2 := congrArg (fun l : List Bool => l[i]?) h + simp only [prefixOf, List.getElem?_ofFn, List.getElem?_eq_getElem hi] at h2 + simp [hi] at h2 + exact h2.symm + +/-- `Statement:` the words of length below `k`, as a finset. -/ +def shortWords (k : ℕ) : Finset (List Bool) := + (Finset.range k).biUnion (fun j => (Finset.univ : Finset (Fin j → Bool)).image List.ofFn) + +/-- `Statement:` every word of length below `k` is in `shortWords k`. -/ +theorem mem_shortWords {k : ℕ} {d : List Bool} (h : d.length < k) : d ∈ shortWords k := by + simp only [shortWords, Finset.mem_biUnion, Finset.mem_range, Finset.mem_image, Finset.mem_univ, + true_and] + exact ⟨d.length, h, fun i => d[i], List.ofFn_getElem⟩ + +/-- `Statement:` there are at most `2^k - 1` words of length below `k`. -/ +theorem card_shortWords_le (k : ℕ) : (shortWords k).card + 1 ≤ 2 ^ k := by + induction k with + | zero => simp [shortWords] + | succ k ih => + have h1 : shortWords (k + 1) = + shortWords k ∪ (Finset.univ : Finset (Fin k → Bool)).image List.ofFn := by + simp [shortWords, Finset.range_add_one, Finset.biUnion_insert, Finset.union_comm] + rw [h1] + have h2 := Finset.card_union_le (shortWords k) + ((Finset.univ : Finset (Fin k → Bool)).image List.ofFn) + have h3 : ((Finset.univ : Finset (Fin k → Bool)).image List.ofFn).card ≤ 2 ^ k := + Finset.card_image_le.trans (by simp) + rw [pow_succ]; omega + +/-- `Statement:` for any decoder `D`, the words with a description shorter than `k` lie in a finset +of at most `2^k - 1` words. -/ +theorem compressible_card (D : List Bool → Option (List Bool)) (k : ℕ) : + ∃ S : Finset (List Bool), {x | ∃ d, d.length < k ∧ D d = some x} ⊆ ↑S ∧ S.card + 1 ≤ 2 ^ k := by + classical + refine ⟨(shortWords k).biUnion (fun d => (D d).toFinset), ?_, ?_⟩ + · rintro x ⟨d, hd, hD⟩ + simp only [Finset.coe_biUnion, Set.mem_iUnion, Finset.mem_coe, exists_prop] + exact ⟨d, mem_shortWords hd, by simp [hD]⟩ + · have : ((shortWords k).biUnion (fun d => (D d).toFinset)).card ≤ (shortWords k).card := by + refine (Finset.card_biUnion_le).trans ?_ + calc ∑ d ∈ shortWords k, (D d).toFinset.card ≤ ∑ _d ∈ shortWords k, 1 := + Finset.sum_le_sum fun d _ => by cases D d <;> simp + _ = (shortWords k).card := by simp + have := card_shortWords_le k; omega + +/-- `Statement:` no word in `S` is a proper prefix of another in `S`. -/ +def PrefixFree (S : Set (List Bool)) : Prop := ∀ d ∈ S, ∀ e ∈ S, d <+: e → d = e + +/-- `Statement:` two words whose cylinders meet are prefix-comparable. -/ +theorem prefix_of_mem_prefixCyl {d e : List Bool} {w : ℕ → Bool} (hd : w ∈ prefixCyl d) + (he : w ∈ prefixCyl e) (hle : d.length ≤ e.length) : d <+: e := by + rw [List.prefix_iff_eq_take] + apply List.ext_getElem (by simp; omega) + intro i h1 h2 + simp only [List.getElem_take] + exact (hd i h1).symm.trans (he i (by omega)) + +/-- `Statement:` over a prefix-free domain, the domain's cylinders are pairwise disjoint. -/ +theorem pairwise_disjoint_domCyl (D : List Bool → Option (List Bool)) + (hD : PrefixFree {d | (D d).isSome}) : + Pairwise (Function.onFun Disjoint + (fun d => if (D d).isSome then prefixCyl d else (∅ : Set (ℕ → Bool)))) := by + intro d e hne + simp only [Function.onFun] + split_ifs with h1 h2 + · rw [Set.disjoint_left] + intro w hwd hwe + rcases le_total d.length e.length with hle | hle + · exact hne (hD d h1 e h2 (prefix_of_mem_prefixCyl hwd hwe hle)) + · exact hne (hD e h2 d h1 (prefix_of_mem_prefixCyl hwe hwd hle)).symm + all_goals simp + +/-- `Statement:` Kraft, measure form: over a prefix-free domain, `∑ 2^(-|d|) ≤ 1`. -/ +theorem kraft_measure (D : List Bool → Option (List Bool)) (hD : PrefixFree {d | (D d).isSome}) : + ∑' d, fairTape (if (D d).isSome then prefixCyl d else ∅) ≤ 1 := by + rw [← measure_iUnion (pairwise_disjoint_domCyl D hD) (fun d => by + split_ifs + · exact prefixCyl_measurable d + · exact MeasurableSet.empty)] + exact prob_le_one + +-- Statement: Mathlib, `InformationTheory.kraft_mcmillan_inequality`: a finite uniquely decodable +-- binary code has `∑ (1/2)^|w| ≤ 1`. +example {S : Finset (List Bool)} (h : InformationTheory.UniquelyDecodable (S : Set (List Bool))) : + ∑ w ∈ S, (1 / Fintype.card Bool : ℝ) ^ w.length ≤ 1 := + InformationTheory.kraft_mcmillan_inequality h + +/-- `Statement:` the tapes with a prefix `x` having a `D`-description `c` or more bits shorter. -/ +def compressibleTapes (D : List Bool → Option (List Bool)) (c : ℕ) : Set (ℕ → Bool) := + {w | ∃ d x, D d = some x ∧ d.length + c ≤ x.length ∧ w ∈ prefixCyl x} + +/-- `Statement:` over a prefix-free domain, `compressibleTapes D c` has fair-coin measure at most +`2⁻ᶜ`. -/ +theorem fairTape_compressibleTapes_le (D : List Bool → Option (List Bool)) + (hD : PrefixFree {d | (D d).isSome}) (c : ℕ) : fairTape (compressibleTapes D c) ≤ 2⁻¹ ^ c := by + classical + let B : List Bool → Set (ℕ → Bool) := fun d => + match D d with + | some x => if d.length + c ≤ x.length then prefixCyl x else ∅ + | none => ∅ + have hsub : compressibleTapes D c ⊆ ⋃ d, B d := by + rintro w ⟨d, x, hDx, hlen, hw⟩ + refine Set.mem_iUnion.2 ⟨d, ?_⟩ + simp only [B, hDx, if_pos hlen]; exact hw + have hB : ∀ d, fairTape (B d) ≤ + 2⁻¹ ^ c * fairTape (if (D d).isSome then prefixCyl d else ∅) := by + intro d + simp only [B] + cases hDd : D d with + | none => simp + | some x => + simp only [Option.isSome_some, if_true] + split_ifs with hlen + · rw [fairTape_prefixCyl, fairTape_prefixCyl, ← pow_add] + exact pow_le_pow_of_le_one zero_le (by norm_num) (by omega) + · simp + calc fairTape (compressibleTapes D c) ≤ fairTape (⋃ d, B d) := measure_mono hsub + _ ≤ ∑' d, fairTape (B d) := measure_iUnion_le _ + _ ≤ ∑' d, 2⁻¹ ^ c * fairTape (if (D d).isSome then prefixCyl d else ∅) := + ENNReal.tsum_le_tsum hB + _ = 2⁻¹ ^ c * ∑' d, fairTape (if (D d).isSome then prefixCyl d else ∅) := + ENNReal.tsum_mul_left + _ ≤ 2⁻¹ ^ c * 1 := by gcongr; exact kraft_measure D hD + _ = 2⁻¹ ^ c := mul_one _ + +/-- `Statement:` over a prefix-free domain, almost every fair-coin tape `w` has a `c` with every +`D`-description of every prefix of `w` fewer than `c` bits shorter than that prefix. -/ +theorem ae_incompressible (D : List Bool → Option (List Bool)) + (hD : PrefixFree {d | (D d).isSome}) : + ∀ᵐ w ∂fairTape, ∃ c, ∀ d x, D d = some x → w ∈ prefixCyl x → x.length < d.length + c := by + have hnull : fairTape (⋂ c, compressibleTapes D c) = 0 := + measure_iInter_le_pow_zero fairTape _ (fairTape_compressibleTapes_le D hD) + rw [ae_iff] + refine measure_mono_null (fun w hw => ?_) hnull + simp only [Set.mem_setOf_eq, not_exists, not_forall, not_lt] at hw + refine Set.mem_iInter.2 fun c => ?_ + obtain ⟨d, x, hDx, hw', hlen⟩ := hw c + exact ⟨d, x, hDx, hlen, hw'⟩ + +/-- `Statement:` the decoder sending every word `d` to `d ++ [false]`. -/ +def appendFalse : List Bool → Option (List Bool) := fun d => some (d ++ [false]) + +/-- `Statement:` `1/2 + 1/4 < 1` in `ENNReal`. -/ +theorem half_add_quarter_lt_one : (2⁻¹ : ENNReal) + 2⁻¹ ^ 2 < 1 := by + have e : (2⁻¹ : ENNReal) = ((2⁻¹ : NNReal) : ENNReal) := by simp + rw [e, ← ENNReal.coe_pow, ← ENNReal.coe_add, ← ENNReal.coe_one, ENNReal.coe_lt_coe] + norm_num + +-- Statement: CONTROL, drop prefix-freeness: under `appendFalse`, `compressibleTapes appendFalse 1` +-- exceeds the bound `2⁻¹` (it holds every tape with a `false` anywhere; the proof uses the subset +-- with one in the first two bits, measure 3/4). +example : ¬ fairTape (compressibleTapes appendFalse 1) ≤ 2⁻¹ ^ 1 ∧ + ¬ PrefixFree {d | (appendFalse d).isSome} := by + constructor + · have hsub : (prefixCyl [true, true])ᶜ ⊆ compressibleTapes appendFalse 1 := by + intro w hw + simp only [Set.mem_compl_iff, prefixCyl, Set.mem_setOf_eq, List.length_cons, + List.length_nil, not_forall] at hw + obtain ⟨i, hi, hne⟩ := hw + have hwi : w i = false := by + interval_cases i <;> simp_all + refine ⟨prefixOf w i, prefixOf w i ++ [false], rfl, by simp [prefixOf], ?_⟩ + intro j hj + have hj' : j < i + 1 := by simpa [prefixOf] using hj + rw [List.getElem_append] + split_ifs with h + · simp [prefixOf] + · have : j = i := by simp [prefixOf] at h; omega + subst this; simp [hwi] + intro hle + have h1 := measure_add_measure_compl (μ := fairTape) (prefixCyl_measurable [true, true]) + rw [measure_univ, fairTape_prefixCyl] at h1 + have h2 : (1 : ENNReal) ≤ 2⁻¹ ^ 2 + 2⁻¹ := by + calc (1 : ENNReal) = 2⁻¹ ^ [true, true].length + fairTape (prefixCyl [true, true])ᶜ := h1.symm + _ ≤ 2⁻¹ ^ 2 + fairTape (compressibleTapes appendFalse 1) := + add_le_add (le_of_eq (by simp)) (measure_mono hsub) + _ ≤ 2⁻¹ ^ 2 + 2⁻¹ := add_le_add le_rfl (by simpa using hle) + rw [add_comm] at h2 + exact absurd h2 (not_le.2 half_add_quarter_lt_one) + · intro h + have := h [] (by simp [appendFalse]) [false] (by simp [appendFalse]) (List.nil_prefix) + simp at this + +/-! ## § V. Prior art, outside the dependency closure + +A. Milovanov, `kolmogorov-complexity-lean` @7e71116 (Lean 4.35; not compared with our definitions). +Levin–Schnorr, uniform measure: `isMartinLofRandom_uniform_iff_le_KPPlain_cantorPrefix`, Martin-Löf +random iff `K(w↾n) ≥ n − c`, prefix-free `K`. Entropy rate, Bernoulli `p`: `tendsto_plainK_cantorPrefix_div` +(computable `p`, `0 < p < 1`, every Martin-Löf random tape; entropy in bits, ours in nats); almost-every +form, the Bernoulli case of Brudno's theorem, `measure_setOf_not_tendsto_plainK_cantorPrefix_div` (any +`p ≤ 1`). A rate alone does not give Martin-Löf randomness (standard, not proved here). Ergodic +measures: Hoyrup's effective Shannon–McMillan–Breiman (Cenzer–Porter, arXiv:2103.03971, p. 22, +Thm 32, retrieved 2026-11-07; primary: Hoyrup, STACS 2012, arXiv:1107.1149, not retrieved). -/ + +end ZeroParadox + +/-! ## Axiom Purity Check -/ + +section PurityCheck +open ZeroParadox + +#print axioms shannonEntropy +#print axioms negMulLog_inv_natCast +#print axioms avg_negMulLog_le +#print axioms avg_eq_inv_card +#print axioms avg_negMulLog_eq +#print axioms shannonEntropy_le_log +#print axioms shannonEntropy_eq_log_iff +#print axioms missingInfo +#print axioms missingInfo_nonneg +#print axioms missingInfo_eq_zero_iff +#print axioms missingInfo_eq_kl +#print axioms missingInfo_fin_eq_zero_iff +#print axioms eq_half_of_maxEntropy +#print axioms maximizer_admissible +#print axioms trials_eq_fairTape_of_maxEntropy +#print axioms maxEntropy_mlRandom_and_snap_ae +#print axioms prefixCyl_eq_pi +#print axioms prefixCyl_measurable +#print axioms fairTape_prefixCyl +#print axioms prefixOf +#print axioms mem_prefixCyl_iff +#print axioms shortWords +#print axioms mem_shortWords +#print axioms card_shortWords_le +#print axioms compressible_card +#print axioms PrefixFree +#print axioms prefix_of_mem_prefixCyl +#print axioms pairwise_disjoint_domCyl +#print axioms kraft_measure +#print axioms compressibleTapes +#print axioms fairTape_compressibleTapes_le +#print axioms ae_incompressible +#print axioms appendFalse +#print axioms half_add_quarter_lt_one + +end PurityCheck diff --git a/ZeroParadox/Information/SnapEpsilonZero.lean b/ZeroParadox/Information/SnapEpsilonZero.lean new file mode 100644 index 00000000..94d265cb --- /dev/null +++ b/ZeroParadox/Information/SnapEpsilonZero.lean @@ -0,0 +1,279 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): `snap_of_firstStep_MLRandom` instantiated on two carriers, the corner on `WithBot Ordinal` and the cover at ε₀ on `{0} ∪ {fixed points of ω^·}`, with an order isomorphism relating them. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Information.TwoRequirements +import ZeroParadox.Multihomed.BoundaryOrder +import ZeroParadox.Ordinal.Epsilon0MinMax +import ZeroParadox.Reals.OrderedField +import Mathlib.Tactic + +/-! +# The snap and ε₀ on two carriers: on `WithBot Ordinal` the first step lands at ↑0 and `up` carries it to ↑ε₀ (the corner); on `EpsilonOrZero` the first step is ε₀ (the cover) + +## Engineer's Take + +There was something about epsilon zero we hadn't quite wrapped up. What we needed was two specific things: an instantiation, and a very specific place in the die. These are two separate zoom levels, a maximum of one and a minimum of the other. + +--- + +## Formal Overview (AI-assisted) +§ I: `max` on a linear order with least element. § II: the corner, `WithBot Ordinal`. § III: the +cover, `EpsilonOrZero`. § IV: the iso between them. Each snap is one way, from hypotheses. +-/ + +set_option maxHeartbeats 400000 + +namespace ZeroParadox + +open ZPSemilattice + +/-! ## § I. A linear order with a least element, join `max` -/ + +/-- `Statement:` join `max`, ⊥ the given least element `b`; a definition, not an instance. -/ +abbrev linearMaxZPS (α : Type*) [LinearOrder α] (b : α) (hb : ∀ x, b ≤ x) : ZPSemilattice α where + join := max + bot := b + join_assoc := max_assoc + join_comm := max_comm + join_idem := max_self + bot_join := fun x => max_eq_right (hb x) + +/-- `Statement:` under `linearMaxZPS`, ZP-A's induced `<` is `α`'s own `<`. -/ +theorem linearMaxZPS_lt_iff {α : Type*} [LinearOrder α] (b : α) (hb : ∀ x, b ≤ x) (x y : α) : + @LT.lt α (@zpSemilatticeSup α (linearMaxZPS α b hb)).toLT x y ↔ x < y := by + show (max x y = y ∧ ¬ max y x = x) ↔ x < y + rw [max_eq_right_iff, max_eq_right_iff, not_le] + exact ⟨fun h => h.2, fun h => ⟨h.le, h⟩⟩ + +/-- `Statement:` so its covers are `α`'s own covers; both directions. -/ +theorem linearMaxZPS_covBy_iff {α : Type*} [LinearOrder α] (b : α) (hb : ∀ x, b ≤ x) (x y : α) : + @CovBy α (@zpSemilatticeSup α (linearMaxZPS α b hb)).toLT x y ↔ x ⋖ y := by + constructor + · rintro ⟨h1, h2⟩ + exact ⟨(linearMaxZPS_lt_iff b hb _ _).1 h1, fun c hc1 hc2 => + h2 ((linearMaxZPS_lt_iff b hb _ _).2 hc1) ((linearMaxZPS_lt_iff b hb _ _).2 hc2)⟩ + · rintro ⟨h1, h2⟩ + exact ⟨(linearMaxZPS_lt_iff b hb _ _).2 h1, fun c hc1 hc2 => + h2 ((linearMaxZPS_lt_iff b hb _ _).1 hc1) ((linearMaxZPS_lt_iff b hb _ _).1 hc2)⟩ + +/-- `Statement:` `BotHasFirstStep` under `linearMaxZPS` iff `HasFirstStep b` in `α`'s order. -/ +theorem linearMaxZPS_botHasFirstStep_iff {α : Type*} [LinearOrder α] (b : α) (hb : ∀ x, b ≤ x) : + @BotHasFirstStep α (linearMaxZPS α b hb) ↔ HasFirstStep b := + ⟨fun ⟨a, ha⟩ => ⟨a, (linearMaxZPS_covBy_iff b hb _ _).1 ha⟩, + fun ⟨a, ha⟩ => ⟨a, (linearMaxZPS_covBy_iff b hb _ _).2 ha⟩⟩ + +/-- `Statement:` if `b ⋖ a` and `w` is Martin-Löf random for `trials p hp` with `0 < p`, then +`snap_of_firstStep_MLRandom`'s conclusion holds under `linearMaxZPS`, and the run's `S 1` covers +`b` in `α`'s order and equals `a` (`axb1_gives_unique_target`). One way. -/ +theorem linearMaxZPS_snap_target {α : Type*} [LinearOrder α] (b : α) (hb : ∀ x, b ≤ x) + (a : α) (ha : b ⋖ a) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (w : ℕ → Bool) (hML : MLRandom (trials p hp) w) : + ∃ (φ : Bool → α) (hw : ∃ k, w k = true), + ((φ ∘ firedRun w hw) 0 = b ∧ (φ ∘ firedRun w hw) 1 ≠ (φ ∘ firedRun w hw) 0 ∧ + @IsStateSequence α (linearMaxZPS α b hb) (φ ∘ firedRun w hw)) ∧ + b ⋖ (φ ∘ firedRun w hw) 1 ∧ (φ ∘ firedRun w hw) 1 = a := by + obtain ⟨φ, hw, h⟩ := @snap_of_firstStep_MLRandom α (linearMaxZPS α b hb) + ((linearMaxZPS_botHasFirstStep_iff b hb).2 ⟨a, ha⟩) p hp hp0 w hML + have hcov : b ⋖ (φ ∘ firedRun w hw) 1 := (linearMaxZPS_covBy_iff b hb _ _).1 h.2.2 + exact ⟨φ, hw, h.1, hcov, (axb1_gives_unique_target b ⟨a, ha⟩).unique hcov ha⟩ + +/-! ## § II. The corner: `WithBot Ordinal`, the floor-below order of `BoundaryOrder.lean` -/ + +/-- `Statement:` `linearMaxZPS` on `WithBot Ordinal`, ⊥ of `WithBot Ordinal` as its ⊥. -/ +noncomputable abbrev phaseMaxZPS : ZPSemilattice (WithBot Ordinal.{0}) := + linearMaxZPS (WithBot Ordinal.{0}) ⊥ (fun _ => bot_le) + +/-- `Statement:` ⊥ of `WithBot Ordinal` has a first step under `phaseMaxZPS`. -/ +theorem phaseMaxZPS_botHasFirstStep : @BotHasFirstStep (WithBot Ordinal.{0}) phaseMaxZPS := + (linearMaxZPS_botHasFirstStep_iff _ _).2 ⟨_, phase_floor_covBy_snap⟩ + +/-- `Statement:` under `phaseMaxZPS`, if `w` is Martin-Löf random for `trials p hp` with `0 < p`, +some run `S` from the tape has `⊥ ⋖ S 1`, `S 1 = ↑0 ≠ ↑ε₀`, and `phaseUpAndOver.up (S 1) = ↑ε₀`. +One way. -/ +theorem phase_snap_of_MLRandom (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (w : ℕ → Bool) + (hML : MLRandom (trials p hp) w) : + ∃ (φ : Bool → WithBot Ordinal.{0}) (hw : ∃ k, w k = true), + (⊥ : WithBot Ordinal.{0}) ⋖ (φ ∘ firedRun w hw) 1 ∧ + (φ ∘ firedRun w hw) 1 = ((0 : Ordinal) : WithBot Ordinal) ∧ + (φ ∘ firedRun w hw) 1 ≠ ((epsilonZero : Ordinal) : WithBot Ordinal) ∧ + phaseUpAndOver.up ((φ ∘ firedRun w hw) 1) = ((epsilonZero : Ordinal) : WithBot Ordinal) := by + obtain ⟨φ, hw, -, hcov, h1⟩ := linearMaxZPS_snap_target (⊥ : WithBot Ordinal.{0}) + (fun _ => bot_le) _ phase_floor_covBy_snap p hp hp0 w hML + refine ⟨φ, hw, hcov, h1, ?_, ?_⟩ + · rw [h1]; exact phase_floor_snap_epsilon0_ne.1 + · rw [h1]; exact phaseUp_snap + +-- `Statement:` CONTROL: in `WithBot Ordinal`, `↑ε₀` does not cover ⊥ of `WithBot Ordinal` (`↑0` lies +-- between), so no run's first step lands there. +example : ¬ (⊥ : WithBot Ordinal.{0}) ⋖ ((epsilonZero : Ordinal) : WithBot Ordinal) := fun h => + h.2 (c := ((0 : Ordinal) : WithBot Ordinal)) (WithBot.bot_lt_coe _) + (WithBot.coe_lt_coe.2 (Ordinal.epsilon_pos 0)) + +/-! ## § III. The cover: `{o | o = 0 ∨ ω^o = o}`, join `max`, ⊥ = 0 of `Ordinal` -/ + +/-- `Statement:` the ordinals that are 0 or fixed by `α ↦ ω^α`, in `Ordinal`'s order. -/ +abbrev EpsilonOrZero : Type 1 := {o : Ordinal.{0} // o = 0 ∨ Ordinal.omega0 ^ o = o} + +/-- `Statement:` the point 0 of `Ordinal`, adjoined by the left disjunct. -/ +def epsilonOrZero_bot : EpsilonOrZero := ⟨0, Or.inl rfl⟩ + +/-- `Statement:` the point ε₀. -/ +noncomputable def epsilonOrZero_eps0 : EpsilonOrZero := ⟨Ordinal.epsilon 0, Or.inr epsilon0_is_fixedpoint⟩ + +/-- `Statement:` the point ε₁. -/ +noncomputable def epsilonOrZero_eps1 : EpsilonOrZero := + ⟨Ordinal.epsilon 1, Or.inr (Ordinal.omega0_opow_epsilon 1)⟩ + +/-- `Statement:` `epsilonOrZero_bot` is least. -/ +theorem epsilonOrZero_bot_le (x : EpsilonOrZero) : epsilonOrZero_bot ≤ x := + show (0 : Ordinal) ≤ x.1 from zero_le (a := x.1) + +/-- `Statement:` `linearMaxZPS` on `EpsilonOrZero`, with `epsilonOrZero_bot` as its ⊥. -/ +noncomputable abbrev epsilonOrZeroMaxZPS : ZPSemilattice EpsilonOrZero := + linearMaxZPS EpsilonOrZero epsilonOrZero_bot epsilonOrZero_bot_le + +/-- `Statement:` ε₀ covers 0 in `EpsilonOrZero`; the `SnapCannotBe.lean` § II example, named. -/ +theorem epsilonOrZero_bot_covBy_eps0 : epsilonOrZero_bot ⋖ epsilonOrZero_eps0 := by + refine ⟨Ordinal.epsilon_pos 0, ?_⟩ + rintro ⟨c, hc | hc⟩ h0 hε + · exact (ne_of_gt (show (0 : Ordinal) < c from h0)) hc + · exact nothing_between_is_a_step c hε hc + +/-- `Statement:` ⊥ of `EpsilonOrZero` has a first step under `epsilonOrZeroMaxZPS`. -/ +theorem epsilonOrZeroMaxZPS_botHasFirstStep : @BotHasFirstStep EpsilonOrZero epsilonOrZeroMaxZPS := + (linearMaxZPS_botHasFirstStep_iff _ _).2 ⟨_, epsilonOrZero_bot_covBy_eps0⟩ + +/-- `Statement:` under `epsilonOrZeroMaxZPS`, if `w` is Martin-Löf random for `trials p hp` with +`0 < p`, some run `S` from the tape has `S 1` covering 0 with value ε₀ ≠ 0. One way. -/ +theorem epsilonOrZero_snap_of_MLRandom (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (w : ℕ → Bool) + (hML : MLRandom (trials p hp) w) : + ∃ (φ : Bool → EpsilonOrZero) (hw : ∃ k, w k = true), + epsilonOrZero_bot ⋖ (φ ∘ firedRun w hw) 1 ∧ + ((φ ∘ firedRun w hw) 1).1 = Ordinal.epsilon 0 ∧ ((φ ∘ firedRun w hw) 1).1 ≠ (0 : Ordinal) := by + obtain ⟨φ, hw, -, hcov, h1⟩ := linearMaxZPS_snap_target epsilonOrZero_bot epsilonOrZero_bot_le _ + epsilonOrZero_bot_covBy_eps0 p hp hp0 w hML + exact ⟨φ, hw, hcov, congrArg Subtype.val h1, by rw [h1]; exact epsilon0_ne_zero⟩ + +-- `Statement:` CONTROL, non-vacuity: `EpsilonOrZero` holds ε₁, distinct from 0 and ε₀ and above ε₀; +-- ε₁ does not cover 0, and 0 has exactly one cover. +example : epsilonOrZero_eps1 ≠ epsilonOrZero_bot ∧ epsilonOrZero_eps0 < epsilonOrZero_eps1 ∧ + ¬ epsilonOrZero_bot ⋖ epsilonOrZero_eps1 ∧ ∃! a : EpsilonOrZero, epsilonOrZero_bot ⋖ a := by + have h01 : Ordinal.epsilon.{0} 0 < Ordinal.epsilon 1 := + Ordinal.veblen_right_strictMono 1 zero_lt_one + refine ⟨fun h => (Ordinal.epsilon_pos 1).ne' (congrArg Subtype.val h), h01, + fun h => h.2 epsilonOrZero_bot_covBy_eps0.1 h01, ?_⟩ + exact axb1_gives_unique_target epsilonOrZero_bot ⟨_, epsilonOrZero_bot_covBy_eps0⟩ + +/-! ## § IV. The relation: `EpsilonOrZero` ≃o the landings of `phaseUpAndOver.up` -/ + +/-- `Statement:` the closed points (landings) of `phaseUpAndOver.up` in `WithBot Ordinal`. -/ +abbrev PhaseLanding : Type 1 := {x : WithBot Ordinal.{0} // phaseUpAndOver.up x = x} + +/-- `Statement:` on `↑o`, `phaseUpAndOver.up` is `↑(nfp (ω^·) o)`. -/ +theorem phaseUp_coe (o : Ordinal.{0}) : phaseUpAndOver.up (o : WithBot Ordinal) = + ((Ordinal.nfp (fun a => Ordinal.omega0 ^ a) o : Ordinal) : WithBot Ordinal) := rfl + +/-- `Statement:` `phaseUpAndOver.up` fixes ⊥ of `WithBot Ordinal`. -/ +theorem phaseUp_bot : phaseUpAndOver.up (⊥ : WithBot Ordinal.{0}) = ⊥ := rfl + +open Classical in +/-- `Statement:` 0 of `Ordinal` to ⊥ of `WithBot Ordinal`, each fixed point `o` to `↑o`. -/ +noncomputable def epsilonOrZeroToLanding : EpsilonOrZero → PhaseLanding := fun x => + if h : x.1 = 0 then ⟨⊥, phaseUp_bot⟩ + else ⟨(x.1 : WithBot Ordinal), by rw [phaseUp_coe, Ordinal.nfp_eq_self (x.2.resolve_left h)]⟩ + +/-- `Statement:` `epsilonOrZeroToLanding` is strictly monotone. -/ +theorem epsilonOrZeroToLanding_strictMono : StrictMono epsilonOrZeroToLanding := by + intro a b hab + have hb : b.1 ≠ 0 := (lt_of_le_of_lt (zero_le (a := a.1)) hab).ne' + by_cases ha : a.1 = 0 + · simp only [epsilonOrZeroToLanding, ha, hb, ↓reduceDIte] + exact WithBot.bot_lt_coe _ + · simp only [epsilonOrZeroToLanding, ha, hb, ↓reduceDIte] + exact WithBot.coe_lt_coe.2 hab + +/-- `Statement:` `epsilonOrZeroToLanding` is onto. -/ +theorem epsilonOrZeroToLanding_surjective : Function.Surjective epsilonOrZeroToLanding := by + rintro ⟨x, hx⟩ + induction x using WithBot.recBotCoe with + | bot => exact ⟨epsilonOrZero_bot, by simp [epsilonOrZeroToLanding, epsilonOrZero_bot]⟩ + | coe o => + rw [phaseUp_coe] at hx + have ha : Ordinal.nfp (fun a => Ordinal.omega0 ^ a) o = o := WithBot.coe_injective hx + have hfp : Ordinal.omega0 ^ o = o := by + have := Ordinal.nfp_fp (Ordinal.isNormal_opow Ordinal.one_lt_omega0) o + rwa [ha] at this + have ho : o ≠ 0 := fun h => bot_is_not_a_step (h ▸ hfp) + exact ⟨⟨o, Or.inr hfp⟩, by simp [epsilonOrZeroToLanding, ho]⟩ + +/-- `Statement:` the order isomorphism `EpsilonOrZero ≃o PhaseLanding`. -/ +noncomputable def epsilonOrZeroIsoLanding : EpsilonOrZero ≃o PhaseLanding := + StrictMono.orderIsoOfSurjective epsilonOrZeroToLanding epsilonOrZeroToLanding_strictMono + epsilonOrZeroToLanding_surjective + +/-- `Statement:` the iso sends 0 of `Ordinal` to ⊥ of `WithBot Ordinal` (not to `↑0`) and ε₀ to +`↑ε₀`, and carries the cover `0 ⋖ ε₀` to a cover among the landings. -/ +theorem epsilonOrZeroIsoLanding_spec : + (epsilonOrZeroIsoLanding epsilonOrZero_bot).1 = ⊥ ∧ + (epsilonOrZeroIsoLanding epsilonOrZero_eps0).1 = + ((Ordinal.epsilon 0 : Ordinal) : WithBot Ordinal) ∧ + epsilonOrZeroIsoLanding epsilonOrZero_bot ⋖ epsilonOrZeroIsoLanding epsilonOrZero_eps0 := by + refine ⟨?_, ?_, (apply_covBy_apply_iff epsilonOrZeroIsoLanding).2 epsilonOrZero_bot_covBy_eps0⟩ + · show (epsilonOrZeroToLanding epsilonOrZero_bot).1 = ⊥ + simp [epsilonOrZeroToLanding, epsilonOrZero_bot] + · show (epsilonOrZeroToLanding epsilonOrZero_eps0).1 = _ + have h : (epsilonOrZero_eps0.1 : Ordinal) ≠ 0 := (Ordinal.epsilon_pos 0).ne' + simp only [epsilonOrZeroToLanding, h, ↓reduceDIte] + rfl + +-- `Statement:` CONTROL: the inclusion `o ↦ ↑o` sends 0 of `Ordinal` to `↑0`, not to ⊥ of +-- `WithBot Ordinal`, and does not preserve the cover: `↑1` lies between `↑0` and `↑ε₀`. +example : ¬ ((0 : Ordinal.{0}) : WithBot Ordinal) ⋖ ((Ordinal.epsilon 0 : Ordinal) : WithBot Ordinal) := + fun h => h.2 (c := ((1 : Ordinal) : WithBot Ordinal)) (WithBot.coe_lt_coe.2 zero_lt_one) + (WithBot.coe_lt_coe.2 (lt_trans Ordinal.one_lt_omega0 (Ordinal.omega0_lt_epsilon 0))) + +/-- `Statement:` (i) `up` sends the snap `↑0` to `↑ε₀`, and ε₀ is the tower's supremum; (ii) ε₀, +the cover of 0 in `EpsilonOrZero`, is the least fixed point of `ω^·`; (iii) the iso sends that +cover to `up`'s landing from the snap. `Reading:` the supremum face and the least-fixed-point face +of `epsilon0_min_eq_max`, one per carrier, related by the iso; neither face replaces the other. -/ +theorem snap_epsilon0_two_faces : + (phaseUpAndOver.up (phaseEquivWithBot snap) = ((epsilonZero : Ordinal.{0}) : WithBot Ordinal) ∧ + epsilonZero = ⨆ n : ℕ, fundamentalSeq.{0} n) ∧ + (epsilonOrZero_bot ⋖ epsilonOrZero_eps0 ∧ epsilonOrZero_eps0.1 = epsilonZero ∧ + IsLeast {o : Ordinal.{0} | Ordinal.omega0 ^ o = o} epsilonZero.{0}) ∧ + (epsilonOrZeroIsoLanding epsilonOrZero_eps0).1 = phaseUpAndOver.up (phaseEquivWithBot snap) := + ⟨⟨phaseUp_snap, epsilon0_min_eq_max.{0, 0}.1⟩, + ⟨epsilonOrZero_bot_covBy_eps0, rfl, epsilon0_min_eq_max.{0, 0}.2⟩, + epsilonOrZeroIsoLanding_spec.2.1.trans phaseUp_snap.symm⟩ + +end ZeroParadox + +section PurityCheck +open ZeroParadox + +#print axioms linearMaxZPS +#print axioms linearMaxZPS_lt_iff +#print axioms linearMaxZPS_covBy_iff +#print axioms linearMaxZPS_botHasFirstStep_iff +#print axioms linearMaxZPS_snap_target +#print axioms phaseMaxZPS +#print axioms phaseMaxZPS_botHasFirstStep +#print axioms phase_snap_of_MLRandom +#print axioms EpsilonOrZero +#print axioms epsilonOrZero_bot +#print axioms epsilonOrZero_eps0 +#print axioms epsilonOrZero_eps1 +#print axioms epsilonOrZero_bot_le +#print axioms epsilonOrZeroMaxZPS +#print axioms epsilonOrZero_bot_covBy_eps0 +#print axioms epsilonOrZeroMaxZPS_botHasFirstStep +#print axioms epsilonOrZero_snap_of_MLRandom +#print axioms PhaseLanding +#print axioms phaseUp_coe +#print axioms phaseUp_bot +#print axioms epsilonOrZeroToLanding +#print axioms epsilonOrZeroToLanding_strictMono +#print axioms epsilonOrZeroToLanding_surjective +#print axioms epsilonOrZeroIsoLanding +#print axioms epsilonOrZeroIsoLanding_spec +#print axioms snap_epsilon0_two_faces + +end PurityCheck diff --git a/ZeroParadox/Information/Surprisal.lean b/ZeroParadox/Information/Surprisal.lean index 8af28c29..589550e8 100644 --- a/ZeroParadox/Information/Surprisal.lean +++ b/ZeroParadox/Information/Surprisal.lean @@ -40,6 +40,8 @@ namespace ZeroParadox /-! ## Setup: Binary States (AX-B1) -/ +-- [ZP port] Lean 4.35: Mathlib's `Fintype` deriving handler needs the pre-4.35 defeq transparency. +set_option backward.isDefEq.respectTransparency false in -- [ZP-CUSTOM] replaces: Fin 2 | reason: ZPC is self-contained (no ZPB import); BinaryState is a local copy of the same free-inductive encoding used by OntologicalStates in ZPB. Fin 2 would import ℕ arithmetic into an information-theoretic file whose proofs should not depend on it. /-- The two ontological states: non-existence (⊥) and existence. A free inductive type — no natural-number dependency. -/ @@ -162,18 +164,26 @@ theorem t2_diverges : ∀ M : ℝ, ∃ n : ℕ, M < circPartial n := by /-! ## Section III-B: L-INF — Unbounded Surprisal -/ -/-- L-INF — Unbounded Surprisal of ⊥. +/-- L-INF — Unbounded Surprisal, in the depth chart. - The surprisal I(n) = n at ball-hierarchy depth n is unbounded: for any finite - bound M, there exist depths n with I(n) > M. ⊥ of `MachinePhase` (c₀) corresponds - to the limit point 0 ∈ Q₂ — the limit of the binary ball hierarchy at infinite - depth. At this limit, surprisal is not finite. + `Statement:` the surprisal I(n) = n at ball-hierarchy depth n is unbounded above: for any + real bound M, some depth n has I(n) > M. - Formal content: surprisal is unbounded above. - Semantic content: ⊥ has unbounded surprisal — it is the compressed limit of - all possible binary programs. No finite program bounds its informational content, - so no finite external interpreter can hold ⊥ as a static description. This is - one argument for DA-1's precondition (ZP-E, Path 2), and it does not derive it. + "Surprisal at ⊥" has two charts, and no equation joins them: + * Depth chart (this theorem): every depth n has a finite surprisal, I(n) = n, and no + finite bound holds of all of them. No depth has infinite surprisal. + * Point chart: at the floor 0 of Q₂ the complexity is ⊤ (`infinitude_forces_infinite_complexity` + at `q2InfinitudeFloor`, `ZeroParadox/Valuation/InfinitudeFloor.lean`), the supremum of the + climbing complexities of the members 2ⁿ⁺¹ (`infinite_complexity_is_infinitude_of_zeros`; + `cxQ2_two_pow`: the complexity of 2ᵏ is k). + ⊥ of `MachinePhase` (c₀) corresponds to that limit point 0 of Q₂, the limit of the binary + ball hierarchy; the correspondence is the framework's reading, not an identity (c₀ and 0 + are elements of different carriers). + + `Reading:` ⊥ is the compressed limit of all possible binary programs. No finite program + bounds its informational content, so no finite external interpreter can hold ⊥ as a + static description. This is one argument for DA-1's precondition (ZP-E, Path 2), and it + does not derive it. Note: the step from unbounded surprisal to executing is not a consequence of L-INF and is not DA-1: it is a bridge principle of its own, which the framework @@ -225,10 +235,10 @@ mixture over both. This is the *information-theoretic* forcing of the discrete b mechanism from the order forcing (`t_snap_derived`), the incompressibility forcing (`l_inf`), and the self-execution route (ZP-K). Every route constrains the same transition — its shape, not its occurrence; none of the four makes the step happen, and `tsnap_holds_but_nothing_moves` (`Order/Snap.lean`) exhibits a model in which -the order route holds and nothing moves. They also do not all rest on the same kind of ground — the README states each one's requirement alongside its witness, and the self-execution -route's requirement is the load-bearing one: `da1_closed_concrete` proves ⊥ is the unique Quine atom of -MachinePhase and mentions no `Code` and no execution, so "⊥ must execute itself" rests on ZP-K's -`KleeneStructure` commitment rather than on that theorem. -/ +the order route holds and nothing moves. The routes rest on different ground (the README gives each requirement +beside its witness), and the self-execution route's is load-bearing: `da1_closed_concrete` proves ⊥ is the unique +Quine atom of MachinePhase and mentions no `Code` and no execution, so the retired "⊥ must execute itself" rests on +no theorem: that ⊥ executes is the occurrence commitment; that, if it does, nothing outside it executes it is DA-1 Path 1. -/ /-- No half-state: every ontological state is `null` or `exist`; there is no third, intermediate value. -/ theorem binaryState_exhaustive (s : BinaryState) : s = nullSt ∨ s = firstSt := by @@ -243,7 +253,7 @@ theorem binaryState_card_two : Fintype.card BinaryState = 2 := by decide theorem distP_support_singleton : distP.support = {nullSt} := by rw [distP, PMF.support_pure] -/-- The first-atomic-state distribution is likewise a point mass, supported on the single outcome `exist`. -/ +/-- The distribution `distQ`, at the state `firstSt` (the `exist` constructor of `BinaryState`, not `null`), is likewise a point mass, supported on the single outcome `exist`. -/ theorem distQ_support_singleton : distQ.support = {firstSt} := by rw [distQ, PMF.support_pure] @@ -272,15 +282,15 @@ non-pureness; **no construction supplying its hypotheses was located in this cor `ZeroParadox/Reals/MarkovSpectralGap.lean`, both of which build a specific two-point distribution for their own purpose rather than the general constructor). Stated as a dated search result, not as a universal negative. -⚠ **Not missing from Mathlib** — `PMF.uniformOfFinset` with `PMF.support_uniformOfFinset` -(`Mathlib/Probability/Distributions/Uniform.lean`) constructs the same thing directly. It is cited -rather than swapped in: that route needs a heavier import and there is no purity gain (both carry -`Classical.choice`, measured). - -⚠ **It is NOT stronger than what is proved here, and a first draft of this paragraph said it was.** The -three conjuncts below give `p.support = {x, y}` **exactly** — the two memberships supply `⊇` and the -third supplies `⊆` — so the `⊆` form understates this theorem rather than being understated by -Mathlib's. -/ +⚠ **Mathlib's uniform distribution on a finset is a `Measure`, not a `PMF`, at the pin.** +`MeasureTheory.Measure.uniformOfFinset` (`Mathlib/Probability/Distributions/Uniform.lean`) is a +`Measure α` and carries `Classical.choice` (measured); `PMF.support_uniformOfFinset` is a deprecated +alias of a lemma about it. A constant `PMF.uniformOfFinset` was not located as of 2026-11-07, searched +by `#check` with that file imported and by a grep of the pinned Mathlib for `uniformOfFinset`, which +hits that file only. So that route does not supply the `PMF` constructed here. + +The three conjuncts below give `p.support = {x, y}` **exactly** — the two memberships supply `⊇` and +the third supplies `⊆`. -/ theorem exists_spread_pmf {α : Type*} (x y : α) : ∃ p : PMF α, x ∈ p.support ∧ y ∈ p.support ∧ p.support ⊆ {x, y} := by have hle : (1/2 : NNReal) ≤ 1 := by norm_num diff --git a/ZeroParadox/Information/Surprisal.md b/ZeroParadox/Information/Surprisal.md index 58f00de8..2ce95a6d 100644 --- a/ZeroParadox/Information/Surprisal.md +++ b/ZeroParadox/Information/Surprisal.md @@ -34,7 +34,8 @@ doing all the work and must not be dropped when the sentence is quoted. `injective_forces_confined_support_subsingleton` is Mathlib's `Set.Subsingleton.preimage` (`Mathlib/Data/Set/Image.lean`) composed with a singleton; the proof body is the same argument (composed with `Set.Subsingleton.anti`). It is not swapped in because the statement mentions `PMF`, and -`#print axioms` follows the STATEMENT — both routes measure `[propext, Classical.choice, Quot.sound]`, so +`#print axioms` follows the statement as well as the proof, so what the statement's constants carry is in +every route's footprint — both routes measure `[propext, Classical.choice, Quot.sound]`, so there is no purity gain, and the hand proof reads locally. Same verdict as the `CovBy` precedent: keep the hand proof, cite the standard name. @@ -54,7 +55,14 @@ this object it is checkable rather than a framing. ⚠ **The necessity half — *"it has to"* — is NOT proved and is not claimed.** What is proved is that on this object both readings do hold at once. Whether a boundary of this kind *cannot* run one direction only -is an open no-go, recorded in `.claude-local/notes/future-research/concurrent_poles_2026-08-06.md`. +would be a no-go theorem, and this file does not attempt it. A theorem proving or refuting it was not +located as of 2026-11-01 in `ZeroParadox/`, searched as follows: three phrasings over its `.lean` and +`.md` files, root `.md` files not included ("one direction only" / "cannot run one direction"; +"one-directional" / "runs one way"; "both readings hold" / "concurrent"). The hits +on this question are this paragraph, the fence in `Surprisal.lean`, and the same fence at +`repr_spread_source_certain_target` (`ZeroParadox/Ordinal/PricedInterface.lean`); other hits, among +them `occurrence_semidecidable_nonoccurrence_not`, `four_corners_exhaustive` and `InfinitudeFloor.lean` +§ VI, concern other one-way questions and neither prove nor refute this one. **Prior art.** Mathlib's `PMF.map_const : p.map (Function.const α b) = pure b` (`Mathlib/Probability/ProbabilityMassFunction/Constructions.lean`) is the **globally constant** case. One @@ -162,7 +170,8 @@ fails, and `f_snap_impossible` carries no Archimedean hypothesis). Both are true wanted. ⚠ **FENCE 5 — the p-adic route is a DIFFERENT non-Archimedean-ness and is not this one.** Khrennikov's -ℚ_p-valued probability (survey: `.claude-local/papers/dragovich_padic_physics_2009_0904.4205.pdf` § 10, +ℚ_p-valued probability (survey: Dragovich, Khrennikov, Kozyrev and Volovich, *On p-Adic Mathematical +Physics*, arXiv:0904.4205, § 10, "Q_p-valued Probability") replaces the **topology** of frequency stabilisation, not the **order**. `ℚ_[p]` is not an ordered field and its absolute value is real-valued with an Archimedean value group, so "infinitely slim but non-zero" is not expressible there at all. The corpus's home for the Ostrowski sense @@ -190,7 +199,7 @@ So the capsule's content is **the geometric series test holds in an ordered fiel Archimedean.** Bibliographic data is confirmed twice over — the reference lists of *Completeness of Ordered Fields and a Trio of Classical Series Tests* (Abstr. Appl. Anal. 2016, art. 6023273) and *Normed Algebras and the Geometric Series Test* (Surveys in Math. and its Appl. **12** (2017), 203-217, ref. -[10]), both in `.claude-local/papers/`, agree on volume 46, 2015, pp. 139-141, MR3361762. +[10]), agree on volume 46, 2015, pp. 139-141 (the 2017 list adds MR3361762). **The delta, stated exactly.** Theirs is the **series** form (∑ rⁿ converges for `0 < r < 1`); this file's is the **sequence** form (`rⁿ → 0`, with `r = 1 - p`). In an ordered field the two are linked by the diff --git a/ZeroParadox/Information/TwoRequirements.lean b/ZeroParadox/Information/TwoRequirements.lean new file mode 100644 index 00000000..66305321 --- /dev/null +++ b/ZeroParadox/Information/TwoRequirements.lean @@ -0,0 +1,895 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): a first step at ⊥ of a ZP-A semilattice and a typical tape, as two hypotheses giving the snap's cover and its slot-chart firing (`hw`). Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Information.Disjunctive +import ZeroParadox.Reals.OrderedField +import Mathlib.Probability.StrongLaw +import Mathlib.Analysis.Real.OfDigits +import Mathlib.Order.Filter.EventuallyConst +import Mathlib.Tactic + +set_option maxHeartbeats 400000 + +/-! +# Two requirements: a first step at ⊥ of `L`, and a typical tape + +Two HYPOTHESES, neither discharged: `BotHasFirstStep L`, a cover of ⊥ of a `ZPSemilattice L` in +ZP-A's induced order (AX-B1's form), and a tape typical for `trials p hp`, in three forms: +zero-block typical, Martin-Löf random (implies the first, § II), frequency of `true` tending to +`p`. § I–III: with `0 < p` they give `t_snap_given_cover`'s full conclusion. § IV: binary expansion +sends a tape to a dyadic rational iff the tape is eventually constant. +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. + +--- +-/ + +namespace ZeroParadox + +open MeasureTheory ProbabilityTheory Filter ZPSemilattice + +/-! ## § I. Two hypotheses, one snap + +`BotHasFirstStep` constrains the carrier `L`; `ZeroBlockTypical` constrains one tape. `φ : Bool → L` +is built from the cover's witness, and no map from ⊥ of `L` to a tape is claimed. -/ + +/-- `Statement:` ⊥ of `L` has a first step (a cover) in ZP-A's induced order, `zpSemilatticeSup`. +`Reading:` AX-B1's `HasFirstStep` form, carried as a hypothesis, never as a field. -/ +def BotHasFirstStep (L : Type*) [ZPSemilattice L] : Prop := + letI := zpSemilatticeSup L; HasFirstStep (bot : L) + +/-- `Statement:` the tape `w` avoids every zero-block test for `trials p hp` (`AvoidsTests`). -/ +def ZeroBlockTypical (p : NNReal) (hp : p ≤ 1) (w : ℕ → Bool) : Prop := + AvoidsTests (ZeroBlockTest (trials p hp)) w + +/-- `Statement:` a tape that fires infinitely often fires at some stage. -/ +theorem fires_once_of_mem_limsup {w : ℕ → Bool} (h : w ∈ Filter.limsup fires Filter.atTop) : + ∃ k, w k = true := by + rw [mem_limsup_iff_frequently_mem] at h + obtain ⟨k, -, hk⟩ := h.forall_exists_of_atTop 0 + exact ⟨k, hk⟩ + +/-- `Statement:` if ⊥ of `L` has a first step and the tape `w` fires at some stage (`hw`), some +`φ : Bool → L` makes `S := φ ∘ firedRun w hw` start at ⊥ of `L`, step at index 1, be a state +sequence, and carry `t_snap_given_cover`'s conclusion (the triple and `⊥ ⋖ S 1`). One way. The +cover `hcov` comes only through `φ true`, the cover's witness (`hcov_iff_phi_cover`). -/ +theorem snap_of_firstStep_fires_once {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (w : ℕ → Bool) (hw : ∃ k, w k = true) : + ∃ φ : Bool → L, + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := by + obtain ⟨a, ha⟩ := hR1 + let φ : Bool → L := fun b => if b then a else bot + have hφ1 : φ true ≠ bot := by + letI := zpSemilatticeSup L + exact fun h => ha.1.ne h.symm + refine ⟨φ, ?_⟩ + intro S + obtain ⟨hS0, hS1, hSeq, -⟩ := t_snap_of_fires_once φ rfl hφ1 w hw + have hS1a : S 1 = a := by + show φ (firedRun w hw 1) = a + rw [(firedRun_spec w hw).2 0]; rfl + have hcov : letI := zpSemilatticeSup L; S 0 ⋖ S 1 := by + have e0 : S 0 = bot := hS0 + rw [e0, hS1a]; exact ha + exact ⟨⟨hS0, hS1, hSeq⟩, t_snap_given_cover S hS0 hS1 hcov⟩ + +/-- `Statement:` if ⊥ of `L` has a first step and `w` is zero-block typical for `trials p hp` with +`0 < p`, then `w` fires (`hw`) and `snap_of_firstStep_fires_once`'s conclusion holds. One way. +`Reading:` CARRIER: the occurrence commitment's slot-chart hypothesis `hw` comes from typicality of +one tape, the cover from AX-B1's form on `L`; neither is discharged, and a firing is not proved to +be an execution event (`ZeroParadox/Order/Snap.lean`). -/ +theorem snap_of_two_requirements {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (w : ℕ → Bool) (hR2 : ZeroBlockTypical p hp w) : + ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := by + obtain ⟨φ, h⟩ := snap_of_firstStep_fires_once hR1 w + (fires_once_of_mem_limsup (fires_io_of_avoids p hp hp0 _ (fun _ h => h) w hR2)) + exact ⟨φ, _, h⟩ + +/-- `Statement:` for a FIXED `φ` with `φ false = ⊥`, the run's `hcov` holds iff `φ true` covers ⊥ of +`L`; both directions. -/ +theorem hcov_iff_phi_cover {L : Type*} [ZPSemilattice L] (φ : Bool → L) + (hφ0 : φ false = bot) (w : ℕ → Bool) (hw : ∃ k, w k = true) : + (letI := zpSemilatticeSup L; (φ ∘ firedRun w hw) 0 ⋖ (φ ∘ firedRun w hw) 1) ↔ + (letI := zpSemilatticeSup L; (bot : L) ⋖ φ true) := by + have h0 : (φ ∘ firedRun w hw) 0 = bot := by simp [(firedRun_spec w hw).1, hφ0] + have h1 : (φ ∘ firedRun w hw) 1 = φ true := by simp [(firedRun_spec w hw).2 0] + rw [h0, h1] + +/-- `Statement:` `BotHasFirstStep L` iff some `φ` has `φ false = ⊥` and `⊥ ⋖ φ true`. -/ +theorem botHasFirstStep_iff_exists_phi {L : Type*} [ZPSemilattice L] : + BotHasFirstStep L ↔ + ∃ φ : Bool → L, φ false = bot ∧ (letI := zpSemilatticeSup L; (bot : L) ⋖ φ true) := by + constructor + · rintro ⟨a, ha⟩; exact ⟨fun b => if b then a else bot, rfl, ha⟩ + · rintro ⟨φ, -, h⟩; exact ⟨φ true, h⟩ + +/-- `Statement:` `NNReal` with join `max` and ⊥ = 0 of `NNReal`; a definition, not an instance. -/ +abbrev nnrealMaxZPS : ZPSemilattice NNReal where + join := max + bot := 0 + join_assoc := max_assoc + join_comm := max_comm + join_idem := max_self + bot_join := fun _ => max_eq_right zero_le + +/-- `Statement:` the zero-block typical tapes include the all-`true` tape at every `p ≤ 1`; the +`example` in `ZeroParadox/Information/CrossingTrials.lean` § VI, named. -/ +theorem allTrue_zeroBlockTypical (p : NNReal) (hp : p ≤ 1) : + ZeroBlockTypical p hp (fun _ => true) := by + rintro U ⟨hμ, f, -, hf⟩ hmem + have h1 := hμ 1 + rw [hf 1] at h1 + have hm : (fun _ => true : ℕ → Bool) ∈ zeroBlock (f 1).1 (f 1).2 := by + rw [← hf 1]; exact Set.mem_iInter.1 hmem 1 + rcases Nat.eq_zero_or_pos (f 1).2 with h0 | hpos + · have : zeroBlock (f 1).1 (f 1).2 = Set.univ := by + ext w; simp [zeroBlock, h0] + rw [this, measure_univ] at h1 + norm_num at h1 + · have := hm (f 1).1 (by simp [Finset.mem_Ico]; omega) + simp at this + +section NNRealControl + +attribute [local instance] nnrealMaxZPS + +/-- `Statement:` under `nnrealMaxZPS`, ZP-A's induced `<` is `NNReal`'s own `<`. -/ +theorem nnreal_zp_lt_iff (x y : NNReal) : + @LT.lt NNReal (zpSemilatticeSup NNReal).toLT x y ↔ x < y := by + show (max x y = y ∧ ¬ max y x = x) ↔ x < y + rw [max_eq_right_iff, max_eq_right_iff, not_le] + exact ⟨fun h => h.2, fun h => ⟨h.le, h⟩⟩ + +/-- `Statement:` CONTROL, drop the first step: ⊥ of `NNReal` under `max` has no cover. -/ +theorem nnreal_not_botHasFirstStep : ¬ BotHasFirstStep NNReal := by + rintro ⟨a, ha⟩ + have h0a : (0 : NNReal) < a := (nnreal_zp_lt_iff _ _).1 ha.1 + exact ha.2 ((nnreal_zp_lt_iff _ _).2 (half_pos h0a)) ((nnreal_zp_lt_iff _ _).2 (half_lt_self h0a)) + +-- Statement: CONTROL, drop the first step: on `NNReal` under `max` the all-`true` tape is zero-block +-- typical at `p = 1/2`, and for every `φ` and firing proof the run's `S 1` does not cover ⊥. +example : ZeroBlockTypical (1/2) (by norm_num) (fun _ => true) ∧ + ∀ (φ : Bool → NNReal) (hw : ∃ k, (fun _ => true : ℕ → Bool) k = true), + ¬ @CovBy NNReal (zpSemilatticeSup NNReal).toLT bot ((φ ∘ firedRun (fun _ => true) hw) 1) := + ⟨allTrue_zeroBlockTypical _ _, fun _ _ h => nnreal_not_botHasFirstStep ⟨_, h⟩⟩ + +end NNRealControl + +-- Statement: CONTROL, drop typicality: for `0 < p ≤ 1` the all-`false` tape is not zero-block +-- typical, and it never fires, so no `hw` exists for it. +example (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + ¬ ZeroBlockTypical p hp (fun _ => false) ∧ ¬ ∃ k, (fun _ => false : ℕ → Bool) k = true := by + refine ⟨?_, fun ⟨_, h⟩ => Bool.false_ne_true h⟩ + obtain ⟨U, hU, hUeq⟩ := zeroBlockTest_silentFrom p hp hp0 0 + have hmem : (fun _ => false : ℕ → Bool) ∈ ⋂ m, U m := by + rw [hUeq]; exact fun _ _ => rfl + exact fun h => h U hU hmem + +/-- `Statement:` `Bool` with join `||` and ⊥ = `false`; a definition, not an instance. -/ +abbrev boolOrZPS : ZPSemilattice Bool where + join := (· || ·) + bot := false + join_assoc := Bool.or_assoc + join_comm := Bool.or_comm + join_idem := Bool.or_self + bot_join := Bool.false_or + +section BoolControl + +attribute [local instance] boolOrZPS + +/-- `Statement:` CONTROL, the two-element carrier: under `boolOrZPS`, `true` covers ⊥ = `false`. -/ +theorem bool_botHasFirstStep : BotHasFirstStep Bool := + ⟨true, ⟨⟨rfl, by decide⟩, fun c h1 h2 => by + cases c + · exact h1.2 rfl + · exact h2.2 rfl⟩⟩ + +end BoolControl + +-- Statement: CONTROL, `Unit`: under any `ZPSemilattice Unit`, ⊥ has no first step. +example [ZPSemilattice Unit] : ¬ BotHasFirstStep Unit := by + rintro ⟨a, ha⟩ + letI := zpSemilatticeSup Unit + exact @LT.lt.ne Unit (zpSemilatticeSup Unit).toPreorder _ _ ha.1 (Subsingleton.elim _ _) + +/-! ## § II. Martin-Löf randomness, defined locally + +Not located in the pinned Mathlib as of 2026-11-06 (grep of `.lake/packages/mathlib/Mathlib` for +`martin.?l`, `kurtz`, case-insensitive: no hit). Prior art outside the dependency closure: +`ZeroParadox/Information/CrossingTrials.md`, Prior art (Lean: Freer `algorithmic-randomness`, +Milovanov; paper: Reimann–Slaman, Thm 4.4). Tests list cylinders by a computable `g` with no access +to `μ`: blind (Hippocratic) Martin-Löf randomness (Bienvenu, Hölzl, Porter, Shafer, NDJFL 58(3) 2017, +arXiv:1310.5133, Def 2.8; Kjos-Hanssen, arXiv:1408.2850, Def 2.1; Thm 6.2, p. 9, proves it coincides +with ordinary randomness for Bernoulli `μ_p`; that `trials p hp` is his `μ_p` is not proved here). It +implies zero-block typical; the converse fails at `p = 1/2`, at the all-`true` tape. -/ + +/-- `Statement:` the tapes extending the finite word `l` (a prefix cylinder). -/ +def prefixCyl (l : List Bool) : Set (ℕ → Bool) := {x | ∀ i (h : i < l.length), x i = l[i]} + +/-- `Statement:` `U` is a Martin-Löf test for `μ`: level `m` has measure at most `2⁻ᵐ` and is the +union of the prefix cylinders a computable `g` lists at `(m, j)`, `none` skipped. -/ +def MLTest (μ : Measure (ℕ → Bool)) (U : ℕ → Set (ℕ → Bool)) : Prop := + (∀ m, μ (U m) ≤ 2⁻¹ ^ m) ∧ + ∃ g : ℕ × ℕ → Option (List Bool), Computable g ∧ ∀ m, U m = ⋃ j, ⋃ l ∈ g (m, j), prefixCyl l + +/-- `Statement:` `w` is Martin-Löf random for `μ`: it lies in no test's intersection. -/ +def MLRandom (μ : Measure (ℕ → Bool)) (w : ℕ → Bool) : Prop := AvoidsTests (MLTest μ) w + +/-- `Statement:` the tapes reading `b` at every stage in `[N, N + n)`. -/ +def constBlock (b : Bool) (N n : ℕ) : Set (ℕ → Bool) := + {w | ∀ k ∈ Finset.Ico N (N + n), w k = b} + +theorem zeroBlock_eq_constBlock (N n : ℕ) : zeroBlock N n = constBlock false N n := rfl + +/-- `Statement:` the `j`-th word: the low `N` bits of `j`, then `n` copies of `b`. -/ +def blockWord (b : Bool) (N n j : ℕ) : List Bool := + (List.range N).map (bitAt j) ++ (List.range n).map (fun _ => b) + +theorem blockWord_length (b : Bool) (N n j : ℕ) : (blockWord b N n j).length = N + n := by + simp [blockWord] + +theorem blockWord_getElem (b : Bool) (N n j i : ℕ) (h : i < (blockWord b N n j).length) : + (blockWord b N n j)[i] = if i < N then bitAt j i else b := by + unfold blockWord + refine (List.getElem_append h).trans ?_ + split_ifs with h1 h2 h2 + · simp + · simp at h1; omega + · simp at h1; omega + · simp + +/-- `Statement:` a constant block is the union over `j` of the cylinders of `blockWord b N n j`. -/ +theorem constBlock_eq_iUnion (b : Bool) (N n : ℕ) : + constBlock b N n = ⋃ j, prefixCyl (blockWord b N n j) := by + ext x + simp only [constBlock, Finset.mem_Ico, Set.mem_setOf_eq, Set.mem_iUnion, prefixCyl] + constructor + · intro hx + refine ⟨ofBits N (fun i => x i), fun i hi => ?_⟩ + rw [blockWord_getElem] + split_ifs with hN + · exact (bitAt_ofBits N (fun i => x i) ⟨i, hN⟩).symm + · rw [blockWord_length] at hi; exact hx i ⟨by omega, hi⟩ + · rintro ⟨j, hj⟩ k hk + have hk' : k < (blockWord b N n j).length := by rw [blockWord_length]; exact hk.2 + rw [hj k hk', blockWord_getElem, if_neg (by omega)] + +/-- `Statement:` `bitAt` is primitive recursive; the same proof sits inline in `champ_primrec` +(`ZeroParadox/Information/Disjunctive.lean`). -/ +theorem bitAt_primrec : Primrec (fun p : ℕ × ℕ => bitAt p.1 p.2) := by + have hit : Primrec (fun p : ℕ × ℕ => (fun m => m / 2)^[p.2] p.1) := + Primrec.nat_iterate Primrec.snd Primrec.fst + (Primrec.nat_div.comp₂ Primrec₂.right (Primrec₂.const 2)) + exact (Primrec.beq.comp (Primrec.nat_mod.comp hit (Primrec.const 2)) (Primrec.const 1)).of_eq + fun _ => rfl + +theorem blockWord_primrec (b : Bool) : + Primrec (fun q : ℕ × ℕ × ℕ => blockWord b q.1 q.2.1 q.2.2) := by + have h1 : Primrec (fun q : ℕ × ℕ × ℕ => (List.range q.1).map (bitAt q.2.2)) := + Primrec.list_map (Primrec.list_range.comp Primrec.fst) + (bitAt_primrec.comp (Primrec.pair (Primrec.snd.comp (Primrec.snd.comp Primrec.fst)) + Primrec.snd)).to₂ + have h2 : Primrec (fun q : ℕ × ℕ × ℕ => (List.range q.2.1).map (fun _ => b)) := + Primrec.list_map (Primrec.list_range.comp (Primrec.fst.comp Primrec.snd)) (Primrec₂.const b) + exact (Primrec.list_append.comp h1 h2).of_eq fun _ => rfl + +/-- `Statement:` a constant-block family indexed by a primitive recursive `f` is listed as unions +of prefix cylinders by a computable `g`. -/ +theorem constBlock_presented (b : Bool) (f : ℕ → ℕ × ℕ) (hf : Primrec f) : + ∃ g : ℕ × ℕ → Option (List Bool), Computable g ∧ + ∀ m, constBlock b (f m).1 (f m).2 = ⋃ j, ⋃ l ∈ g (m, j), prefixCyl l := by + refine ⟨fun q => some (blockWord b (f q.1).1 (f q.1).2 q.2), ?_, fun m => ?_⟩ + · have hq : Primrec (fun q : ℕ × ℕ => ((f q.1).1, (f q.1).2, q.2)) := + Primrec.pair (Primrec.fst.comp (hf.comp Primrec.fst)) + (Primrec.pair (Primrec.snd.comp (hf.comp Primrec.fst)) Primrec.snd) + have hw : Primrec (fun q : ℕ × ℕ => blockWord b (f q.1).1 (f q.1).2 q.2) := + (blockWord_primrec b).comp hq + have hs : Primrec (fun q : ℕ × ℕ => (some (blockWord b (f q.1).1 (f q.1).2 q.2) : + Option (List Bool))) := Primrec.option_some.comp hw + exact hs.to_comp + · rw [constBlock_eq_iUnion] + simp + +/-- `Statement:` every zero-block test for `μ` is a Martin-Löf test for `μ`. -/ +theorem zeroBlockTest_isMLTest {μ : Measure (ℕ → Bool)} {U : ℕ → Set (ℕ → Bool)} + (hU : ZeroBlockTest μ U) : MLTest μ U := by + obtain ⟨hμ, f, hf, hUf⟩ := hU + obtain ⟨g, hg, hgf⟩ := constBlock_presented false f hf + exact ⟨hμ, g, hg, fun m => by rw [hUf m, zeroBlock_eq_constBlock, hgf m]⟩ + +/-- `Statement:` Martin-Löf random for `trials p hp` implies zero-block typical. One way. -/ +theorem zeroBlockTypical_of_MLRandom (p : NNReal) (hp : p ≤ 1) (w : ℕ → Bool) + (h : MLRandom (trials p hp) w) : ZeroBlockTypical p hp w := + fun U hU => h U (zeroBlockTest_isMLTest hU) + +/-- `Statement:` `snap_of_two_requirements` with zero-block typical replaced by Martin-Löf random +for `trials p hp`, `0 < p`. One way. `Reading:` the randomness is a hypothesis on one tape; no tape +is named, and ⊥ of `L` is not claimed random. -/ +theorem snap_of_firstStep_MLRandom {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (w : ℕ → Bool) (hML : MLRandom (trials p hp) w) : + ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := + snap_of_two_requirements hR1 p hp hp0 w (zeroBlockTypical_of_MLRandom p hp w hML) + +/-- `Statement:` a constant block of length `n` has measure `p ^ n` if `b = true`, and +`(1 - p) ^ n` if `b = false`. -/ +theorem trials_constBlock (p : NNReal) (hp : p ≤ 1) (b : Bool) (N n : ℕ) : + trials p hp (constBlock b N n) = + (if b then (p : ENNReal) else ((1 - p : NNReal) : ENNReal)) ^ n := by + have : constBlock b N n = (↑(Finset.Ico N (N + n)) : Set ℕ).pi (fun _ => ({b} : Set Bool)) := by + ext w; simp [constBlock] + rw [this, trials, Measure.infinitePi_pi _ (fun i _ => measurableSet_singleton b)] + cases b <;> simp [PMF.bernoulli] + +-- Statement: CONTROL, the converse fails: at `p = 1/2` the all-`true` tape is zero-block typical and +-- not Martin-Löf random (level `m` the cylinder of `m` trues, measure `2⁻ᵐ`). +example : ZeroBlockTypical (1/2) (by norm_num) (fun _ => true) ∧ + ¬ MLRandom (trials (1/2) (by norm_num)) (fun _ => true) := by + refine ⟨allTrue_zeroBlockTypical _ _, fun h => ?_⟩ + obtain ⟨g, hg, hgf⟩ := constBlock_presented true (fun m => (0, m)) + (Primrec.pair (Primrec.const 0) Primrec.id) + refine h (fun m => constBlock true 0 m) ⟨fun m => ?_, g, hg, hgf⟩ ?_ + · rw [trials_constBlock]; simp + · simp [constBlock] + +/-- `Statement:` the level sets listed by `g`. -/ +def levelOf (g : ℕ × ℕ → Option (List Bool)) (m : ℕ) : Set (ℕ → Bool) := + ⋃ j, ⋃ l ∈ g (m, j), prefixCyl l + +/-- `Statement:` the computable listings `ℕ × ℕ → Option (List Bool)` form a countable type. -/ +theorem countable_computable_enum : + Countable {g : ℕ × ℕ → Option (List Bool) // Computable g} := by + let F : {g : ℕ × ℕ → Option (List Bool) // Computable g} → {f : ℕ → ℕ // Computable f} := + fun g => ⟨fun n => Encodable.encode (g.1 (Denumerable.ofNat (ℕ × ℕ) n)), + Computable.encode.comp (g.2.comp (Primrec.ofNat (ℕ × ℕ)).to_comp)⟩ + refine Function.Injective.countable (f := F) ?_ + rintro ⟨g, hg⟩ ⟨g', hg'⟩ h + apply Subtype.ext + funext q + have := congrFun (congrArg Subtype.val h) (Encodable.encode q) + simp only [F, Denumerable.ofNat_encode] at this + exact Encodable.encode_injective this + +/-- `Statement:` if `μ (U m) ≤ 2⁻ᵐ` for every `m`, then `⋂ m, U m` is `μ`-null. -/ +theorem measure_iInter_le_pow_zero (μ : Measure (ℕ → Bool)) (U : ℕ → Set (ℕ → Bool)) + (h : ∀ m, μ (U m) ≤ 2⁻¹ ^ m) : μ (⋂ m, U m) = 0 := by + refine le_antisymm ?_ zero_le + have ht : Tendsto (fun m : ℕ => (2⁻¹ : ENNReal) ^ m) atTop (nhds 0) := + ENNReal.tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) + exact ge_of_tendsto' ht fun m => (measure_mono (Set.iInter_subset _ m)).trans (h m) + +/-- `Statement:` for every measure `μ` on tapes, `μ`-almost every tape is Martin-Löf random for `μ`: +the others lie in a countable union of null sets, one per computable listing. `Reading:` prior art +for the null half: Martin-Löf (1966), Information and Control 9, 602–619, abstract p. 602: "the non +random sequences form a maximal constructive null set". Maximality (a universal test) is not claimed +here; for blind tests it fails at non-computable `p` (Kjos-Hanssen, arXiv:1408.2850, Corollary 5.5, +p. 9). -/ +theorem mlRandom_ae (μ : Measure (ℕ → Bool)) : ∀ᵐ w ∂μ, MLRandom μ w := by + classical + haveI := countable_computable_enum + let bad : {g : ℕ × ℕ → Option (List Bool) // Computable g} → Set (ℕ → Bool) := fun g => + if ∀ m, μ (levelOf g.1 m) ≤ 2⁻¹ ^ m then ⋂ m, levelOf g.1 m else ∅ + have hnull : μ (⋃ g, bad g) = 0 := by + refine measure_iUnion_null fun g => ?_ + simp only [bad] + split_ifs with h + · exact measure_iInter_le_pow_zero μ _ h + · exact measure_empty + rw [ae_iff] + refine measure_mono_null (fun w hw => ?_) hnull + simp only [MLRandom, AvoidsTests, Set.mem_setOf_eq, not_forall, not_not] at hw + obtain ⟨U, ⟨hμ, g, hg, hU⟩, hmem⟩ := hw + have hUl : U = levelOf g := funext hU + subst hUl + refine Set.mem_iUnion.2 ⟨⟨g, hg⟩, ?_⟩ + simp only [bad, if_pos hμ] + exact hmem + +/-- `Statement:` for every `p ≤ 1` some tape is Martin-Löf random for `trials p hp`; it names none. -/ +theorem exists_MLRandom (p : NNReal) (hp : p ≤ 1) : ∃ w, MLRandom (trials p hp) w := + (mlRandom_ae (trials p hp)).exists + +/-- `Statement:` if ⊥ of `L` has a first step and `0 < p ≤ 1`, then for `trials p hp`-almost every +tape `w`, `w` fires (`hw`) and `snap_of_firstStep_fires_once`'s conclusion holds. One way. Almost +every, not every: the all-`false` tape never fires (the `example` below). No map from ⊥ of `L` to a +tape or to `trials p hp` is claimed. -/ +theorem snap_ae_of_firstStep {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + ∀ᵐ w ∂(trials p hp), ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := by + have hm : MeasurableSet {w : ℕ → Bool | ∃ k, w k = true} := by + have e : {w : ℕ → Bool | ∃ k, w k = true} = ⋃ k, fires k := by ext w; simp [fires] + rw [e]; exact MeasurableSet.iUnion fires_measurable + have hfire : ∀ᵐ w ∂(trials p hp), w ∈ {w : ℕ → Bool | ∃ k, w k = true} := + (ae_iff_measure_eq hm.nullMeasurableSet).2 (by rw [trials_fires_once p hp hp0, measure_univ]) + filter_upwards [hfire] with w hw + obtain ⟨φ, h⟩ := snap_of_firstStep_fires_once hR1 w hw + exact ⟨φ, hw, h⟩ + +/-- `Statement:` under `snap_ae_of_firstStep`'s hypotheses, `trials p hp`-almost every tape is +Martin-Löf random for `trials p hp` and carries `snap_ae_of_firstStep`'s conclusion; from +`mlRandom_ae` and `snap_of_firstStep_MLRandom`. One way. `Reading:` CARRIER: the ensemble reading +(all tapes under `trials p hp`) and the point reading (one Martin-Löf random tape) agree almost +everywhere: the ensemble's typical member is a random tape that gives the snap. That ⊥ of `L` is the +ensemble or a random tape is not proved here; `BotHasFirstStep L` stays a hypothesis, and a firing +is not proved to be an execution event. Prior art for the pattern (`snap_ae_of_firstStep` the +almost-every form, `snap_of_firstStep_MLRandom` the every-random form): Landsman, *Typical = random*, +arXiv:2306.09226, § 4, p. 16; the credit runs from Landsman to here. -/ +theorem mlRandom_and_snap_ae {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) : + ∀ᵐ w ∂(trials p hp), MLRandom (trials p hp) w ∧ ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := by + filter_upwards [mlRandom_ae (trials p hp)] with w hML + exact ⟨hML, snap_of_firstStep_MLRandom hR1 p hp hp0 w hML⟩ + +-- Statement: CONTROL, almost every is not every: at the all-`false` tape no `hw` exists, so the +-- conclusion fails there for every `L` (measure zero: the measure-one CONTROL `example` in +-- `ZeroParadox/Information/CrossingTrials.lean` § VIII). Dropping the first step: `nnreal_not_botHasFirstStep`. +example {L : Type*} [ZPSemilattice L] : + ¬ ∃ (_ : Bool → L) (_ : ∃ k, (fun _ => false : ℕ → Bool) k = true), True := + fun ⟨_, ⟨_, h⟩, _⟩ => Bool.false_ne_true h + +/-! ## § III. Frequency of `true` tending to `p` (the strong law of large numbers) + +Per tape: the fraction of `true` among the first `n` stages tends to `p`. That a Martin-Löf random +tape has this property is not proved here. For computable `p` the analogue for Milovanov's +`IsMartinLofRandom` and `bernoulliMeasure` is proved outside the dependency closure +(`tendsto_freqOne_of_isMartinLofRandom_bernoulli'`; `ZeroParadox/Information/CrossingTrials.md`, Prior +art); his definitions are not compared with `MLRandom` or `trials p hp` here. For every `p`, +Kjos-Hanssen (arXiv:1408.2850, Theorem 5.2, p. 8) proves it on paper for Hippocratic randomness of +`μ_p`; not formalized here. -/ + +section Frequency + +open Finset + +/-- `Statement:` the `ℝ`-valued indicator of `true` at stage `i`. -/ +def tapeInd (w : ℕ → Bool) (i : ℕ) : ℝ := if w i then 1 else 0 + +/-- `Statement:` the frequency of `true` among the first `n` stages. -/ +noncomputable def trueFreq (w : ℕ → Bool) (n : ℕ) : ℝ := (∑ i ∈ range n, tapeInd w i) / n + +/-- `Statement:` the frequency of `true` on `w` tends to `p`. -/ +def FreqBalanced (p : ℝ) (w : ℕ → Bool) : Prop := Tendsto (trueFreq w) atTop (nhds p) + +theorem tapeInd_measurable (i : ℕ) : Measurable (fun w : ℕ → Bool => tapeInd w i) := + (measurable_of_countable (fun b : Bool => if b then (1 : ℝ) else 0)).comp (measurable_pi_apply i) + +/-- `Statement:` `trials p hp`-almost every tape is `FreqBalanced p`: Mathlib's strong law +(`strong_law_ae_real`) on the coordinate indicators. -/ +theorem freqBalanced_ae (p : NNReal) (hp : p ≤ 1) : ∀ᵐ w ∂(trials p hp), FreqBalanced p w := by + let f : Bool → ℝ := fun b => if b then 1 else 0 + have hf : Measurable f := measurable_of_countable f + let X : ℕ → (ℕ → Bool) → ℝ := fun i w => tapeInd w i + have hXm : ∀ i, Measurable (X i) := tapeInd_measurable + have hint : Integrable (X 0) (trials p hp) := by + refine Integrable.of_bound (C := 1) (hXm 0).aestronglyMeasurable (Eventually.of_forall ?_) + intro w; simp only [X, tapeInd]; split_ifs <;> simp + have hind : iIndepFun X (trials p hp) := (coords_iIndep p hp).comp (fun _ => f) (fun _ => hf) + have hmap : ∀ i, Measure.map (X i) (trials p hp) = + Measure.map f (PMF.bernoulli p hp).toMeasure := by + intro i + have : X i = f ∘ (fun w : ℕ → Bool => w i) := rfl + rw [this, ← Measure.map_map hf (measurable_pi_apply i), trials, Measure.infinitePi_map_eval] + have hident : ∀ i, IdentDistrib (X i) (X 0) (trials p hp) (trials p hp) := fun i => + ⟨(hXm i).aemeasurable, (hXm 0).aemeasurable, by rw [hmap i, hmap 0]⟩ + have hE : ∫ w, X 0 w ∂(trials p hp) = p := by + calc ∫ w, X 0 w ∂(trials p hp) = ∫ w, f (w 0) ∂(trials p hp) := rfl + _ = ∫ b, f b ∂(Measure.map (fun w : ℕ → Bool => w 0) (trials p hp)) := + (integral_map (measurable_pi_apply 0).aemeasurable hf.aestronglyMeasurable).symm + _ = ∫ b, f b ∂((PMF.bernoulli p hp).toMeasure) := by + rw [trials, Measure.infinitePi_map_eval] + _ = p := by + rw [integral_fintype (Integrable.of_finite)] + simp [f, PMF.bernoulli, Measure.real] + have := strong_law_ae_real X hint (fun i j hij => hind.indepFun hij) hident + filter_upwards [this] with w hw + rw [hE] at hw + exact hw + +/-- `Statement:` if `0 < p` and `w` is `FreqBalanced p`, then `w` fires infinitely often: a tape +silent from `N` has frequency at most `N / n`, which tends to 0. One way. -/ +theorem fires_io_of_freqBalanced {p : ℝ} (hp0 : 0 < p) (w : ℕ → Bool) (hb : FreqBalanced p w) : + w ∈ Filter.limsup fires Filter.atTop := by + by_contra h + obtain ⟨N, hN⟩ := (not_mem_limsup_fires_iff w).1 h + have hle : ∀ n, ∑ i ∈ range n, tapeInd w i ≤ N := by + intro n + calc ∑ i ∈ range n, tapeInd w i ≤ ∑ i ∈ range n, (if i < N then (1 : ℝ) else 0) := by + refine sum_le_sum fun i _ => ?_ + simp only [tapeInd] + by_cases hi : i < N + · rw [if_pos hi]; split_ifs <;> norm_num + · rw [if_neg hi, hN i (not_lt.1 hi)]; simp + _ = ((range n).filter (· < N)).card := by rw [sum_boole] + _ ≤ N := by + exact_mod_cast (card_le_card (fun i hi => by + simp only [mem_filter] at hi; exact mem_range.2 hi.2)).trans (card_range N).le + have hfreq : ∀ n, trueFreq w n ≤ (N : ℝ) / n := fun n => + div_le_div_of_nonneg_right (hle n) (Nat.cast_nonneg n) + have h0 : Tendsto (fun n : ℕ => (N : ℝ) / n) atTop (nhds 0) := + tendsto_const_div_atTop_nhds_zero_nat (N : ℝ) + have : p ≤ 0 := le_of_tendsto_of_tendsto' hb h0 hfreq + linarith + +/-- `Statement:` `snap_of_two_requirements` with zero-block typical replaced by `FreqBalanced p`, +`0 < p`. One way. -/ +theorem snap_of_firstStep_freqBalanced {L : Type*} [ZPSemilattice L] (hR1 : BotHasFirstStep L) + {p : ℝ} (hp0 : 0 < p) (w : ℕ → Bool) (hb : FreqBalanced p w) : + ∃ (φ : Bool → L) (hw : ∃ k, w k = true), + let S := φ ∘ firedRun w hw + (S 0 = bot ∧ S 1 ≠ S 0 ∧ IsStateSequence S) ∧ + ((S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1) ∧ + letI := zpSemilatticeSup L; (bot : L) ⋖ S 1) := by + obtain ⟨φ, h⟩ := snap_of_firstStep_fires_once hR1 w + (fires_once_of_mem_limsup (fires_io_of_freqBalanced hp0 w hb)) + exact ⟨φ, _, h⟩ + +/-- `Statement:` the all-`true` tape has frequency 1 at every `n ≥ 1`. -/ +theorem trueFreq_allTrue (n : ℕ) (hn : 0 < n) : trueFreq (fun _ => true) n = 1 := by + simp only [trueFreq, tapeInd, if_true, sum_const, card_range, nsmul_eq_mul, mul_one] + exact div_self (by exact_mod_cast hn.ne') + +-- Statement: CONTROL, the all-`true` tape is `FreqBalanced p` for no `p < 1`. +example (p : ℝ) (hp : p < 1) : ¬ FreqBalanced p (fun _ => true) := by + intro h + have h1 : Tendsto (trueFreq (fun _ => true)) atTop (nhds 1) := + tendsto_const_nhds.congr' (eventually_atTop.2 ⟨1, fun n hn => (trueFreq_allTrue n hn).symm⟩) + have := tendsto_nhds_unique h h1 + linarith + +-- Statement: CONTROL, drop `0 < p`: the all-`false` tape is `FreqBalanced 0` and never fires. +example : FreqBalanced 0 (fun _ => false) ∧ ¬ ∃ k, (fun _ => false : ℕ → Bool) k = true := by + refine ⟨?_, fun ⟨_, h⟩ => Bool.false_ne_true h⟩ + have : trueFreq (fun _ => false) = fun _ => 0 := by funext n; simp [trueFreq, tapeInd] + rw [FreqBalanced, this]; exact tendsto_const_nhds + +end Frequency + +/-! ## § IV. Tape to real: binary expansion + +`tapeReal w` is `0.w₀w₁w₂…` in base 2 (`Real.ofDigits`). How `trials p hp` pushes forward under it +is not stated here; `Mathlib/Analysis/Real/OfDigits.lean` has no measure statement (read 2026-11-06). -/ + +section TapeReal + +open Finset + +/-- `Statement:` bit `b` as a base-2 digit. -/ +def bitDigit (b : Bool) : Fin 2 := if b then 1 else 0 + +/-- `Statement:` the real `0.w₀w₁w₂…` in base 2. -/ +noncomputable def tapeReal (w : ℕ → Bool) : ℝ := Real.ofDigits (fun i => bitDigit (w i)) + +/-- `Statement:` the tape is eventually constant. -/ +def EventuallyConstTape (w : ℕ → Bool) : Prop := ∃ N b, ∀ k, N ≤ k → w k = b + +-- Statement: it is Mathlib's `Filter.EventuallyConst` at `atTop`. +example (w : ℕ → Bool) : EventuallyConstTape w ↔ Filter.EventuallyConst w Filter.atTop := by + rw [Filter.eventuallyConst_atTop] + constructor + · rintro ⟨N, b, hb⟩; exact ⟨N, fun j hj => (hb j hj).trans (hb N le_rfl).symm⟩ + · rintro ⟨N, hN⟩; exact ⟨N, w N, hN⟩ + +/-- `Statement:` `x` is a non-negative dyadic rational `k / 2ⁿ`, `k n : ℕ`. -/ +def IsDyadic (x : ℝ) : Prop := ∃ n k : ℕ, x = k / 2 ^ n + +theorem fin2_val_le_one (d : Fin 2) : ((d : ℕ) : ℝ) ≤ 1 := by + have := d.isLt; exact_mod_cast (by omega : (d : ℕ) ≤ 1) + +/-- `Statement:` a base-2 expansion with a nonzero digit is positive. -/ +theorem ofDigits_two_pos {d : ℕ → Fin 2} (h : ∃ i, d i ≠ 0) : 0 < Real.ofDigits d := by + obtain ⟨i, hi⟩ := h + have hdi : d i = 1 := by revert hi; generalize d i = x; fin_cases x <;> simp + unfold Real.ofDigits + refine Summable.tsum_pos Real.summable_ofDigitsTerm (fun _ => Real.ofDigitsTerm_nonneg) i ?_ + simp [Real.ofDigitsTerm, hdi] + +/-- `Statement:` a base-2 expansion with a zero digit is less than 1. -/ +theorem ofDigits_two_lt_one {d : ℕ → Fin 2} (h : ∃ i, d i = 0) : Real.ofDigits d < 1 := by + obtain ⟨i, hi⟩ := h + rw [← Real.ofDigits_const_last_eq_one 1] + unfold Real.ofDigits + refine Summable.tsum_lt_tsum (i := i) (fun j => ?_) ?_ Real.summable_ofDigitsTerm + Real.summable_ofDigitsTerm + · simp only [Real.ofDigitsTerm] + gcongr + simpa using fin2_val_le_one (d j) + · simp [Real.ofDigitsTerm, hi] + +/-- `Statement:` `2ⁿ` times the first `n` terms of a base-2 expansion is a natural number. -/ +theorem ofDigits_two_partial_nat (d : ℕ → Fin 2) (n : ℕ) : + ∃ m : ℕ, (2 : ℝ) ^ n * ∑ i ∈ range n, Real.ofDigitsTerm d i = m := by + induction n with + | zero => exact ⟨0, by simp⟩ + | succ n ih => + obtain ⟨m, hm⟩ := ih + refine ⟨2 * m + (d n : ℕ), ?_⟩ + rw [sum_range_succ, mul_add, pow_succ, mul_comm ((2 : ℝ) ^ n) 2, mul_assoc, hm] + simp only [Real.ofDigitsTerm] + push_cast + have : (2 : ℝ) ^ (n + 1) ≠ 0 := by positivity + field_simp + ring + +/-- `Statement:` a tape not eventually constant has, past every `n`, a `true` and a `false`. -/ +theorem shift_of_not_eventuallyConst {w : ℕ → Bool} (h : ¬ EventuallyConstTape w) (n : ℕ) : + (∃ i, bitDigit (w (i + n)) ≠ 0) ∧ (∃ i, bitDigit (w (i + n)) = 0) := by + constructor + · by_contra hc + push Not at hc + refine h ⟨n, false, fun k hk => ?_⟩ + have := hc (k - n) + rw [Nat.sub_add_cancel hk] at this + cases hw : w k <;> simp_all [bitDigit] + · by_contra hc + push Not at hc + refine h ⟨n, true, fun k hk => ?_⟩ + have := hc (k - n) + rw [Nat.sub_add_cancel hk] at this + cases hw : w k <;> simp_all [bitDigit] + +/-- `Statement:` a tape that is not eventually constant lands strictly inside (0, 1) at no dyadic +rational. The converse direction is `dyadic_of_eventuallyConst`. -/ +theorem interior_of_not_eventuallyConst {w : ℕ → Bool} (h : ¬ EventuallyConstTape w) : + 0 < tapeReal w ∧ tapeReal w < 1 ∧ ¬ IsDyadic (tapeReal w) := by + have h0 := shift_of_not_eventuallyConst h 0 + simp only [Nat.add_zero] at h0 + refine ⟨ofDigits_two_pos h0.1, ofDigits_two_lt_one h0.2, ?_⟩ + rintro ⟨n, k, hk⟩ + obtain ⟨m, hm⟩ := ofDigits_two_partial_nat (fun i => bitDigit (w i)) n + have hn := shift_of_not_eventuallyConst h n + have ht0 := ofDigits_two_pos hn.1 + have ht1 := ofDigits_two_lt_one hn.2 + have hdec := Real.ofDigits_eq_sum_add_ofDigits (fun i => bitDigit (w i)) n + set t := Real.ofDigits (fun i => bitDigit (w (i + n))) + have h2n : (0 : ℝ) < 2 ^ n := by positivity + have hx : (2 : ℝ) ^ n * tapeReal w = m + t := by + unfold tapeReal; rw [hdec, mul_add, hm]; push_cast + rw [← mul_assoc, mul_inv_cancel₀ h2n.ne', one_mul] + have hk' : (2 : ℝ) ^ n * tapeReal w = k := by rw [hk]; field_simp + rw [hk'] at hx + have a : (m : ℝ) < k := by linarith + have b : (k : ℝ) < m + 1 := by linarith + have a' : m < k := by exact_mod_cast a + have b' : k < m + 1 := by exact_mod_cast b + omega + +/-- `Statement:` an eventually constant tape lands on a dyadic rational. -/ +theorem dyadic_of_eventuallyConst {w : ℕ → Bool} (h : EventuallyConstTape w) : + IsDyadic (tapeReal w) := by + obtain ⟨N, b, hb⟩ := h + obtain ⟨m, hm⟩ := ofDigits_two_partial_nat (fun i => bitDigit (w i)) N + have hdec := Real.ofDigits_eq_sum_add_ofDigits (fun i => bitDigit (w i)) N + have htail : Real.ofDigits (fun i => bitDigit (w (i + N))) = if b then 1 else 0 := by + have hfun : (fun i => bitDigit (w (i + N))) = fun _ => bitDigit b := + funext fun i => by rw [hb (i + N) (Nat.le_add_left N i)] + rw [hfun] + cases b + · simp [Real.ofDigits, Real.ofDigitsTerm, bitDigit] + · exact Real.ofDigits_const_last_eq_one 1 + refine ⟨N, m + (if b then 1 else 0), ?_⟩ + have h2n : (0 : ℝ) < 2 ^ N := by positivity + unfold tapeReal + rw [hdec, htail] + have hS : ∑ i ∈ range N, Real.ofDigitsTerm (fun i => bitDigit (w i)) i = m / 2 ^ N := by + rw [eq_div_iff h2n.ne', mul_comm, hm] + rw [hS] + cases b <;> (push_cast; field_simp) + +/-- `Statement:` `w` is not eventually constant iff `tapeReal w` is not a dyadic rational; both +directions. -/ +theorem not_eventuallyConst_iff_not_dyadic (w : ℕ → Bool) : + ¬ EventuallyConstTape w ↔ ¬ IsDyadic (tapeReal w) := + ⟨fun h => (interior_of_not_eventuallyConst h).2.2, fun h hc => h (dyadic_of_eventuallyConst hc)⟩ + +-- Reading: CARRIER. The tapes that settle land on dyadic rationals, each at a finite binary level; +-- the tapes that never settle land off them, strictly inside (0, 1). The split is between values with +-- a finite binary expansion and values with only infinite ones, not stepped versus continuous: the +-- dyadic rationals are dense among themselves (between two distinct ones lies a third, the `example` +-- below), and in ℝ's order no point, dyadic or not, has a first step +-- (`no_firstStep_of_preconnected`, `ZeroParadox/Reals/ConnectedNoFirstStep.lean`). The first step of § I is asked of `L`, never of ℝ. + +-- Statement: between two distinct dyadic rationals `x < y` lies a third, their midpoint. +example (x y : ℝ) (hx : IsDyadic x) (hy : IsDyadic y) (hxy : x < y) : + ∃ z, IsDyadic z ∧ x < z ∧ z < y := by + refine ⟨(x + y) / 2, ?_, by linarith, by linarith⟩ + obtain ⟨n, k, rfl⟩ := hx + obtain ⟨m, j, rfl⟩ := hy + refine ⟨n + m + 1, k * 2 ^ m + j * 2 ^ n, ?_⟩ + push_cast + field_simp + ring + +/-- `Statement:` for `0 < p < 1`, a Martin-Löf random tape for `trials p hp` is not eventually +constant: eventually `false` is caught by a zero-block test, eventually `true` by a one-block test. -/ +theorem not_eventuallyConst_of_MLRandom (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (hp1 : p < 1) + (w : ℕ → Bool) (hML : MLRandom (trials p hp) w) : ¬ EventuallyConstTape w := by + rintro ⟨N, b, hb⟩ + cases b with + | false => + have hio := fires_io_of_avoids p hp hp0 _ (fun _ h => h) w + (zeroBlockTypical_of_MLRandom p hp w hML) + exact (not_mem_limsup_fires_iff w).2 ⟨N, hb⟩ hio + | true => + have hq0 : 0 < (1 - p : NNReal) := tsub_pos_of_lt hp1 + obtain ⟨K, -, hK⟩ := exists_halving_block (1 - p) hq0 + rw [tsub_tsub_cancel_of_le hp] at hK + obtain ⟨g, hg, hgf⟩ := constBlock_presented true (fun m => (N, K * m)) + (Primrec.pair (Primrec.const N) (Primrec.nat_mul.comp (Primrec.const K) Primrec.id)) + refine hML (fun m => constBlock true N (K * m)) ⟨fun m => ?_, g, hg, hgf⟩ ?_ + · rw [trials_constBlock, if_pos rfl, pow_mul] + exact pow_le_pow_left₀ zero_le hK m + · simp only [Set.mem_iInter, constBlock, Set.mem_setOf_eq, Finset.mem_Ico] + intro m k hk; exact hb k hk.1 + +/-- `Statement:` for `0 < p < 1`, a Martin-Löf random tape for `trials p hp` lands strictly inside +(0, 1), at no dyadic rational. -/ +theorem interior_of_MLRandom (p : NNReal) (hp : p ≤ 1) (hp0 : 0 < p) (hp1 : p < 1) + (w : ℕ → Bool) (hML : MLRandom (trials p hp) w) : + 0 < tapeReal w ∧ tapeReal w < 1 ∧ ¬ IsDyadic (tapeReal w) := + interior_of_not_eventuallyConst (not_eventuallyConst_of_MLRandom p hp hp0 hp1 w hML) + +-- Statement: CONTROL, the all-`false` and all-`true` tapes land on the endpoints 0 and 1. +example : tapeReal (fun _ => false) = 0 ∧ tapeReal (fun _ => true) = 1 := by + refine ⟨by simp [tapeReal, Real.ofDigits, Real.ofDigitsTerm, bitDigit], ?_⟩ + exact Real.ofDigits_const_last_eq_one 1 + +-- Statement: `trials 1` is the point mass on the all-`true` tape. +example : trials 1 le_rfl = Measure.dirac (fun _ => true) := by + have hb : PMF.bernoulli (1 : NNReal) le_rfl = PMF.pure true := by + ext b; cases b <;> simp [PMF.bernoulli_apply, PMF.pure_apply] + rw [trials, hb, PMF.toMeasure_pure, Measure.infinitePi_dirac] + +-- Statement: CONTROL, `p < 1` is needed: at `p = 1` the all-`true` tape is Martin-Löf random for +-- `trials 1` (the point mass on it, previous `example`), eventually constant, and lands on 1. +example : MLRandom (trials 1 le_rfl) (fun _ => true) ∧ EventuallyConstTape (fun _ => true) ∧ + tapeReal (fun _ => true) = 1 := by + refine ⟨?_, ⟨0, true, fun _ _ => rfl⟩, Real.ofDigits_const_last_eq_one 1⟩ + rintro U ⟨hμ, g, -, hU⟩ hmem + have h1 : (fun _ => true : ℕ → Bool) ∈ U 1 := Set.mem_iInter.1 hmem 1 + rw [hU 1] at h1 + simp only [Set.mem_iUnion, exists_prop] at h1 + obtain ⟨j, l, hl, hx⟩ := h1 + have hsub : constBlock true 0 l.length ⊆ U 1 := by + intro x hx' + rw [hU 1] + simp only [Set.mem_iUnion, exists_prop] + refine ⟨j, l, hl, fun i hi => ?_⟩ + rw [← hx i hi] + exact hx' i (by simp only [Finset.mem_Ico]; omega) + have h2 := (measure_mono hsub).trans (hμ 1) + rw [trials_constBlock, if_pos rfl] at h2 + norm_num at h2 + +-- Statement: CONTROL, the alternating tape lands strictly inside (0, 1), at no dyadic rational. +example : 0 < tapeReal (fun k => decide (k % 2 = 0)) ∧ tapeReal (fun k => decide (k % 2 = 0)) < 1 ∧ + ¬ IsDyadic (tapeReal (fun k => decide (k % 2 = 0))) := by + refine interior_of_not_eventuallyConst ?_ + rintro ⟨N, b, hb⟩ + have h1 : decide ((2 * N) % 2 = 0) = b := hb (2 * N) (by omega) + have h2 : decide ((2 * N + 1) % 2 = 0) = b := hb (2 * N + 1) (by omega) + rw [decide_eq_true (by omega : (2 * N) % 2 = 0)] at h1 + rw [decide_eq_false (by omega : ¬ (2 * N + 1) % 2 = 0)] at h2 + exact Bool.false_ne_true (h2.trans h1.symm) + +-- Statement: the alternating tape is computable. +example : Computable (fun k : ℕ => decide (k % 2 = 0)) := + (Primrec.beq.comp (Primrec.nat_mod.comp Primrec.id (Primrec.const 2)) (Primrec.const 0)).to_comp.of_eq + fun k => by by_cases h : k % 2 = 0 <;> simp [h] + +-- Statement: the alternating tape is not Martin-Löf random for `trials (1/2)` (level `m` the cylinder +-- of its first `m` bits, measure `2⁻ᵐ`). Reading: so at `p = 1/2`, landing strictly inside (0, 1) at +-- no dyadic rational does not need randomness. +example : ¬ MLRandom (trials (1/2) (by norm_num)) (fun k => decide (k % 2 = 0)) := by + intro h + let a : ℕ → Bool := fun k => decide (k % 2 = 0) + have ha : Primrec a := + (Primrec.beq.comp (Primrec.nat_mod.comp Primrec.id (Primrec.const 2)) (Primrec.const 0)).of_eq + fun k => by by_cases hk : k % 2 = 0 <;> simp [a, hk] + have hcyl : ∀ m, prefixCyl ((List.range m).map a) = + (↑(Finset.range m) : Set ℕ).pi (fun i => ({a i} : Set Bool)) := by + intro m; ext x; simp [prefixCyl] + refine h (fun m => prefixCyl ((List.range m).map a)) + ⟨fun m => ?_, fun q => some ((List.range q.1).map a), ?_, fun m => ?_⟩ ?_ + · show trials _ _ (prefixCyl ((List.range m).map a)) ≤ _ + rw [hcyl, trials, Measure.infinitePi_pi _ (fun i _ => measurableSet_singleton _)] + have : ∀ i, (PMF.bernoulli (1/2) (by norm_num)).toMeasure {a i} = 2⁻¹ := by + intro i; cases a i <;> simp [PMF.bernoulli] + rw [Finset.prod_congr rfl (fun i _ => this i), Finset.prod_const, Finset.card_range] + · have : Primrec (fun q : ℕ × ℕ => (List.range q.1).map a) := + Primrec.list_map (Primrec.list_range.comp Primrec.fst) (ha.comp Primrec.snd).to₂ + exact (Primrec.option_some.comp this).to_comp + · ext x + simp only [Set.mem_iUnion, Option.mem_def, Option.some.injEq, exists_prop] + exact ⟨fun hx => ⟨0, _, rfl, hx⟩, fun ⟨_, _, hl, hx⟩ => hl ▸ hx⟩ + · simp [prefixCyl, a] + +end TapeReal + +end ZeroParadox + +/-! ## Axiom Purity Check -/ + +section PurityCheck +open ZeroParadox + +#print axioms BotHasFirstStep +#print axioms ZeroBlockTypical +#print axioms fires_once_of_mem_limsup +#print axioms snap_of_firstStep_fires_once +#print axioms snap_of_two_requirements +#print axioms hcov_iff_phi_cover +#print axioms botHasFirstStep_iff_exists_phi +#print axioms nnrealMaxZPS +#print axioms allTrue_zeroBlockTypical +#print axioms nnreal_zp_lt_iff +#print axioms nnreal_not_botHasFirstStep +#print axioms boolOrZPS +#print axioms bool_botHasFirstStep +#print axioms prefixCyl +#print axioms MLTest +#print axioms MLRandom +#print axioms constBlock +#print axioms zeroBlock_eq_constBlock +#print axioms blockWord +#print axioms blockWord_length +#print axioms blockWord_getElem +#print axioms constBlock_eq_iUnion +#print axioms bitAt_primrec +#print axioms blockWord_primrec +#print axioms constBlock_presented +#print axioms zeroBlockTest_isMLTest +#print axioms zeroBlockTypical_of_MLRandom +#print axioms snap_of_firstStep_MLRandom +#print axioms trials_constBlock +#print axioms levelOf +#print axioms countable_computable_enum +#print axioms measure_iInter_le_pow_zero +#print axioms mlRandom_ae +#print axioms exists_MLRandom +#print axioms snap_ae_of_firstStep +#print axioms mlRandom_and_snap_ae +#print axioms tapeInd +#print axioms trueFreq +#print axioms FreqBalanced +#print axioms tapeInd_measurable +#print axioms freqBalanced_ae +#print axioms fires_io_of_freqBalanced +#print axioms snap_of_firstStep_freqBalanced +#print axioms trueFreq_allTrue +#print axioms bitDigit +#print axioms tapeReal +#print axioms EventuallyConstTape +#print axioms IsDyadic +#print axioms fin2_val_le_one +#print axioms ofDigits_two_pos +#print axioms ofDigits_two_lt_one +#print axioms ofDigits_two_partial_nat +#print axioms shift_of_not_eventuallyConst +#print axioms interior_of_not_eventuallyConst +#print axioms dyadic_of_eventuallyConst +#print axioms not_eventuallyConst_iff_not_dyadic +#print axioms not_eventuallyConst_of_MLRandom +#print axioms interior_of_MLRandom + +end PurityCheck diff --git a/ZeroParadox/MANIFEST.md b/ZeroParadox/MANIFEST.md index 2ab07042..970631ba 100644 --- a/ZeroParadox/MANIFEST.md +++ b/ZeroParadox/MANIFEST.md @@ -16,7 +16,9 @@ cites; it is a curated map of what is established, not a source of new claims. **On the central claim (read this first).** The organizing thesis is that the bottom element recurs in the same structural role across several domains. What is **proved** is the *membership* and the *recurrence of the slot structure*. The reading that the various bottoms are *one object* is retired as ill-typed (object -equality across categories does not typecheck and is not invariant under equivalence); what separates the members +equality across categories does not typecheck and is not invariant under equivalence; for the equivalence +principle see Ahrens and North, "Univalent foundations and the equivalence principle", arXiv:2202.01892, +§ 2, as `CLAIMS.md` cites it); what separates the members is proved property by property (seam_unique_among_named, for the named bottoms, in a lattice with no top). The index above is where the precise line between proved and conjectural is kept. @@ -26,9 +28,11 @@ The framework's reviewed, load-bearing Lean, organized by domain folder. The for ### Order / lattice (ZP-A, ZP-E) +- `ZeroParadox/Order/ChoiceFreeWithTop.lean` - Choice-free orders on `WithTop α` and `WithBot α` - `ZeroParadox/Order/Lattice.lean` - ZP-A: Lattice Algebra - `ZeroParadox/Order/LeastFixedPoint.lean` - The μ abstraction: least fixed point reached from a seed (the ceiling analogue of `AbstractSelfApp`) - ride-along docs: `ZeroParadox/Order/LeastFixedPoint.md` - The schema, its three faces, and why the seed is a role rather than an origin +- `ZeroParadox/Order/PadicLimitCone.lean` - The p-adic floor `{0}` is a genuine categorical limit cone - `ZeroParadox/Order/PataraiaChoiceFree.lean` - Pataraia's theorem and induction, with no axioms - `ZeroParadox/Order/PataraiaFromBourbakiWitt.lean` - Pataraia's statement from Bourbaki–Witt, classically - ride-along docs: `ZeroParadox/Order/PataraiaFromBourbakiWitt.md` - Prior art for the classical route, and where the choice-free proofs are formalized @@ -77,6 +81,7 @@ The framework's reviewed, load-bearing Lean, organized by domain folder. The for - `ZeroParadox/Information/BottomMeasure.lean` - P6: measure = +∞ at the bottom — per-domain bundle, and the type-boundary finding - `ZeroParadox/Information/CrossingTrials.lean` - Crossing trials: what a probability on the crossing would buy + - ride-along docs: `ZeroParadox/Information/CrossingTrials.md` - Crossing trials, § IV–IX: from almost surely to one run, from one firing to a state sequence, and why a finite reading can confirm a firing (`isOpen_fires_once`) and never refute one - `ZeroParadox/Information/Disjunctive.lean` - Disjunctive sequences: a tape on which every finite word occurs - ride-along docs: `ZeroParadox/Information/Disjunctive.md` - Disjunctive sequences: prior art, footprints and fences - `ZeroParadox/Information/PadicSurprisal.lean` - B3 (pipeline): information surprisal ≡ 2-adic depth at the floor @@ -120,6 +125,7 @@ The framework's reviewed, load-bearing Lean, organized by domain folder. The for - `ZeroParadox/Category/LawvereTaboo.lean` - The diagonal engine's supplier is a constructive taboo - ride-along docs: `ZeroParadox/Category/LawvereTaboo.md` - The diagonal engine's supplier is a constructive taboo: result, fences and prior art - `ZeroParadox/Category/LawvereTwoAdic.lean` - Add-one, doubling and the relativized Lawvere witness: on ℤ, ℤ_[2] and partial digit streams +- `ZeroParadox/Category/TreeSeam.lean` - ZP-H tree — the #5 straddle resolved: the Hilbert bottom is the μ=ν seam ### Multi-homed bridges (ZP-H) @@ -139,6 +145,7 @@ The framework's reviewed, load-bearing Lean, organized by domain folder. The for - `ZeroParadox/Multihomed/SelfClosureObstruction.lean` - Self-Closure Obstructions: the wall-side mirror of the diagonal fixed point (experimental probe) - `ZeroParadox/Multihomed/SeparatedSuccession.lean` - The type bridge: a separated succession as an interface, with two known implementations - `ZeroParadox/Multihomed/TopNumEdge.lean` - Web edge: topology ↔ number theory (the valuation generates the ball topology) +- `ZeroParadox/Multihomed/TreeObstructions.lean` - ZP-H: The bottom-diagram tree — machine-checked obstruction core (E4 + SPLIT, rebuilt) ### Set theory / AFA (ZP-J) @@ -206,7 +213,7 @@ The framework's reviewed, load-bearing Lean, organized by domain folder. The for - `ZeroParadox/Ordinal/NaturalOpsPow.lean` - Natural sum on powers of ω — the deferred CNF characterization (ported) - `ZeroParadox/Ordinal/OrdinalChoiceEssential.lean` - Comparability of well-orders is a constructive taboo - ride-along docs: `ZeroParadox/Ordinal/OrdinalChoiceEssential.md` - Comparability of well-orders is a constructive taboo: result, prior art and fences -- `ZeroParadox/Ordinal/P8.lean` - P8 re-attempt: ε₀ → 0 in ℤ₂ via a tower-rank 2-adic encoding +- `ZeroParadox/Ordinal/P8.lean` - P8 re-attempt: the ω-tower's encodings → 0 in ℤ₂ via a tower-rank 2-adic encoding - `ZeroParadox/Ordinal/PricedInterface.lean` - A priced interface: notations denoting the ordinals up to ε₀, a map into `Ordinal`, and both sides' axiom footprints - ride-along docs: `ZeroParadox/Ordinal/PricedInterface.md` - PricedInterface — ride-along documentation - `ZeroParadox/Ordinal/SnapMetaLattice.lean` - The lattice of systems: adjoining the point at infinity makes the ordinals a frame @@ -258,18 +265,19 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results ### Order / lattice (ZP-A, ZP-E) +- `ZeroParadox/Order/DieJoints.lean` - Joints and dual joints: cut points approached from one side and not reached there - `ZeroParadox/Order/MarkovContractionDual.lean` - The dual contraction dichotomy on the Markov ν-side (#2) - `ZeroParadox/Order/MarkovPlacement.lean` - The unplaced node: does the Markov attractor (#2) admit ANY order-extremal or categorical placement? - `ZeroParadox/Order/OrbitDichotomy.lean` - The orbit dichotomy — "one or infinitely many", no finite middle (probe) -- `ZeroParadox/Order/PadicLimitCone.lean` - The p-adic floor `{0}` is a genuine categorical limit cone - `ZeroParadox/Order/ProofFloorHomset.lean` - Axis III over the proof-theory floor #1 (the hom-set carrier convention) -- `ZeroParadox/Order/SeamSchema.lean` - A shared "seam schema" for the QPF root-seam and the lattice selfApp seam, with the cross-setting fence IN the statement. +- `ZeroParadox/Order/SeamSchema.lean` - A shared "seam schema" for the QPF root-seam and the lattice selfApp seam; this file exhibits no map between the two settings - `ZeroParadox/Order/WellFoundedObstruct.lean` - Well-foundedness obstructs the attractor character of the μ floor - ride-along docs: `ZeroParadox/Order/WellFoundedObstruct.md` - The NO-GO gauge on the attractor reading, and what the capstone does not claim ### Valuation / number theory (ZP-B, ZP-F) - `ZeroParadox/Valuation/AxisSweepProbe.lean` - Experimental probes: the fork is trivially satisfiable, and the pole vs chain / branching pairs +- `ZeroParadox/Valuation/BallLine.lean` - The line of closed balls about 0 of `ℚ_[2]`: a cover at every vertex, none at either end - `ZeroParadox/Valuation/BottomInvariant.lean` - A first universal: the bottom carries an invariant probability measure - ride-along docs: `ZeroParadox/Valuation/BottomInvariant.md` - Evidence for a universal at the existence level, and where it stops - `ZeroParadox/Valuation/BoundaryGap.lean` - The boundary embedding: the exact gap to the Bruhat-Tits tree @@ -305,6 +313,7 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Valuation/PoleCorners.lean` - The four corners: 0 and ∞ have exactly four representations to each other - `ZeroParadox/Valuation/PoleCornersBridge.lean` - Bridge: the four corners are the corners of the tower to ω (shared-shape correspondence) - ride-along docs: `ZeroParadox/Valuation/PoleCornersBridge.md` - Assembling a correspondence without asserting an identity +- `ZeroParadox/Valuation/PolePassage.lean` - The snap arc on the 2-adic sphere: no passage through `∞`, a return in the valuation - `ZeroParadox/Valuation/RateTransport.lean` - within-Axis-I positive rate-transport via the shared geometric rate `2^(-n)` - `ZeroParadox/Valuation/RootAsymmetry.lean` - Root-asymmetry test: #1 (μ order-floor) vs #3 (ν p-adic limit) - `ZeroParadox/Valuation/ScaleDepthWitness.lean` - A concrete family satisfying ZP-I's `IsDepthChain`, and the gauge pricing what that satisfaction is worth @@ -315,6 +324,13 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Valuation/TowerHeightFloor.lean` - Height meets floor: the tower's 2-adic images as an InfinitudeFloor, norm order reversed from stage 1 — ε₀ ≠ ⊥ of `Ordinal` preserved - ride-along docs: `ZeroParadox/Valuation/TowerHeightFloor.md` - Height meets floor — the tower's 2-adic images as an InfinitudeFloor, norm order reversed from stage 1 +### Information (ZP-C) + +- `ZeroParadox/Information/BrudnoBridge.lean` - Brudno bridge: `trials` and `MLRandom` against `kolmogorov-complexity-lean` +- `ZeroParadox/Information/MaxEntropy.lean` - Maximum entropy: the fair coin, missing information, and incompressible tapes +- `ZeroParadox/Information/SnapEpsilonZero.lean` - The snap and ε₀ on two carriers: on `WithBot Ordinal` the first step lands at ↑0 and `up` carries it to ↑ε₀ (the corner); on `EpsilonOrZero` the first step is ε₀ (the cover) +- `ZeroParadox/Information/TwoRequirements.lean` - Two requirements: a first step at ⊥ of `L`, and a typical tape + ### State / Hilbert (ZP-D) - `ZeroParadox/State/ProbeSeparates.lean` - `Fin 0` is empty; the zero ℂ-module on `Fin 0` is inhabited @@ -322,6 +338,7 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results ### Reals (counterexamples) +- `ZeroParadox/Reals/ConnectedNoFirstStep.lean` - Connectedness and the first step on a linear order with its order topology - `ZeroParadox/Reals/RateClassInvariant.lean` - Axis IV: convergence-rate class as a cross-root invariant ### Category theory (ZP-G, ZP-H) @@ -350,7 +367,7 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Category/SeamBiproductUnit.lean` - The seam #5 is the additive UNIT of the biproduct on `ModuleCat ℂ` - `ZeroParadox/Category/SeamBridge.lean` - Is the seam a genuine BRIDGE between the subtrees, or a coincidentally two-sided object? - `ZeroParadox/Category/SeamCoincidence.lean` - The seam IS the categorical μ=ν coincidence -- `ZeroParadox/Category/SeamComparisonMap.lean` - The canonical μ→ν comparison map at the root seam, and the honest fence on "root-seam ≅ node-seam" +- `ZeroParadox/Category/SeamComparisonMap.lean` - The canonical μ→ν comparison map at the root seam, and the root seam beside the node seam - `ZeroParadox/Category/SeamFrameChange.lean` - The frame-change in the category frame: `op`-duality swaps initial ↔ terminal at the seam - `ZeroParadox/Category/SeamGeneric.lean` - The seam as a GENERIC theorem (the μ=ν coincidence is a real categorical fact) - `ZeroParadox/Category/SeamLimColim.lean` - The seam diagram-level coincidence (lim = colim at the zero object) @@ -358,7 +375,6 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Category/SeamUniqueness.lean` - Seam uniqueness extended: is any OTHER bottom a zero object? - ride-along docs: `ZeroParadox/Category/SeamUniqueness.md` - Which named bottom is a zero object: the per-bottom obstructions and the fence - `ZeroParadox/Category/TopNoGo.lean` - In TopCat the empty space is not isomorphic to the one-point space -- `ZeroParadox/Category/TreeSeam.lean` - ZP-H tree — the #5 straddle resolved: the Hilbert bottom is the μ=ν seam - `ZeroParadox/Category/WellFoundedCoalgebra.lean` - The next time operator: μ/ν as an INTRINSIC property, not a construction ### Multi-homed bridges (ZP-H) @@ -373,7 +389,6 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Multihomed/SnapFrameChange.lean` - The tower limit's two chart-readings: ⊥ and ∞ are two charts, swapped by `rInv` - ride-along docs: `ZeroParadox/Multihomed/SnapFrameChange.md` - SnapFrameChange — the tower limit's two chart-readings - `ZeroParadox/Multihomed/SpanObstruction.lean` - The #1↔#3 cross-root obstruction under a SPAN (THIN-BUT-HONEST) -- `ZeroParadox/Multihomed/TreeObstructions.lean` - ZP-H: The bottom-diagram tree — machine-checked obstruction core (E4 + SPLIT, rebuilt) - `ZeroParadox/Multihomed/TreeT1.lean` - ZP-H tree, edge T1 — the within-μ edge: proof-theory floor ↔ categorical-initial bottoms - `ZeroParadox/Multihomed/TreeT2.lean` - ZP-H tree, edge T2 — the within-ν edge: Markov attractor ↔ p-adic inverse-limit - `ZeroParadox/Multihomed/TwoFacesBot.lean` - Direction B — the two faces of ⊥ at the seam: VACUOUS (they coincide, but only as a bare singleton) @@ -392,7 +407,7 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results - `ZeroParadox/Computability/ChoicePurityInvariant.lean` - Is choice-purity an IN-STATEMENT μ/ν separating invariant? - ride-along docs: `ZeroParadox/Computability/ChoicePurityInvariant.md` - ChoicePurityInvariant — ride-along documentation -- `ZeroParadox/Computability/CodeDataFrameChange.lean` - The frame-change in the computability frame: the code↔data involution and the quine on its fixed locus +- `ZeroParadox/Computability/CodeDataFrameChange.lean` - The frame-change in the computability frame: the code↔data involution, whose fixed locus holds every code's self-application - `ZeroParadox/Computability/ComputableCrossing.lean` - The Lawvere bridge, crossed in the computability face (probe) - ride-along docs: `ZeroParadox/Computability/ComputableCrossing.md` - Where the obstruction is absent: the universal machine as a reflexive object - `ZeroParadox/Computability/MarkovNuUniversal.lean` - Does the Markov node (#2) get a ν (terminal/unique-fixed-point) universal property? @@ -408,4 +423,4 @@ These carry the `-- EXPERIMENTAL` header: the exploratory work the core results --- -*Generated by `build_manifest.py` from the Lean tree + each file's `-- EXPERIMENTAL` header. Rerun after adding, moving, or renaming a file. (134 core, 106 experimental.)* +*Generated by `build_manifest.py` from the Lean tree + each file's `-- EXPERIMENTAL` header. Rerun after adding, moving, or renaming a file. (138 core, 111 experimental.)* diff --git a/ZeroParadox/Meta/AxiomLedger.lean b/ZeroParadox/Meta/AxiomLedger.lean index d88f61f6..765c5f69 100644 --- a/ZeroParadox/Meta/AxiomLedger.lean +++ b/ZeroParadox/Meta/AxiomLedger.lean @@ -13,8 +13,8 @@ This file is a gate on what we claim about which axioms our proofs use. We make `Statement:` elaborating this file fails unless every row below holds when recomputed by the auditor of `GuardianEngineAI/corpus` (vendored in `ZeroParadox/Vendored/CorpusAudit/`), and unless -every theorem of `ZeroParadox/Computability/KleeneChoiceFree.lean`, of -`ZeroParadox/Computability/UniversalChoiceFree.lean` and of this file has a row. +every non-auxiliary theorem (`Corpus.Audit.isAux` exempts by spelling) of +`ZeroParadox/Computability/KleeneChoiceFree.lean`, `UniversalChoiceFree.lean` and this file has a row. -/ open Lean @@ -43,12 +43,6 @@ theorem bridge_sqrt_le (new : type_of% @cf_sqrt_le) : type_of% @Nat.sqrt_le := n /-- `Statement:` `cf_lt_succ_sqrt`'s type implies `Nat.lt_succ_sqrt`'s. -/ theorem bridge_lt_succ_sqrt (new : type_of% @cf_lt_succ_sqrt) : type_of% @Nat.lt_succ_sqrt := new -/-- `Statement:` `cf_sqrt_iter_sq_le`'s type implies `Nat.sqrt.iter_sq_le`'s. -/ -theorem bridge_sqrt_iter_sq_le (new : type_of% @ZeroParadox.cf_sqrt_iter_sq_le) : - type_of% @Nat.sqrt.iter_sq_le := new -/-- `Statement:` `cf_sqrt_lt_iter_succ_sq`'s type implies `Nat.sqrt.lt_iter_succ_sq`'s. -/ -theorem bridge_sqrt_lt_iter_succ_sq (new : type_of% @ZeroParadox.cf_sqrt_lt_iter_succ_sq) : - type_of% @Nat.sqrt.lt_iter_succ_sq := new /-- `Statement:` `cf_sqrt_le_self`'s type implies `Nat.sqrt_le_self`'s. -/ theorem bridge_sqrt_le_self (new : type_of% @ZeroParadox.cf_sqrt_le_self) : type_of% @Nat.sqrt_le_self := new @@ -58,9 +52,6 @@ theorem bridge_unpair_left_le (new : type_of% @ZeroParadox.cf_unpair_left_le) : /-- `Statement:` `cf_unpair_right_le`'s type implies `Nat.unpair_right_le`'s. -/ theorem bridge_unpair_right_le (new : type_of% @ZeroParadox.cf_unpair_right_le) : type_of% @Nat.unpair_right_le := new -/-- `Statement:` `cf_div2_val`'s type implies `Nat.div2_val`'s. -/ -theorem bridge_div2_val (new : type_of% @ZeroParadox.cf_div2_val) : - type_of% @Nat.div2_val := new /-- `Statement:` `cf_eval_id`'s type implies `Nat.Partrec.Code.eval_id`'s. -/ theorem bridge_eval_id (new : type_of% @ZeroParadox.cf_eval_id) : type_of% @Nat.Partrec.Code.eval_id := new @@ -87,17 +78,12 @@ def replacements : List Corpus.Audit.Row := rep `ZeroParadox.AxiomLedger.cf_sqrt_le `ZeroParadox.AxiomLedger.bridge_sqrt_le `Nat.sqrt_le, rep `ZeroParadox.AxiomLedger.cf_lt_succ_sqrt `ZeroParadox.AxiomLedger.bridge_lt_succ_sqrt `Nat.lt_succ_sqrt, - rep `ZeroParadox.cf_sqrt_iter_sq_le `ZeroParadox.AxiomLedger.bridge_sqrt_iter_sq_le - `Nat.sqrt.iter_sq_le, - rep `ZeroParadox.cf_sqrt_lt_iter_succ_sq `ZeroParadox.AxiomLedger.bridge_sqrt_lt_iter_succ_sq - `Nat.sqrt.lt_iter_succ_sq, rep `ZeroParadox.cf_sqrt_le_self `ZeroParadox.AxiomLedger.bridge_sqrt_le_self `Nat.sqrt_le_self, rep `ZeroParadox.cf_unpair_left_le `ZeroParadox.AxiomLedger.bridge_unpair_left_le `Nat.unpair_left_le, rep `ZeroParadox.cf_unpair_right_le `ZeroParadox.AxiomLedger.bridge_unpair_right_le `Nat.unpair_right_le, - rep `ZeroParadox.cf_div2_val `ZeroParadox.AxiomLedger.bridge_div2_val `Nat.div2_val, rep `ZeroParadox.cf_eval_id `ZeroParadox.AxiomLedger.bridge_eval_id `Nat.Partrec.Code.eval_id, rep `ZeroParadox.cf_eval_curry `ZeroParadox.AxiomLedger.bridge_eval_curry @@ -110,8 +96,9 @@ def replacements : List Corpus.Audit.Row := -- Reading: a row compares two supplied proofs of one statement. It does not show that our -- profile is the least possible, nor that the predecessor's statement needs `Classical.choice`. -/-- `Statement:` declared profiles for `fpCF`, every other theorem of `KleeneChoiceFree.lean` -that replaces no Mathlib lemma, and every theorem of `UniversalChoiceFree.lean`. -/ +/-- `Statement:` declared profiles for every non-auxiliary theorem of `KleeneChoiceFree.lean` that +replaces no Mathlib lemma, every non-auxiliary theorem of `UniversalChoiceFree.lean`, and the `def`s `fpCF`, `ofNatCodeCF` and +`cfFinBound`, which coverage (theorems only) does not require. -/ def profiles : List Corpus.Audit.ProfileRow := let ours := ["Quot.sound", "propext"] [ ⟨`ZeroParadox.fpCF, []⟩, @@ -121,9 +108,13 @@ def profiles : List Corpus.Audit.ProfileRow := ⟨`ZeroParadox.const_not_quine_succ, ours⟩, ⟨`ZeroParadox.cf_amgm, ours⟩, ⟨`ZeroParadox.cf_sq_succ, ours⟩, + ⟨`ZeroParadox.cf_sqrt_iter_sq_le, ours⟩, + ⟨`ZeroParadox.cf_sqrt_lt_iter_succ_sq, ours⟩, + ⟨`Nat.sqrt.iter.eq_1, ["Quot.sound"]⟩, ⟨`ZeroParadox.cf_sqrt_isSqrt, ours⟩, ⟨`ZeroParadox.cf_sqrt_eq_of, ours⟩, ⟨`ZeroParadox.cf_bodd_add_div2, ours⟩, + ⟨`ZeroParadox.cf_div2_val, ours⟩, ⟨`ZeroParadox.cf_eval_succ, []⟩, ⟨`ZeroParadox.cf_eval_left, ours⟩, ⟨`ZeroParadox.cf_eval_right, ours⟩, @@ -154,7 +145,7 @@ def profiles : List Corpus.Audit.ProfileRow := ⟨`ZeroParadox.ofNatCodeCF_eq_ofNatCode, Corpus.Audit.stock⟩, ⟨`ZeroParadox.stmtOfNatCodeCFEq, Corpus.Audit.stock⟩, ⟨`ZeroParadox.boddNat_div2Nat_eq, ours⟩, - ⟨`ZeroParadox.boddNat_eq, []⟩, + ⟨`ZeroParadox.boddNat_eq, ours⟩, ⟨`ZeroParadox.cf_exists_code_mp, ours⟩, ⟨`ZeroParadox.cf_primrec_casesOn', ours⟩, ⟨`ZeroParadox.codeArg_add_four, []⟩, @@ -303,6 +294,7 @@ def profiles : List Corpus.Audit.ProfileRow := ⟨`ZeroParadox.encodeCode_lt_pair_left, ours⟩, ⟨`ZeroParadox.lt_encodeCode_selfUniv, ours⟩, ⟨`ZeroParadox.selfref_universal_unbounded_cf, ours⟩, + ⟨`ZeroParadox.cfFinBound, ["propext"]⟩, ⟨`ZeroParadox.cf_le_finBound, ["propext"]⟩, ⟨`ZeroParadox.selfref_universal_infinite_cf, ours⟩, ⟨`ZeroParadox.zero_selfPrints_not_universal, ours⟩, @@ -356,12 +348,9 @@ open ZeroParadox.AxiomLedger #print axioms bridge_pair_unpair #print axioms bridge_sqrt_le #print axioms bridge_lt_succ_sqrt -#print axioms bridge_sqrt_iter_sq_le -#print axioms bridge_sqrt_lt_iter_succ_sq #print axioms bridge_sqrt_le_self #print axioms bridge_unpair_left_le #print axioms bridge_unpair_right_le -#print axioms bridge_div2_val #print axioms bridge_eval_id #print axioms bridge_eval_curry #print axioms bridge_eval_prec_zero diff --git a/ZeroParadox/Miniature.lean b/ZeroParadox/Miniature.lean index 4bbceca6..1074c2e1 100644 --- a/ZeroParadox/Miniature.lean +++ b/ZeroParadox/Miniature.lean @@ -60,33 +60,32 @@ It reads top to bottom: **What the floor stands for — self-reference and the Quine atom.** This file represents the floor as bare fixed-point existence (`floor_of_witness`: a witness forces a fixed point; `cZero_has_fp`: the collapse fixes a -point). In the full framework that fixed point is a *self-referential* object — **the Quine atom** (Quine; -Aczel): the set that is its own only member, `⊥ = {⊥}`. It is one structural fact in several languages. Three -of them — the Quine atom (set theory / ZF+AFA), the order-bottom `⊥`, and the algebraic join-identity — are +point). In the full framework that fixed point is a *self-referential* object — **the Quine atom** (CC-2; Quine; +Aczel), a role: a point that steps to itself and to nothing else, in set theory a set x = {x}. Three faces — the Quine atom (set theory / ZF+AFA), the order-bottom `⊥`, and the algebraic join-identity — are proved to be the *same* element within a single carrier, axiom-free (`Settheory/SetTheoryAFA.lean` `t_exec_triple_iff`; its two-face half is `t_exec`); -the fourth, the Kleene quine (a program that prints itself, computability), is *joined* to them by an explicit -structural commitment — the `KleeneStructure` typeclass carries the computational fixed point as filling the -same role, without asserting an identity across types, not derived (`Computability/Kleene.lean`). +the fourth, the Kleene quine (a program that prints itself, computability), is compared with them through that +role, never by an identity: no code is equated with ⊥, and under the `eval` step no single code occupies the role +while, for computable `eval`-respecting maps, a class of codes does (`codes_vs_classes`, `Computability/Kleene.lean`). -**That fourth commitment is where time enters — and it is the easiest thing here to walk past.** The other +**That fourth face is where time can enter — and it is the easiest thing here to walk past.** The other three faces are *static*: order-bottom, self-membered set, algebraic identity are timeless facts that simply hold, and nothing about them ever *happens*. The Kleene quine is the only one that *runs*, and running is a -before and an after. So committing that the self-contained bottom is the self-executing bottom (⊥ is the -machine in its ground state, which must execute itself) is committing that **time enters the framework as a -state change**. It is what makes the framework dynamic at all: nothing static occurs on its own, so without -it ⊥ would rest as a fixed point forever and the snap would never happen. Stated as what it is — a -*commitment*, never a theorem — which is exactly why the computational face is joined by hand rather than -derived from the static three. The wall's seed here, `negation_no_fp` -(`¬(p ↔ ¬p)`), is that same self-reference *failing to close* (Cantor, Turing, Tarski); the floor is it +before and an after. The framework reads `bot` of the `ZPSemilattice` as its own executor if it executes at all; no +`KleeneStructure` field asserts it, and `da1_computational` proves only `IsQuineAtom bot` (`Computability/Kleene.lean`). +That it runs is the occurrence commitment, and with CC-1 it lets **time enter the framework as a state change** +(`Order/Snap.lean` `t_snap_given`: hypotheses `hcc1` and `hocc`, no `KleeneStructure`); nothing static occurs on its own, +so without them `bot` would rest as a fixed point forever and the snap would never happen. Stated as what they are — +*commitments*, never theorems — which is exactly why the running is committed to rather than derived from +the static three. The wall's seed here, `negation_no_fp` (`¬(p ↔ ¬p)`), is that same self-reference *failing to close* (Cantor, Turing, Tarski); the floor is it *closing* — landing on the thing that is its own answer. We show the *limited* version deliberately. The **shape** — self-reference forced either to a wall or to a self-referential floor — is what the minimal core exhibits, and a bare fixed point is enough to carry it. The -full Quine atom needs a non-well-founded set theory (ZF+AFA) to host `⊥ = {⊥}` literally; that host is the +full Quine atom needs a non-well-founded set theory (ZF+AFA) to host a set x = {x} literally; that host is the *flesh*, cited to its home, not rebuilt here. Honest split: the *structural* self-application fixed point is -Lean-proved and axiom-free (`t_exec`); the *literal* set-membership `⊥ = {⊥}` is a metatheoretic modeling -commitment (ZF+AFA), a theorem nowhere — the framework's own fence, kept here. +Lean-proved and axiom-free (`t_exec`); an equation between a lattice's ⊥ and a set is ill-typed and not asserted: the die's Quine-atom +role has its occupancy settled chart by chart (`ZeroParadox/Settheory/QuineDichotomy.lean`); hosting x = {x} in ZF+AFA is the commitment. **Honest status.** The *content* is re-derived, not new: the engine is **Lawvere (1969) / Yanofsky (2003)** (`Settheory/Wall.lean`); the classifier is `Category/DiagonalWitness.lean`; the four corners are @@ -131,8 +130,9 @@ def HasWitnessRel (β : Type u) (M : (β → β) → Prop) : Prop := ∃ (α : Type u) (e : α → (α → β)), ∀ g : β → β, M g → ∃ a, (fun x => g (e x x)) = e a /-- **The floor condition.** A witness forces every admissible endomap to have a fixed point — self-reference -*closes*. In the full framework that fixed point is the self-referential **Quine atom** `⊥ = {⊥}` / Kleene -quine (`Settheory/SetTheoryAFA.lean` `t_exec`); here it is bare existence — see the docstring's +*closes*. In the full framework that fixed point is the lattice's Quine atom, ⊥ (`Settheory/SetTheoryAFA.lean` +`t_exec`); the Kleene quine is compared with it through the Quine-atom role, not identified +(`Computability/Kleene.lean` § IX); here it is bare existence — see the docstring's "What the floor stands for". -/ theorem floor_of_witness {β : Type*} {M : (β → β) → Prop} (h : HasWitnessRel β M) {g : β → β} (hg : M g) : ∃ b, g b = b := by @@ -156,6 +156,8 @@ theorem witness_antitone {β : Type*} {M M' : (β → β) → Prop} /-! ### § III. The smallest concrete witness — the two-element pole and its four self-maps. -/ +-- [ZP port] Lean 4.35: Mathlib's `Fintype` deriving handler needs the pre-4.35 defeq transparency. +set_option backward.isDefEq.respectTransparency false in /-- The pole: the two-element type `{0, ∞}`. -/ inductive Pole where | zero diff --git a/ZeroParadox/Multihomed/Boundary.lean b/ZeroParadox/Multihomed/Boundary.lean index 51ff4f1f..a2f727ae 100644 --- a/ZeroParadox/Multihomed/Boundary.lean +++ b/ZeroParadox/Multihomed/Boundary.lean @@ -196,7 +196,7 @@ localized entirely at the floor, and the snap is the irreversible exit `floor MODELING CHOICE and introduces no new commitment — what that means, exactly: `ZeroParadox/Multihomed/Boundary.md`. -/ /-- The combined carrier: the self-looping floor, and the ordinal-indexed ascent. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: Illustrative single-carrier model for the well-foundedness boundary — floor (self-looping ⊥) + up : Ordinal → Phase (ε₀ ascent); phaseRel self-loops at the floor, follows ordinal < above it, snap := up 0 is the irreversible exit. Mathlib has no type bundling a non-well-founded floor with a well-founded ordinal ascent. A modeling choice (content = two proven endpoints + reading them as ZP's own ⊥ (the lattice chart's ⊥) and ε₀ respectively, a role assignment already carried: 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; no new commitment). In the carrier Ordinal the bottom role is filled by 0. The value Ordinal.epsilon 0, lifted as ↑ε₀, fills the ε₀ role, the first landing (a fixed point of the closure) 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 lattice chart's ⊥ endpoint (floorRel/floor_not_wellFounded) is axiom-free on the actual lattice. +-- [ZP-CUSTOM] carrier: WithBot Ordinal up to renaming (phaseEquivWithBot, ZeroParadox/Multihomed/BoundaryOrder.lean) | reason: Illustrative single-carrier model for the well-foundedness boundary — floor (self-looping ⊥) + up : Ordinal → Phase (ε₀ ascent). The carrier is Mathlib's WithBot Ordinal renamed; what is new is the relation phaseRel, which self-loops at the floor and follows ordinal < above it, and snap := up 0, the irreversible exit. A modeling choice (content = two proven endpoints + reading them as ZP's own ⊥ (the lattice chart's ⊥) and ε₀ respectively, a role assignment already carried: 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; no new commitment). In the carrier Ordinal the bottom role is filled by 0. The value Ordinal.epsilon 0, lifted as ↑ε₀, fills the ε₀ role, the first landing (a fixed point of that order's lift of nfp (ω ^ ·): phaseUpAndOver.up in WithBot Ordinal, snapNucleusTop in WithTop Ordinal) 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 lattice chart's ⊥ endpoint (floorRel/floor_not_wellFounded) is axiom-free on the actual lattice. inductive Phase where | floor : Phase | up : Ordinal → Phase diff --git a/ZeroParadox/Multihomed/Boundary.md b/ZeroParadox/Multihomed/Boundary.md index 806c4c12..9fae6fac 100644 --- a/ZeroParadox/Multihomed/Boundary.md +++ b/ZeroParadox/Multihomed/Boundary.md @@ -7,9 +7,9 @@ holds the declarations, the Engineer's Take and the per-declaration commentary. **CORE (promoted 2026-07-29, Tim's call).** Formerly a probe; promoted because its results are cited from `ZeroParadox/Settheory/Wall.md` as the adoption site for the descending-chain characterization, -and the infinite-pole declarations are machine-verified with measured footprints. Rung A of the -iterative A→B plan (`.claude-local/notes/wellfounded_coalgebra_foray_2026-06-23.md`) — Rung C, the full -Taylor coalgebraic statement, remains open and is **not** claimed. +and the infinite-pole declarations are machine-verified with measured footprints. The file carries Rung A +(the relation level, below) and Rung B (the single carrier, § "Rung B") of a three-rung plan; Rung C, +the full Taylor coalgebraic statement, remains open and is **not** claimed. Conjecture (Taylor/AMM framing): the snap ⊥→ε₀ crosses the **well-foundedness boundary** — from the non-well-founded floor (⊥ is the self-loop / back edge, where recursion cannot reach, Taylor Prop 111) @@ -29,7 +29,7 @@ infinity is, and the library supplies the answer: well-foundedness is equivalent **infinite descending chain**, so the same fact reads as *"an infinite descent issues from the floor."* That is the INFINITE pole of ⊥ in this face, and the one the self-loop form hides. -Standard form, read at source in the pinned Mathlib (`v4.30.0-rc2`) — `Mathlib/Order/WellFounded.lean`: +Standard form, read at source in the pinned Mathlib (`v4.35.0`) — `Mathlib/Order/WellFounded.lean`: * `wellFounded_iff_isEmpty_descending_chain` — `WellFounded r ↔ IsEmpty { f : ℕ → α // ∀ n, r (f (n+1)) (f n) }`. * `not_acc_iff_exists_descending_chain` — `¬ Acc r x ↔ ∃ f, f 0 = x ∧ ∀ n, r (f (n+1)) (f n)`; the **pointwise** version, which is what "at the floor" needs. @@ -174,11 +174,13 @@ 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). In the carrier `Ordinal` the bottom role is filled by 0. The value -`Ordinal.epsilon 0`, lifted as `↑ε₀`, fills the ε₀ role, the first landing (a fixed point of the -closure) strictly above a floor: in `WithBot Ordinal`, above the boundary model's floor placed at the +`Ordinal.epsilon 0`, lifted as `↑ε₀`, fills the ε₀ role, the first landing (a fixed point of +the lift of `nfp (ω ^ ·)` to each order: `phaseUpAndOver.up` on `WithBot Ordinal`, `snapNucleusTop` on +`WithTop Ordinal`) 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 +placed at the top, the first landing strictly above that order's least element, the snap `↑0` (`phaseTop_epsilon0_isLeast_landing_above_snap`; the two landing theorems and +`phaseUpAndOver` are in `ZeroParadox/Multihomed/BoundaryOrder.lean`, `snapNucleusTop` is in +`ZeroParadox/Ordinal/SnapMetaLattice.lean`). In `Ordinal` that value differs from the bottom role's occupant 0 (`epsilon0_ne_bot`, `epsilon0_ne_zero`). The floor endpoint is tied to the lattice chart's ⊥ (`floor_not_wellFounded`, axiom-free); the abstract `Phase` carrier is the illustrative toy form, with non-well-foundedness localized at the floor diff --git a/ZeroParadox/Multihomed/BoundaryOrder.lean b/ZeroParadox/Multihomed/BoundaryOrder.lean index 7cfd264b..5515d95d 100644 --- a/ZeroParadox/Multihomed/BoundaryOrder.lean +++ b/ZeroParadox/Multihomed/BoundaryOrder.lean @@ -131,7 +131,7 @@ example : ∃ f : Phase → Ordinal.{0}, Function.Injective f ∧ exact ⟨fun _ => lt_of_lt_of_le (pos_iff_ne_zero.2 hb) le_self_add, fun _ => pos_iff_ne_zero.2 hb⟩ · subst hb; rw [if_neg ha, if_pos rfl] - exact ⟨fun h => absurd h (not_lt.2 (zero_le _)), fun h => absurd h (not_lt.2 (zero_le _))⟩ + exact ⟨fun h => absurd h (not_lt.2 (zero_le)), fun h => absurd h (not_lt.2 (zero_le))⟩ · rw [if_neg ha, if_neg hb, ← Order.succ_eq_add_one, ← Order.succ_eq_add_one] exact Order.succ_lt_succ_iff.symm have key : ∀ b, (1 : Ordinal) ≠ f (Phase.up b) := fun b h => by @@ -196,7 +196,7 @@ theorem phaseTop_epsilon0_isLeast_landing_above_snap : refine ⟨fun x => ?_, ⟨?_, ?_⟩, ?_⟩ · induction x using WithTop.recTopCoe with | top => exact le_top - | coe a => exact WithTop.coe_le_coe.2 (zero_le a) + | coe a => exact WithTop.coe_le_coe.2 (zero_le (a := a)) · show WithTop.map _ ((epsilonZero : Ordinal) : WithTop Ordinal) = _ rw [WithTop.map_coe]; exact congrArg _ (Ordinal.nfp_eq_self epsilonZero_fixedPoint) · exact WithTop.coe_lt_coe.2 (Ordinal.epsilon_pos 0) @@ -248,19 +248,32 @@ example : (phaseRel Phase.floor Phase.floor ∧ ¬ Acc phaseRel Phase.floor) ∧ /-! ### § II. The lifted closure -/ +section +-- [ZP port] Lean 4.35: Mathlib's `WithBot` orders carry `Classical.choice`; scope `ZeroParadox/Order/ChoiceFreeWithTop.lean`'s. +attribute [local instance high] withBotPreorderCF withBotPartialOrderCF + /-- `Statement:` a closure operator `c` on `α` lifts to `WithBot α` by `WithBot.map c`, fixing the adjoined `⊥ : WithBot α`; its monotone part is Mathlib's `OrderHom.withBotMap`. -/ def withBotClosure {α : Type*} [PartialOrder α] (c : ClosureOperator α) : ClosureOperator (WithBot α) := - ClosureOperator.mk' (WithBot.map c) c.monotone.withBot_map + ClosureOperator.mk' (WithBot.map c) + (fun x y h => by + induction x using WithBot.recBotCoe with + | bot => exact WithBot.LE.bot_le _ + | coe a => + induction y using WithBot.recBotCoe with + | bot => cases h + | coe b => + cases h with + | coe_le_coe h => exact WithBot.LE.coe_le_coe (c.monotone h)) (fun x => by induction x using WithBot.recBotCoe with | bot => exact le_rfl - | coe a => exact WithBot.coe_le_coe.2 (c.le_closure a)) + | coe a => exact WithBot.LE.coe_le_coe (c.le_closure a)) (fun x => by induction x using WithBot.recBotCoe with | bot => exact le_rfl - | coe a => exact WithBot.coe_le_coe.2 (c.idempotent a).le) + | coe a => exact WithBot.LE.coe_le_coe (c.idempotent a).le) -- `Statement:` the lift's underlying map is `OrderHom.withBotMap` of `c`. example {α : Type*} [PartialOrder α] (c : ClosureOperator α) : @@ -272,6 +285,8 @@ theorem withBotClosure_apply {α : Type*} [PartialOrder α] (c : ClosureOperator withBotClosure c ⊥ = ⊥ ∧ ∀ a : α, withBotClosure c a = (c a : WithBot α) := ⟨rfl, fun _ => rfl⟩ +end + /-! ### § III. The instance on the floor-below member: the corner at the floor `Reading:` selected: this file's order and `phaseUpAndOver` use the floor-below member. -/ @@ -283,13 +298,13 @@ theorem withBotClosure_apply {α : Type*} [PartialOrder α] (c : ClosureOperator noncomputable def phaseUpAndOver : UpAndOver (WithBot Ordinal) where up := withBotClosure ordinalUpAndOver.up corner := ⟨⊥, ((0 : Ordinal) : WithBot Ordinal), (withBotClosure _).isClosed_iff.2 rfl, - WithBot.bot_covBy_coe.2 (fun b _ => zero_le b), fun h => by + WithBot.bot_covBy_coe.2 (fun b _ => zero_le (a := b)), fun h => by have h' : Ordinal.nfp (fun a => Ordinal.omega0 ^ a) 0 = 0 := WithBot.coe_injective h rw [← epsilonZero_eq_nfp] at h' exact epsilon0_ne_zero h'⟩ cover := fun y _ _ => by induction y using WithBot.recBotCoe with - | bot => exact ⟨_, WithBot.bot_covBy_coe.2 (fun b _ => zero_le b)⟩ + | bot => exact ⟨_, WithBot.bot_covBy_coe.2 (fun b _ => zero_le (a := b))⟩ | coe o => exact ⟨((Order.succ o : Ordinal) : WithBot Ordinal), WithBot.coe_covBy_coe.2 (Order.covBy_succ o)⟩ @@ -302,7 +317,7 @@ theorem phase_floor_isBot : IsBot (phaseEquivWithBot Phase.floor) := /-- `Statement:` the snap covers the boundary model's floor: `⊥ ⋖ ↑0` in `WithBot Ordinal`, nothing strictly between (Mathlib `WithBot.bot_covBy_coe`, at the ordinals' least element `0`). -/ theorem phase_floor_covBy_snap : phaseEquivWithBot Phase.floor ⋖ phaseEquivWithBot snap := - WithBot.bot_covBy_coe.2 (fun b _ => zero_le b) + WithBot.bot_covBy_coe.2 (fun b _ => zero_le (a := b)) /-- `Statement:` the tower operator `ω^·` lifted to `WithBot Ordinal`, fixing the floor `⊥ : WithBot Ordinal`. -/ @@ -314,7 +329,7 @@ noncomputable def phaseTower : WithBot Ordinal → WithBot Ordinal := theorem phase_epsilon0_isLeastFixedPointFrom_snap : IsLeastFixedPointFrom (· ≤ ·) phaseTower (phaseEquivWithBot snap) ((epsilonZero : Ordinal) : WithBot Ordinal) := by - refine ⟨WithBot.coe_le_coe.2 (zero_le _), ?_, fun b hb hle => ?_⟩ + refine ⟨WithBot.coe_le_coe.2 (zero_le), ?_, fun b hb hle => ?_⟩ · show ((Ordinal.omega0 ^ epsilonZero : Ordinal) : WithBot Ordinal) = _ rw [epsilonZero_fixedPoint] · induction b using WithBot.recBotCoe with @@ -346,7 +361,7 @@ theorem phaseUp_zero_eq_one : = phaseUpAndOver.up ((1 : Ordinal) : WithBot Ordinal) := by show ((Ordinal.nfp (fun a => Ordinal.omega0 ^ a) 0 : Ordinal) : WithBot Ordinal) = ((Ordinal.nfp (fun a => Ordinal.omega0 ^ a) 1 : Ordinal) : WithBot Ordinal) - rw [nfp_seed_independent_below_epsilon0 0 (zero_le _), + rw [nfp_seed_independent_below_epsilon0 0 (zero_le), nfp_seed_independent_below_epsilon0 1 (Order.one_le_iff_ne_zero.2 epsilon0_ne_zero)] -- `Statement:` the closure is idempotent and not injective (`UpAndOver.up_not_injective`). diff --git a/ZeroParadox/Multihomed/CategoricalBridge.lean b/ZeroParadox/Multihomed/CategoricalBridge.lean index 4760a778..efceee31 100644 --- a/ZeroParadox/Multihomed/CategoricalBridge.lean +++ b/ZeroParadox/Multihomed/CategoricalBridge.lean @@ -121,12 +121,13 @@ ZPC characterizes it as infinite accumulation: ∑ I(X_k → X_{k+1}) diverges a sequence approaching 0 (t2_diverges). These are compatible: domain-absence is strictly stronger than divergence — if infinite accumulation is required to reach 0, no finite morphism can accomplish it, which is exactly hom(X, 0) = ∅. Both sides are independently -derived. Their joint derivability closes OQ-G4. -/ +derived. That both hold together (a conjunction, not a derivation of one from the other) closes OQ-G4. -/ -/-- T-H2: Both singularity characterizations are jointly derivable. +/-- T-H2: Both singularity characterizations hold together. Part I (ZPG side): hom(X, 0) = ∅ for any X not isomorphic to 0 — domain-absent. Part II (ZPC side): accumulated surprisal along sequences approaching 0 diverges. - The conjunction establishes compatibility: same structural obstruction, two vantages. -/ + `Statement:` a pair `⟨t3_unreachability X hne, t2_diverges⟩`, not a joint derivation: Part II + mentions none of `C`, `X` or the initial object, so neither conjunct is derived from the other. -/ theorem th2_singularity_compatibility {C : Type*} [Category C] [zpcat : ZPCategory C] (X : C) (hne : IsEmpty (X ≅ zpcat.zpInitial)) : IsEmpty (X ⟶ zpcat.zpInitial) ∧ @@ -262,7 +263,7 @@ instance nnrealOrderCat : Category NNReal where /-- Every morphism out of 0 exists and is unique (zero_le). -/ instance nnrealHom0Unique (y : NNReal) : Unique ((0 : NNReal) ⟶ y) where - default := ⟨⟨zero_le y⟩⟩ + default := ⟨⟨zero_le (a := y)⟩⟩ uniq := fun _ => Subsingleton.elim _ _ /-- ℝ≥0 is a ZPCategory with 0 as initial object. @@ -275,7 +276,7 @@ noncomputable instance nnrealZPCategory : ZPCategory NNReal where have h : t + 1 ≤ t := (ht.from (t + 1)).down.down exact absurd h (not_le.mpr (lt_add_of_pos_right t one_pos))⟩ ax_g2 := fun x hne => ⟨fun f => by - have hx0 : x = 0 := le_antisymm f.down.down (zero_le x) + have hx0 : x = 0 := le_antisymm f.down.down (zero_le (a := x)) subst hx0; exact hne.elim (Iso.refl (0 : NNReal))⟩ /-- Shared concrete ZPCategory witness for F_B, F_C, and F_D. @@ -381,10 +382,10 @@ theorem q2Ball_antitone {n m : Q₂BallDepth} (h : n.val ≤ m.val) : exact zpow_le_zpow_right₀ (by norm_num : (1 : ℝ) ≤ 2) (by omega : -(↑m.val : ℤ) ≤ -(↑n.val : ℤ)) -/-- Semantic grounding of fb_functor's snap morphism 0 → ⟨1⟩: - For any x ∈ B(0, 2^(-1)) with x ≠ 0, C3 (ZPB) guarantees no continuous path - returns from x to 0 in Q₂: the topological analogue of AX-G2 in Q₂BallDepth, which `q2BallZPCat` - proves by antisymmetry. -/ +/-- Semantic grounding of fb_functor's snap morphism 0 → ⟨1⟩: by C3 (ZPB) no continuous path + returns from x ≠ 0 to 0 in Q₂, the topological analogue of AX-G2 (`q2BallZPCat`, antisymmetry). + `Statement:` the ball hypothesis `x ∈ q2BallAt ⟨1⟩` is unused by the proof: the content is + `c3_irreversible`'s, which carries no ball hypothesis. -/ theorem fb_snap_q2_grounded : ∀ x : Q₂, x ∈ q2BallAt ⟨1⟩ → x ≠ 0 → ¬∃ γ : C(Set.Icc (0 : ℝ) 1, Q₂), @@ -475,7 +476,9 @@ noncomputable instance infoDepthZPCat : ZPCategory InfoDepth where /-- Semantic grounding of fc_functor's snap morphism 0 → ⟨1⟩: T1b (ZPC) establishes that the P → Q snap costs exactly log 2 (1 bit of JSD). This is the informational analogue of AX-G2 in InfoDepth, where no morphism returns to - depth 0 (`infoDepthZPCat`, by antisymmetry): the snap advances from zero surprisal to one bit. -/ + depth 0 (`infoDepthZPCat`, by antisymmetry): the snap advances from zero surprisal to one bit. + `Statement:` a pair `⟨morphism 0 ⟶ ⟨1⟩ in InfoDepth, t1b_jsd⟩`, not a joint derivation: the two + conjuncts share no variable, and neither is derived from the other. -/ theorem fc_snap_info_grounded : Nonempty ((0 : InfoDepth) ⟶ ⟨1⟩) ∧ jsdPQ = Real.log 2 := ⟨⟨⟨⟨Nat.zero_le 1⟩⟩⟩, t1b_jsd⟩ @@ -563,10 +566,10 @@ noncomputable instance hilbDimZPCat : ZPCategory HilbDimDepth where subst hn exact hne.elim (Iso.refl _)⟩ -/-- Semantic grounding of fd_functor's snap morphism 0 → ⟨1⟩: - T4 (ZPD) establishes that the snap produces an orthogonal shift in StateSpace n (n ≥ 2): - ⟪T(0), T(ε₀)⟫_ℂ = 0. The dimension advance 0 → 1 in HilbDimDepth corresponds to - the step from the vector `transitionOp n ⟨0⟩` = T(0) to the orthogonal `transitionOp n ⟨1⟩`. -/ +/-- Semantic grounding of fd_functor's snap morphism 0 → ⟨1⟩: T4 (ZPD) gives an orthogonal shift + in StateSpace n (n ≥ 2), ⟪T(0), T(ε₀)⟫_ℂ = 0, read as the dimension advance 0 → 1 here. + `Statement:` a pair `⟨morphism 0 ⟶ ⟨1⟩, t4_snap_orthogonal n hn⟩`, not a joint derivation: the + first conjunct mentions neither `n` nor `StateSpace n`; neither is derived from the other. -/ theorem fd_snap_hilb_grounded (n : ℕ) (hn : 2 ≤ n) : Nonempty ((0 : HilbDimDepth) ⟶ ⟨1⟩) ∧ @inner ℂ (StateSpace n) _ diff --git a/ZeroParadox/Multihomed/CategoricalBridge.md b/ZeroParadox/Multihomed/CategoricalBridge.md index 5ce2a849..e5258c05 100644 --- a/ZeroParadox/Multihomed/CategoricalBridge.md +++ b/ZeroParadox/Multihomed/CategoricalBridge.md @@ -28,6 +28,8 @@ Key results: 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, for the named bottoms, in a lattice with no top). - T-H2: Categorical singularity (domain-absent) and ZPC singularity (divergent - accumulation) are compatible — jointly derivable (OQ-G4 closed). + accumulation) hold together: `th2_singularity_compatibility` pairs the two independently proved + theorems (`t3_unreachability`, `t2_diverges`), and neither is derived from the other (OQ-G4 closed in + that sense). - T-H3: Binary Snap described consistently under all four functors. Fully proved by assembling independently proved domain theorems. diff --git a/ZeroParadox/Multihomed/InfoFunctor.lean b/ZeroParadox/Multihomed/InfoFunctor.lean index 1db8508d..655d5350 100644 --- a/ZeroParadox/Multihomed/InfoFunctor.lean +++ b/ZeroParadox/Multihomed/InfoFunctor.lean @@ -65,9 +65,14 @@ noncomputable def fC_functor : ℕ ⥤ KleisliCat PMF where map_id n := by funext i simp [fC_map, KleisliCat.id_def] + rfl map_comp f g := by funext i - simp [fC_map, KleisliCat.comp_def] + show (pure (Fin.castLE _ i) : PMF (Fin _)) = + (pure (Fin.castLE (leOfHom f) i) : PMF (Fin _)) >>= + fun j => (pure (Fin.castLE (leOfHom g) j) : PMF (Fin _)) + rw [pure_bind] + rfl /-- ⊥ = `Fin 0` is the genuine initial object of `KleisliCat PMF`: there is exactly one stochastic map out of the empty type. -/ @@ -82,7 +87,7 @@ noncomputable def fC_zero_isInitial : Limits.IsInitial (fC_functor.obj 0) := by theorem fC_no_return {n : ℕ} (hn : 0 < n) : IsEmpty (fC_functor.obj n ⟶ fC_functor.obj 0) := by refine ⟨fun f => ?_⟩ - have hsum : ∑' a : Fin 0, (f ⟨0, hn⟩) a = 1 := PMF.tsum_coe _ + have hsum := PMF.tsum_coe (show PMF (Fin 0) from f ⟨0, hn⟩) rw [tsum_empty] at hsum exact zero_ne_one hsum diff --git a/ZeroParadox/Multihomed/MC1Bridge.lean b/ZeroParadox/Multihomed/MC1Bridge.lean index 8df7ba9a..e138db6e 100644 --- a/ZeroParadox/Multihomed/MC1Bridge.lean +++ b/ZeroParadox/Multihomed/MC1Bridge.lean @@ -18,9 +18,14 @@ Identification with the same symbology is a commitment of this framework. --- ## Formal Overview -The correspondence half of MC-1 over the real domain categories (`TopCat`, `ModuleCat ℂ`, `KleisliCat PMF`): each -domain bottom is the categorical bottom of its own category, bundled in `mc1_correspondence`. The literal cross-category -identity is retired as ill-typed. Halves, prior art and positioning: `ZeroParadox/Multihomed/MC1Bridge.md`. +The correspondence half of MC-1 over the real domain categories, per category (the three full positions are stated together in +`floor_positions_full`, `ZeroParadox/Category/TreeSeam.lean`): the floor is a zero object (`Statement:` COINCIDENCE, initial and terminal at once) +in `ModuleCat ℂ`; initial and +not terminal in `KleisliCat PMF`; in `TopCat` terminal (it has one point; `padic_bottom_isTerminal`) and not +initial (`padic_bottom_not_initial`), and separately the limit of the ball tower (`floorConeIsLimit`). +`mc1_correspondence` bundles two `IsInitial` fields, the no-return field and the `TopCat` set equation. The +literal cross-category identity is retired as ill-typed. Halves, prior art and positioning: +`ZeroParadox/Multihomed/MC1Bridge.md`. -/ namespace ZeroParadox @@ -28,31 +33,33 @@ namespace ZeroParadox open CategoryTheory ZeroParadox ZeroParadox ZeroParadox ZeroParadox /-! ### NO-GO gauge — `MC1Correspondence` is a BUNDLED WITNESS, not a requirements class. -It takes no parameter, so no carrier can fail to be a member — that follows from the missing -parameter, not from Prop-ness: two of its four fields are `IsInitial` **data**, which is why -`MC1Correspondence : Type 1` and `mc1_correspondence` is a `def`, the one inhabitant. +It takes no parameter, so no carrier can fail to be a member — that follows from the missing parameter, not from Prop-ness: +two of its four fields are `IsInitial` **data**, which is why `MC1Correspondence : Type 1` and `mc1_correspondence` is a `def`, the one inhabitant. ⚠ **The reading it must not license.** Bundling the three bottoms into one term does **not** make them one object — that identity is **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`, for the named bottoms, in a lattice with no top). The bundle establishes the **correspondence** half: each -domain bottom is the categorical bottom of its own real Mathlib category. Cite the fields, never the bundle's existence. -/ - -/-- The MC-1 correspondence over the real domain categories: the snap floor is the categorical - bottom (initial object / inverse limit) of each domain's genuine Mathlib category, and the - information bottom admits no return morphism. Bundles the three real-category realizations. - This is the correspondence half of MC-1; the literal cross-category identity is not asserted. -/ +(`seam_unique_among_named`, for the named bottoms, in a lattice with no top). The **correspondence** half, per category: two +`IsInitial` fields, and for `TopCat` a set equation; that floor is terminal (one point; `padic_bottom_isTerminal`), not initial (`padic_bottom_not_initial`). +Cite the fields, never the bundle's existence. -/ + +/-- The MC-1 correspondence over the real domain categories, as four fields: the snap floor is + initial in F_D's `ModuleCat ℂ` and in F_C's `KleisliCat PMF`; no stage `n > 0` of `fC_functor` maps + into stage 0; and F_B's floor is pinned by a set equation in ℚ₂ (`top_limit`; the `TopCat` limit is + `floorConeIsLimit`, outside the bundle). This is the correspondence half of MC-1; the literal + cross-category identity is not asserted. -/ structure MC1Correspondence : Type _ where /-- F_D: in `ModuleCat ℂ`, the snap floor `StateSpace 0` is the genuine initial (zero) object. -/ hilb_initial : Limits.IsInitial (fD_functor.obj 0) /-- F_C: in `KleisliCat PMF`, the snap floor `Fin 0` is the genuine initial object. -/ info_initial : Limits.IsInitial (fC_functor.obj 0) - /-- F_C: AX-G2 realized — no stochastic map returns into the snap floor from a nonempty object. -/ + /-- F_C: AX-G2 realized — no stochastic map into the snap floor from a stage `n > 0` of `fC_functor`. -/ info_no_return : ∀ {n : ℕ}, 0 < n → IsEmpty (fC_functor.obj n ⟶ fC_functor.obj 0) - /-- F_B: in `TopCat`, the snap floor is the inverse limit of the clopen-ball system. -/ + /-- F_B: the clopen balls `q2Ball n` of ℚ₂ intersect exactly in `{0}`. A set equation, not a limit + cone in `TopCat`; that cone is `floorConeIsLimit` (`ZeroParadox/Order/PadicLimitCone.lean`). -/ top_limit : (⋂ n, q2Ball n) = {(0 : Q₂)} -/-- The witness: all three real-category realizations hold simultaneously. -/ +/-- The witness: the four fields hold simultaneously. -/ noncomputable def mc1_correspondence : MC1Correspondence where hilb_initial := fD_zero_isInitial info_initial := fC_zero_isInitial diff --git a/ZeroParadox/Multihomed/MC1Bridge.md b/ZeroParadox/Multihomed/MC1Bridge.md index 10d02cf2..47e38526 100644 --- a/ZeroParadox/Multihomed/MC1Bridge.md +++ b/ZeroParadox/Multihomed/MC1Bridge.md @@ -7,8 +7,11 @@ per-declaration commentary. The results are described at each declaration, not l MC-1 is the cross-framework claim about the four domain bottoms. It was stated in two halves, and the second is retired: -* a **correspondence** half: each domain's bottom is the categorical bottom (initial object or inverse limit) of that - domain's own real structure, and the four agree on the snap; +* a **correspondence** half: each domain's floor has a categorical characterization in that domain's own real + category, and it differs by category: a zero object (`Statement:` COINCIDENCE, initial and terminal at once) in `ModuleCat ℂ`, initial and not + terminal in `KleisliCat PMF`, terminal and not initial in `TopCat`; the three full positions are stated together in + `floor_positions_full` (`ZeroParadox/Category/TreeSeam.lean`: a zero object; initial and not terminal; terminal and not + initial); the four agree on the snap; * a **literal-identity** half: the four bottoms are numerically one object across four different categories. That identity is **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`, @@ -21,14 +24,16 @@ The **correspondence half, over the real domain categories**. Earlier, ZP-H exhi categories (`Q₂BallDepth`, `InfoDepth`, `HilbDimDepth`). Here the snap floor is realized inside the genuine Mathlib categories: -* **F_B / `TopCat`** (`fB_functor`): ⊥ is the inverse limit of the clopen-ball system, - `⋂ n, B(0,2⁻ⁿ) = {0}` (`fB_bottom_is_limit`). `TopCat` has a terminal object, so the honest statement is "limit", - not "initial". -* **F_D / `ModuleCat ℂ`** (`fD_functor`): ⊥ = `StateSpace 0` is the genuine initial (zero) object (`fD_zero_isInitial`), - and the embeddings are isometric (`fD_embed_inner`). +* **F_B / `TopCat`** (`fB_functor`): ⊥ is the inverse limit of the clopen-ball system, as a limit cone + in `TopCat` (`floorConeIsLimit`, `ZeroParadox/Order/PadicLimitCone.lean`); the set equation beneath it + is `⋂ n, B(0,2⁻ⁿ) = {0}` (`fB_bottom_is_limit`). `{0}` is terminal in `TopCat` (it has one point; + `padic_bottom_isTerminal`) and not initial (`padic_bottom_not_initial`), so "initial" is false here; the limit + statement is `floorConeIsLimit`. +* **F_D / `ModuleCat ℂ`** (`fD_functor`): ⊥ = `StateSpace 0` is the genuine initial object (`fD_zero_isInitial`) and a + zero object, terminal as well (`hilbert_bottom_isZero`); the embeddings are isometric (`fD_embed_inner`). * **F_C / `KleisliCat PMF`** (`fC_functor`): ⊥ = `Fin 0` is the genuine initial object (`fC_zero_isInitial`), and there - is **no** stochastic map back into it (`fC_no_return`). That is AX-G2 realized as a theorem, the snap's - irreversibility. + is **no** stochastic map into it from any later stage of the functor (`fC_no_return`), so it is not terminal + (`kleisli_bottom_not_terminal`). That is AX-G2 realized as a theorem, the snap's irreversibility. `F_A` (the join-semilattice ℕ with 0 initial) is already in `ZeroParadox/Multihomed/CategoricalBridge.lean`. It is omitted here only to keep ℕ's category instance unambiguous, not for any mathematical reason. @@ -42,17 +47,25 @@ None of the categorical structure here is new. - A *strict* initial object is one where every morphism into it is an isomorphism; nLab cites Carboni–Lack–Walters 1993, Def. 2.7, for strict initial objects. `fC_no_return` is scoped to the functor's image: it states `IsEmpty (fC_functor.obj n ⟶ fC_functor.obj 0)` for `0 < n`, not strict initiality in the whole category. -- F_B's `⋂ B(0,2⁻ⁿ) = {0}` is the standard 2-adic inverse limit (ℤ₂ = lim ℤ/2ⁿ). -- F_D's zero module is the zero/initial object of an abelian category. +- F_B's `⋂ B(0,2⁻ⁿ) = {0}` is the standard fact that nested closed balls about a point with radii + tending to 0 meet in that point; the inverse system here is of subspace inclusions, not the + quotient system of the presentation ℤ₂ = lim ℤ/2ⁿ. That `{0}` with its inclusions is then a limit cone + (`floorConeIsLimit`) is the standard computation of limits in `Top` on underlying sets with the initial topology + (Mathlib `TopCat.limitCone`, `TopCat.limitConeIsLimit`); the proof here builds the cone directly rather than + through them. +- F_D's zero module is the zero object (`Statement:` COINCIDENCE, initial and terminal at once) of an abelian category; Mathlib + `ModuleCat.isZero_of_subsingleton`. -ZP-H's contribution is not new category theory but the cross-domain *assembly*: each ZP bottom realized as its own real -category's categorical bottom, agreeing on the snap. +ZP-H's contribution is not new category theory but the cross-domain *assembly*: each ZP floor characterized in its own +real category, at a different position in each (above), agreeing on the snap. ## What the witness does and does not say -`mc1_correspondence` bundles these into one witness. It is the **correspondence** half only. It is *not* claimed that -the four bottoms are one object, which is retired as ill-typed; the claim is only that each is the categorical bottom of -its own real category and that they agree on the snap. This is the same discipline the framework applies elsewhere, with one difference kept visible: +`mc1_correspondence` bundles two `IsInitial` fields (`ModuleCat ℂ`, `KleisliCat PMF`), the no-return field +(`fC_no_return`) and the `TopCat` set equation (`fB_bottom_is_limit`) into one witness; `floorConeIsLimit`, +`padic_bottom_isTerminal` and `padic_bottom_not_initial` sit outside it. It is the **correspondence** half only. It is +*not* claimed that the four bottoms are one object, which is retired as ill-typed; the claim is only the per-category +characterization above and that they agree on the snap. This is the same discipline the framework applies elsewhere, with one difference kept visible: - AX-1 is retired. Its shape is proved as T-SNAP, and that the snap occurs follows from the occurrence commitment together with DA-1 (closed given DP-2); that commitment remains. The identity reading leaves nothing to commit to: diff --git a/ZeroParadox/Multihomed/SeparatedSuccession.lean b/ZeroParadox/Multihomed/SeparatedSuccession.lean index 1d89b4e0..839770ad 100644 --- a/ZeroParadox/Multihomed/SeparatedSuccession.lean +++ b/ZeroParadox/Multihomed/SeparatedSuccession.lean @@ -8,7 +8,7 @@ set_option maxHeartbeats 400000 The snap's succession of **targets** — its **iterative bottoms** — shows up in two charts of the framework that are DIFFERENT TYPES. (Iterative bottom: a bottom relative to its iteration, the base the next snap -re-seeds above, never ⊥ itself. `ε₀ ≠ ⊥` is bedrock, `epsilon0_ne_bot`. The qualifier carries the role +re-seeds above, never ⊥ of `Ordinal` itself. `ε₀ ≠ ⊥` of `Ordinal` is bedrock, `epsilon0_ne_bot`. The qualifier carries the role without asserting the identity; standardized 2026-07-19.) - the **ordinal chart** — the ε-numbers `ε₀ < ε₁ < ε₂ < …`, consecutive ones separated by strict order (`ZeroParadox/Ordinal/SnapSuccession.lean`, `succession_lt_succ`); @@ -32,7 +32,7 @@ of which each structure is a witness — the Yoneda/representability reading), b that both are witnesses of one interface — and the honest fence that the carriers are provably distinct types, so the shared shape is the interface, never a cross-type `=`. One asymmetry is kept visible: the ordinal implementation separates unconditionally, the Hilbert one only given a genuine-transition sequence -(consecutive states distinct). +(consecutive states distinct). The two sit at different universe levels of the interface (see below). ## Engineer's Take @@ -123,6 +123,15 @@ noncomputable def hilbertSuccession (n : ℕ) (S : ℕ → Fin n) (hS : ∀ k, S sep_irrefl_on_seq := fun k => by simp [transitionOp, basisVec] +-- Statement: the ordinal implementation is a term of the interface at universe level 1. +noncomputable example : SeparatedSuccession.{1} := ordinalSuccession +-- Statement: the Hilbert implementation is a term of it at level 0, so the two are not terms of one +-- type and one list holds both only after a lift of a carrier (for example by `ULift`). Such a lift +-- was not located in the corpus as of 2026-11-03, searched `ZeroParadox/**/*` for the identifiers +-- `SeparatedSuccession`, `ordinalSuccession`, `hilbertSuccession`, for `ULift`, and for "same/common universe". +noncomputable example (n : ℕ) (S : ℕ → Fin n) (hS : ∀ k, S k ≠ S (k + 1)) : SeparatedSuccession.{0} := + hilbertSuccession n S hS + /-! ### Faithfulness of the enumeration — an IMPLEMENTATION split **Origin (Tim, 2026-08-05): "succession is a state of representation."** Step 0 measured the diff --git a/ZeroParadox/Multihomed/SnapFrameChange.lean b/ZeroParadox/Multihomed/SnapFrameChange.lean index 2482395c..093715d0 100644 --- a/ZeroParadox/Multihomed/SnapFrameChange.lean +++ b/ZeroParadox/Multihomed/SnapFrameChange.lean @@ -1,4 +1,4 @@ --- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the valuation-frame realization of the POLE EXCHANGE (the snap-as-instance reading is ZP-Q's conjecture, not established here - see the declaration docstring) — P8's tower encoding sends the ω-tower (climbing to ε₀) to the 2-adic floor 0 = ⊥: its stage-encodings converge to 0 in the encoding chart (reading that floor as a NEW bottom ⊥ₙ₊₁ is C-DA2, a commitment no theorem here carries), while the SAME encodings, viewed through the Riemann-sphere frame-change rInv (0↔∞), diverge to the antipode ∞. rInv is the passage between the two charts. (The encodings converge to ⊥; ε₀, the ordinal sup of the stages, is never ⊥ — ε₀ ≠ ⊥.) Conjectural synthesis at the operator/space level; the abstract cross-domain "snap = frame-change" stays open. Curated results indexed in ZeroParadox/MANIFEST.md. +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the valuation-frame realization of the POLE EXCHANGE (the snap-as-instance reading is ZP-Q's conjecture, not established here - see the declaration docstring) — P8's tower encoding sends the ω-tower (climbing to ε₀) to ℤ_[2]'s 0, least under the 2-adic norm preorder and greatest under the valuation preorder (z2_two_views): its stage-encodings converge to 0 in the encoding chart (reading that floor as a NEW bottom ⊥ₙ₊₁ is C-DA2, a commitment no theorem here carries), while the SAME encodings, viewed through the Riemann-sphere frame-change rInv (0↔∞), diverge to the antipode ∞. rInv is the passage between the two charts. (The encodings converge to ℤ_[2]'s 0; ε₀, the ordinal sup of the stages, has no encoding and no equation with that 0 (different carriers), and in Ordinal ε₀ ≠ ⊥ of Ordinal, epsilon0_ne_bot.) Conjectural synthesis at the operator/space level; the abstract cross-domain "snap = frame-change" stays open. Curated results indexed in ZeroParadox/MANIFEST.md. import ZeroParadox.Ordinal.P8 import ZeroParadox.Valuation.RiemannSphere import Mathlib.Tactic @@ -43,7 +43,7 @@ theorem snap_frameflip_tower_tendsto_infty : have hq : Tendsto (fun k => (((cnf_encode (towerOrd k)) : ℤ_[2]) : ℚ_[2])) atTop (𝓝 (0 : ℚ_[2])) := by have hc : Continuous (fun z : ℤ_[2] => (z : ℚ_[2])) := continuous_subtype_val - simpa using (hc.tendsto (0 : ℤ_[2])).comp h0 + simpa [Function.comp_def] using (hc.tendsto (0 : ℤ_[2])).comp h0 -- Push into the sphere `OnePoint ℚ₂`. have hs : Tendsto (fun k => OnePoint.some (((cnf_encode (towerOrd k)) : ℤ_[2]) : ℚ_[2])) atTop (𝓝 (OnePoint.some (0 : ℚ_[2]))) := @@ -61,7 +61,7 @@ theorem snap_frameflip_tower_tendsto_infty : is the authority. THE SNAP DOES NOT APPEAR IN THIS STATEMENT.** There is no `c₀ → c₁`, no `bot ⋖ a`, no `⊥ → ε₀` here. - `Statement:` a three-part conjunction about ONE sequence — the ω-tower's encodings converge to `0` in + `Statement:` **INVERSION** — a three-part conjunction about ONE sequence — the ω-tower's encodings converge to `0` in the encoding chart; the SAME encodings diverge to `∞` under `rInv`; and `rInv` exchanges the two poles. So: one object, two chart-readings, and a chart map swapping them. @@ -71,7 +71,8 @@ theorem snap_frameflip_tower_tendsto_infty : the layer's older framing did, and it is what produced the standing puzzle that a frame flip is an involution (reversible) while the snap is one-way. That mismatch is what an identification would have to resolve; ZP-Q holds it open rather than settling it either way. - (ε₀ ≠ ⊥: the encodings converge to ⊥, they do not realize ε₀ as ⊥.) -/ + `Statement:` **CARRIER** — the encodings converge to ℤ_[2]'s `0`; they do not realize ε₀ there, and + ε₀ ≠ ⊥ of `Ordinal` (`epsilon0_ne_bot`). -/ theorem snap_is_frameflip : Tendsto (fun k => cnf_encode (towerOrd k)) atTop (𝓝 (0 : ℤ_[2])) ∧ Tendsto (fun k => rInv (OnePoint.some (((cnf_encode (towerOrd k)) : ℤ_[2]) : ℚ_[2]))) diff --git a/ZeroParadox/Multihomed/SnapFrameChange.md b/ZeroParadox/Multihomed/SnapFrameChange.md index 2ded9aee..b7aafbb0 100644 --- a/ZeroParadox/Multihomed/SnapFrameChange.md +++ b/ZeroParadox/Multihomed/SnapFrameChange.md @@ -10,11 +10,14 @@ Two prior results meet here. **P8** (`ZeroParadox/Ordinal/P8.lean`) built the tower-rank encoding `cnf_encode : {α < ε₀} → ℤ₂` and proved that the ω-tower's encodings converge to `0` (`cnf_encode_tower_tendsto_zero`): the -tower climbing to `ε₀` has stage-encodings that land on the 2-adic floor `0 = ⊥`, so in this -**encoding chart** the ascent to `ε₀` resolves onto the bottom. - -⚠ The encodings **converge to** ⊥; `ε₀` is not ⊥ (`ε₀ ≠ ⊥`). And reading that floor as a **NEW** -bottom ⊥ₙ₊₁ is **C-DA2, a commitment** — no theorem here carries it, and in this very chart +tower climbing to `ε₀` has stage-encodings that land on ℤ_[2]'s `0`, so in this **encoding +chart** the ascent to `ε₀` resolves onto that `0`. Name the order before calling it a bottom: `0` is +least under the 2-adic norm preorder and greatest under the valuation preorder (`z2_two_views`). + +⚠ The encodings **converge to** ℤ_[2]'s `0`; `ε₀` has no encoding and no equation with that `0` +(different carriers); and `ε₀` is not ⊥ of `Ordinal` (`epsilon0_ne_bot`). And reading ℤ_[2]'s `0` as a +**NEW** bottom ⊥ₙ₊₁ of the norm preorder (it is the greatest element under the valuation preorder, +`z2_two_views`) is **C-DA2, a commitment** — no theorem here carries it, and in this very chart `snap_arc_z2_loop` has the arc returning to the **same** `0`. `t_iz_limit_is_new_null` proves the ROLE half only and must never be cited as a novelty witness (the `t_iz_limit_is_new_null` gloss in `Order/SnapCannotBe.lean`). @@ -37,7 +40,7 @@ encoding chart and rises to the antipode `∞` in the `rInv` chart, and `rInv` i them. `Statement:` **INVERSION** — `snap_is_frameflip` bundles both limits with the `0 ↔ ∞` swap: the -descent to ⊥ and the ascent to ∞ are the *same* tower-encodings under the frame-change. +descent to `0` and the ascent to ∞ are the *same* tower-encodings under the frame-change. ## Fences diff --git a/ZeroParadox/Multihomed/TopNumEdge.lean b/ZeroParadox/Multihomed/TopNumEdge.lean index 842acbd4..dad284d3 100644 --- a/ZeroParadox/Multihomed/TopNumEdge.lean +++ b/ZeroParadox/Multihomed/TopNumEdge.lean @@ -79,10 +79,11 @@ theorem info_points_enter_every_ball (n : ℕ) : and information (depth points, B3) ALL enter every ball around the single floor `0 ∈ ℤ₂`, via their real structural encodings. With E1 (ball = valuation sublevel) and `fB_bottom_is_limit` (⋂ balls = {0}), all of {proof, computation, information, topology, number-theory} co-locate at the one floor — the p-adic - cluster as a COMPLETE correspondence subgraph (every pair meets at the floor). This is CORRESPONDENCE - (agreement under the shared 2-adic encoding), NOT the identity claim "they are literally one object" - (which stays the modeling commitment — the dotted ring on the map). The encodings are not designed to - hit 0; they hit it because the bottoms are genuinely floors, so the co-location has content. -/ + cluster as a COMPLETE correspondence subgraph (every pair meets at the floor): CORRESPONDENCE inside + one carrier, ℤ_[2]; no identity of the domains' bottoms across their own carriers is stated (ill-typed, + MC-1). Separately, 0 is the only point stepping to itself only under doubling + (`z2_double_selfOnlyAt_iff`, `ZeroParadox/Ordinal/Incompleteness.lean`). The encodings hit 0 + because the bottoms are floors. -/ theorem padic_cluster_colocates_at_floor (n : ℕ) : (∀ᶠ k in Filter.atTop, ZeroParadox.cnf_encode (ZeroParadox.towerOrd k) @@ -110,8 +111,8 @@ theorem info_valuation_eq_surprisal (n : ℕ) : categorical REALIZATION, and its snap bottom is a proven categorical object — the information and Hilbert bottoms are INITIAL objects (`fC_zero_isInitial`, `fD_zero_isInitial`), and the topology bottom is the inverse LIMIT of the ball system (`fB_bottom_is_limit`, `⋂ = {0}`). This is the MC-1 *correspondence* - half (derived, not the identity commitment): category-theory connects DIRECTLY to the three realized - domains, making it a second hub alongside the p-adic floor. Bundles existing witnesses. -/ + half (derived; the identity half is retired as ill-typed): category-theory connects DIRECTLY to the + three realized domains, making it a second hub alongside the p-adic floor. Bundles existing witnesses. -/ theorem category_realizes_bottoms : Nonempty (CategoryTheory.Limits.IsInitial (ZeroParadox.fC_functor.obj 0)) ∧ Nonempty (CategoryTheory.Limits.IsInitial (ZeroParadox.fD_functor.obj 0)) ∧ diff --git a/ZeroParadox/Multihomed/TreeObstructions.lean b/ZeroParadox/Multihomed/TreeObstructions.lean index 16840f76..2e6e73a7 100644 --- a/ZeroParadox/Multihomed/TreeObstructions.lean +++ b/ZeroParadox/Multihomed/TreeObstructions.lean @@ -1,4 +1,3 @@ --- EXPERIMENTAL (branch scaffolding): bottom-diagram probe campaign, not a finalized layer. Curated/load-bearing results are indexed in ZeroParadox/BottomCannotBe.lean and classified in ZeroParadox/MANIFEST.md. import ZeroParadox.State.HilbFunctor import ZeroParadox.Valuation.TopFunctor import ZeroParadox.Multihomed.InfoFunctor @@ -121,9 +120,10 @@ theorem padic_bottom_not_initial : have f := hinit.to (TopCat.of Empty) exact (f.hom ⟨0, rfl⟩).elim --- Statement: that one-point space `{0} ⊆ Q₂` IS a terminal object of `TopCat`: Mathlib's --- `TopCat.isTerminalPUnit` transported along the homeomorphism between two one-point spaces. -example : Nonempty (Limits.IsTerminal (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) := +/-- Statement: the one-point space `{0} ⊆ Q₂` is a terminal object of `TopCat` (Mathlib's + `TopCat.isTerminalPUnit` transported along a homeomorphism of one-point spaces). -/ +theorem padic_bottom_isTerminal : + Nonempty (Limits.IsTerminal (TopCat.of (↥({(0 : Q₂)} : Set Q₂)))) := ⟨TopCat.isTerminalPUnit.ofIso (TopCat.isoOfHomeo (Homeomorph.homeomorphOfUnique _ _))⟩ -- Statement: `TopCat`'s initial object is the empty space, and it satisfies the AX-G2 shape: a space @@ -185,6 +185,7 @@ open ZeroParadox #print axioms no_strictMono_real_to_ordinal #print axioms simplex_antichain #print axioms padic_bottom_not_initial +#print axioms padic_bottom_isTerminal #print axioms split_kleisli_vs_hilbert #print axioms split_kleisli_vs_padic #print axioms fD_zero_isTerminal diff --git a/ZeroParadox/Multihomed/WallSpanRobust.lean b/ZeroParadox/Multihomed/WallSpanRobust.lean index 010515a6..ca89f822 100644 --- a/ZeroParadox/Multihomed/WallSpanRobust.lean +++ b/ZeroParadox/Multihomed/WallSpanRobust.lean @@ -130,8 +130,7 @@ theorem faithful_iff_descending {S : Type u} (r : S → S → Prop) : constructor · rintro ⟨f, hf⟩; exact apex_wf_of_strictMono_to_ordinal r f hf · intro hwf - haveI : IsWellFounded S r := ⟨hwf⟩ - exact ⟨IsWellFounded.rank r, fun a b hab => IsWellFounded.rank_lt_of_rel hab⟩ + exact ⟨WellFounded.rank r, fun a b hab => WellFounded.rank_lt_of_rel hab⟩ end ZeroParadox diff --git a/ZeroParadox/Order/ChoiceFreeWithTop.lean b/ZeroParadox/Order/ChoiceFreeWithTop.lean new file mode 100644 index 00000000..8b3ac5c0 --- /dev/null +++ b/ZeroParadox/Order/ChoiceFreeWithTop.lean @@ -0,0 +1,163 @@ +import Mathlib.Order.WithBot +import Mathlib.Tactic + +/-! +# Choice-free orders on `WithTop α` and `WithBot α` + +`Preorder`, `PartialOrder`, `OrderBot`, `OrderTop` on `WithTop α` and `WithBot α` over Mathlib's bare +`instLE`/`instLT`, so `≤` and `<` are Mathlib's; fields proved by cases on the constructors, where +Mathlib's go through `le_def` (`grind`, `Classical.choice`). `abbrev`s: opt in with +`attribute [local instance high]`. + +## Engineer's Take + +So this is a re-implementation to avoid classical.choice we do relationship operators between top elements, created. Specifically because classical.Choice is introduced into our footprint otherwise + +--- +-/ + +namespace ZeroParadox + +set_option maxHeartbeats 400000 + +universe u + +variable {α : Type u} + +/-! ### § I. `WithTop α` -/ + +/-- `Statement:` the `Preorder` on `WithTop α` over `WithTop.instLE`/`instLT`; not an instance. -/ +abbrev withTopPreorderCF [Preorder α] : Preorder (WithTop α) where + toLE := WithTop.instLE + toLT := WithTop.instLT + le_refl x := by + cases x with + | top => exact WithTop.LE.le_top _ + | coe a => exact WithTop.LE.coe_le_coe (le_refl a) + le_trans x y z hxy hyz := by + change WithTop.LE x y at hxy + change WithTop.LE y z at hyz + cases hyz with + | le_top => exact WithTop.LE.le_top _ + | coe_le_coe hyz => + cases hxy with + | coe_le_coe hxy => exact WithTop.LE.coe_le_coe (le_trans hxy hyz) + lt_iff_le_not_ge x y := by + change WithTop.LT x y ↔ WithTop.LE x y ∧ ¬ WithTop.LE y x + constructor + · intro h + cases h with + | lt_top a => exact ⟨WithTop.LE.le_top _, fun h => by cases h⟩ + | coe_lt_coe h => + exact ⟨WithTop.LE.coe_le_coe (lt_iff_le_not_ge.1 h).1, + fun h' => by cases h' with | coe_le_coe h' => exact (lt_iff_le_not_ge.1 h).2 h'⟩ + · rintro ⟨h, h'⟩ + cases h with + | le_top => cases x with + | top => exact absurd (WithTop.LE.le_top _) h' + | coe a => exact WithTop.LT.lt_top a + | coe_le_coe h => + exact WithTop.LT.coe_lt_coe + (lt_iff_le_not_ge.2 ⟨h, fun h'' => h' (WithTop.LE.coe_le_coe h'')⟩) + +/-- `Statement:` the `PartialOrder` on `WithTop α` extending `withTopPreorderCF`; not an instance. -/ +abbrev withTopPartialOrderCF [PartialOrder α] : PartialOrder (WithTop α) where + toPreorder := withTopPreorderCF + le_antisymm x y hxy hyx := by + change WithTop.LE x y at hxy + change WithTop.LE y x at hyx + cases hxy with + | le_top => cases hyx with + | le_top => rfl + | coe_le_coe hxy => cases hyx with + | coe_le_coe hyx => exact congrArg _ (le_antisymm hxy hyx) + +/-- `Statement:` ⊤ of `WithTop α` is greatest under `WithTop.instLE`; not an instance. -/ +abbrev withTopOrderTopCF [LE α] : @OrderTop (WithTop α) WithTop.instLE where + toTop := inferInstance + le_top := WithTop.LE.le_top + +/-- `Statement:` `↑⊥` is least in `WithTop α` under `WithTop.instLE`; not an instance. -/ +abbrev withTopOrderBotCF [LE α] [OrderBot α] : @OrderBot (WithTop α) WithTop.instLE where + toBot := inferInstance + bot_le x := by + cases x with + | top => exact WithTop.LE.le_top _ + | coe a => exact WithTop.LE.coe_le_coe bot_le + +/-! ### § II. `WithBot α` -/ + +/-- `Statement:` the `Preorder` on `WithBot α` over `WithBot.instLE`/`instLT`; not an instance. -/ +abbrev withBotPreorderCF [Preorder α] : Preorder (WithBot α) where + toLE := WithBot.instLE + toLT := WithBot.instLT + le_refl x := by + cases x with + | bot => exact WithBot.LE.bot_le _ + | coe a => exact WithBot.LE.coe_le_coe (le_refl a) + le_trans x y z hxy hyz := by + change WithBot.LE x y at hxy + change WithBot.LE y z at hyz + cases hxy with + | bot_le => exact WithBot.LE.bot_le _ + | coe_le_coe hxy => + cases hyz with + | coe_le_coe hyz => exact WithBot.LE.coe_le_coe (le_trans hxy hyz) + lt_iff_le_not_ge x y := by + change WithBot.LT x y ↔ WithBot.LE x y ∧ ¬ WithBot.LE y x + constructor + · intro h + cases h with + | bot_lt b => exact ⟨WithBot.LE.bot_le _, fun h => by cases h⟩ + | coe_lt_coe h => + exact ⟨WithBot.LE.coe_le_coe (lt_iff_le_not_ge.1 h).1, + fun h' => by cases h' with | coe_le_coe h' => exact (lt_iff_le_not_ge.1 h).2 h'⟩ + · rintro ⟨h, h'⟩ + cases h with + | bot_le => cases y with + | bot => exact absurd (WithBot.LE.bot_le _) h' + | coe b => exact WithBot.LT.bot_lt b + | coe_le_coe h => + exact WithBot.LT.coe_lt_coe + (lt_iff_le_not_ge.2 ⟨h, fun h'' => h' (WithBot.LE.coe_le_coe h'')⟩) + +/-- `Statement:` the `PartialOrder` on `WithBot α` extending `withBotPreorderCF`; not an instance. -/ +abbrev withBotPartialOrderCF [PartialOrder α] : PartialOrder (WithBot α) where + toPreorder := withBotPreorderCF + le_antisymm x y hxy hyx := by + change WithBot.LE x y at hxy + change WithBot.LE y x at hyx + cases hxy with + | bot_le => cases hyx with + | bot_le => rfl + | coe_le_coe hxy => cases hyx with + | coe_le_coe hyx => exact congrArg _ (le_antisymm hxy hyx) + +/-- `Statement:` ⊥ of `WithBot α` is least under `WithBot.instLE`; not an instance. -/ +abbrev withBotOrderBotCF [LE α] : @OrderBot (WithBot α) WithBot.instLE where + toBot := inferInstance + bot_le := WithBot.LE.bot_le + +/-- `Statement:` `↑⊤` is greatest in `WithBot α` under `WithBot.instLE`; not an instance. -/ +abbrev withBotOrderTopCF [LE α] [OrderTop α] : @OrderTop (WithBot α) WithBot.instLE where + toTop := inferInstance + le_top x := by + cases x with + | bot => exact WithBot.LE.bot_le _ + | coe a => exact WithBot.LE.coe_le_coe le_top + +end ZeroParadox + +section PurityCheck +open ZeroParadox + +#print axioms withTopPreorderCF +#print axioms withTopPartialOrderCF +#print axioms withTopOrderTopCF +#print axioms withTopOrderBotCF +#print axioms withBotPreorderCF +#print axioms withBotPartialOrderCF +#print axioms withBotOrderBotCF +#print axioms withBotOrderTopCF + +end PurityCheck diff --git a/ZeroParadox/Order/DieJoints.lean b/ZeroParadox/Order/DieJoints.lean new file mode 100644 index 00000000..12c06958 --- /dev/null +++ b/ZeroParadox/Order/DieJoints.lean @@ -0,0 +1,373 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): cut points of an order approached from one side and not reached there (joints and dual joints), with ⊤ and 0 of ℝ≥0∞, ⊤ of ℕ∞, NInf's ∞, the valuation of ℤ_[2]'s 0, and ε₀ as instances. Curated results indexed in ZeroParadox/MANIFEST.md. + +import ZeroParadox.Die +import ZeroParadox.Ordinal.Epsilon0MinMax +import ZeroParadox.Valuation.Scale +import Mathlib.Basic.ENNReal.Inv +import Mathlib.Tactic + +set_option maxHeartbeats 400000 + +/-! +# Joints and dual joints: cut points approached from one side and not reached there + +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. + +--- + +## Formal Overview (AI-assisted) +Cut points, joints and dual joints of an order (§ I), exchanged by the order dual (§ II); exclusions +(§ III); the ends of `ℝ≥0∞` and `ℕ∞` (§ IV); order-reversing maps and the 2-adic pole (§ V); +`PinnedLimit`, NInf's ∞ and ε₀ (§ VI). A shared shape only: no equation between these points. +-/ + +namespace ZeroParadox + +/-! ### § I. Cut points, joints, dual joints +`Reading:` "joint" here names the order-theoretic shape only; whether it is the joint of Tim's +2026-10-22 read (`ZeroParadox/DieCannotBe.lean` § I) is not claimed. At the canonical cut of a linear +order, `IsJoint` is Mathlib's `Order.IsSuccLimit` and `IsDualJoint` is `Order.IsPredLimit` (the two +`example`s after the definitions); the general form is over an arbitrary pair `(A, B)`. -/ + +section Defs + +variable {α : Type*} [Preorder α] + +/-- `Statement:` `A` lies below `B`, and `x` is the least upper bound of `A` and the greatest lower + bound of `B`. -/ +-- [ZP-CUSTOM] no Mathlib analog | reason: a conjunction of Mathlib's `IsLUB` and `IsGLB` at one point +-- for a pair of sets; Mathlib's `DedekindCut` is the completion's cut, not a point of the carrier. +def IsCutPoint (A B : Set α) (x : α) : Prop := + (∀ a ∈ A, ∀ b ∈ B, a ≤ b) ∧ IsLUB A x ∧ IsGLB B x + +/-- `Statement:` a cut point of `(A, B)` lying in `B`, with `A` nonempty and without a greatest + element. -/ +-- [ZP-CUSTOM] extends: IsCutPoint (ZeroParadox/Order/DieJoints.lean) | reason: the one-sided form +-- over an arbitrary pair, approached from below and not reached there; at the canonical cut +-- `(Set.Iio x, Set.Ici x)` of a linear order it is Mathlib's `Order.IsSuccLimit x`. +def IsJoint (A B : Set α) (x : α) : Prop := + IsCutPoint A B x ∧ A.Nonempty ∧ (¬ ∃ m, IsGreatest A m) ∧ x ∈ B + +/-- `Statement:` a cut point of `(A, B)` lying in `A`, with `B` nonempty and without a least + element. -/ +-- [ZP-CUSTOM] extends: IsCutPoint (ZeroParadox/Order/DieJoints.lean) | reason: the mirror of +-- `IsJoint`, approached from above and not reached there; at the canonical cut +-- `(Set.Iic x, Set.Ioi x)` of a linear order it is Mathlib's `Order.IsPredLimit x`. +def IsDualJoint (A B : Set α) (x : α) : Prop := + IsCutPoint A B x ∧ B.Nonempty ∧ (¬ ∃ m, IsLeast B m) ∧ x ∈ A + +end Defs + +-- `Statement:` in a linear order, `a` is a joint of (`Set.Iio a`, `Set.Ici a`) iff `a` is a +-- successor limit (`Order.IsSuccLimit`); both directions. +example {α : Type*} [LinearOrder α] (a : α) : + IsJoint (Set.Iio a) (Set.Ici a) a ↔ Order.IsSuccLimit a := by + constructor + · rintro ⟨⟨-, hl, -⟩, ⟨b, hb⟩, -, -⟩ + exact ⟨fun h => absurd (h (le_of_lt hb)) (not_le.2 hb), Order.isLUB_Iio_iff_isSuccPrelimit.1 hl⟩ + · intro h + refine ⟨⟨fun x hx y hy => (le_of_lt hx).trans hy, h.isLUB_Iio, isGLB_Ici⟩, ?_, ?_, le_refl a⟩ + · obtain ⟨b, hb⟩ := not_isMin_iff.1 h.not_isMin; exact ⟨b, hb⟩ + · rintro ⟨m, hm, hmax⟩ + exact absurd (h.isLUB_Iio.2 hmax) (not_le.2 hm) + +-- `Statement:` in a linear order, `a` is a dual joint of (`Set.Iic a`, `Set.Ioi a`) iff `a` is a +-- predecessor limit (`Order.IsPredLimit`); both directions. +example {α : Type*} [LinearOrder α] (a : α) : + IsDualJoint (Set.Iic a) (Set.Ioi a) a ↔ Order.IsPredLimit a := by + constructor + · rintro ⟨⟨-, -, hg⟩, ⟨b, hb⟩, -, -⟩ + exact ⟨fun h => absurd (h (le_of_lt hb)) (not_le.2 hb), Order.isGLB_Ioi_iff_isPredPrelimit.1 hg⟩ + · intro h + refine ⟨⟨fun x hx y hy => hx.trans (le_of_lt hy), isLUB_Iic, h.isGLB_Ioi⟩, ?_, ?_, le_refl a⟩ + · obtain ⟨b, hb⟩ := not_isMax_iff.1 h.not_isMax; exact ⟨b, hb⟩ + · rintro ⟨m, hm, hmin⟩ + exact absurd (h.isGLB_Ioi.2 hmin) (not_le.2 hm) + +/-! ### § II. The order dual exchanges joints and dual joints +`Reading:` INVERSION. Q2: the arrow is the order; run backwards (`αᵒᵈ`) a joint reads as a dual +joint and back. Q1: the § IV pair, 0 and ⊤ of `ℝ≥0∞`, exchanged by `x ↦ x⁻¹` (§ V). -/ + +/-- `Statement:` `x` is a joint of `(B, A)` in `αᵒᵈ` iff it is a dual joint of `(A, B)` in `α`; + both directions. -/ +theorem isJoint_toDual_iff {α : Type*} [Preorder α] (A B : Set α) (x : α) : + IsJoint (α := αᵒᵈ) (OrderDual.ofDual ⁻¹' B) (OrderDual.ofDual ⁻¹' A) (OrderDual.toDual x) ↔ + IsDualJoint A B x := by + constructor + · rintro ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ + exact ⟨⟨fun a ha b hb => hAB b hb a ha, hg, hl⟩, hne, fun ⟨m, hm⟩ => hng ⟨m, hm⟩, hx⟩ + · rintro ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ + exact ⟨⟨fun b hb a ha => hAB a ha b hb, hg, hl⟩, hne, fun ⟨m, hm⟩ => hng ⟨m, hm⟩, hx⟩ +-- `Reading:` at the canonical cut (§ I) Mathlib's form is `Order.isSuccLimit_toDual_iff`. + +/-- `Statement:` `x` is a dual joint of `(B, A)` in `αᵒᵈ` iff it is a joint of `(A, B)` in `α`; + both directions. -/ +theorem isDualJoint_toDual_iff {α : Type*} [Preorder α] (A B : Set α) (x : α) : + IsDualJoint (α := αᵒᵈ) (OrderDual.ofDual ⁻¹' B) (OrderDual.ofDual ⁻¹' A) (OrderDual.toDual x) ↔ + IsJoint A B x := by + constructor + · rintro ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ + exact ⟨⟨fun a ha b hb => hAB b hb a ha, hg, hl⟩, hne, fun ⟨m, hm⟩ => hng ⟨m, hm⟩, hx⟩ + · rintro ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ + exact ⟨⟨fun b hb a ha => hAB a ha b hb, hg, hl⟩, hne, fun ⟨m, hm⟩ => hng ⟨m, hm⟩, hx⟩ + +/-! ### § III. Exclusions: a least point is never a joint; a well-order has no dual joint -/ + +/-- `Statement:` if `x` is least in a preorder, then `x` is a joint of no `(A, B)`. -/ +theorem not_isJoint_of_isBot {α : Type*} [Preorder α] {x : α} (hx : IsBot x) (A B : Set α) : + ¬ IsJoint A B x := by + rintro ⟨⟨-, hl, -⟩, ⟨a, ha⟩, hng, -⟩ + exact hng ⟨a, ha, fun b hb => (hl.1 hb).trans (hx a)⟩ +-- `Reading:` at the canonical cut (§ I) Mathlib's form is `IsMin.not_isSuccLimit`. + +/-- `Statement:` if `x` is greatest in a preorder, then `x` is a dual joint of no `(A, B)`. -/ +theorem not_isDualJoint_of_isTop {α : Type*} [Preorder α] {x : α} (hx : IsTop x) (A B : Set α) : + ¬ IsDualJoint A B x := by + rintro ⟨⟨-, -, hg⟩, ⟨b, hb⟩, hng, -⟩ + exact hng ⟨b, hb, fun c hc => (hx b).trans (hg.1 hc)⟩ + +/-- `Statement:` if a linear order is well-founded (`WellFoundedLT`), then nothing in it is a dual + joint. -/ +theorem not_isDualJoint_of_wellFoundedLT {α : Type*} [LinearOrder α] [WellFoundedLT α] + (A B : Set α) (x : α) : ¬ IsDualJoint A B x := by + rintro ⟨-, hne, hng, -⟩ + obtain ⟨m, hm, hmin⟩ := (wellFounded_lt (α := α)).has_min B hne + exact hng ⟨m, hm, fun b hb => not_lt.1 (hmin b hb)⟩ + +-- `Statement:` the instance at `Ordinal`: nothing in `Ordinal` is a dual joint. +example (A B : Set Ordinal.{0}) (x : Ordinal.{0}) : ¬ IsDualJoint A B x := + not_isDualJoint_of_wellFoundedLT A B x + +-- `Statement:` CONTROL: linearity is a premise. `Finset Bool` is well-founded and not linear, and +-- `∅` is a dual joint of (`{∅}`, `{{true}, {false}}`), whose two points are incomparable. +example : WellFoundedLT (Finset Bool) ∧ + IsDualJoint ({∅} : Set (Finset Bool)) {{true}, {false}} ∅ := by + refine ⟨inferInstance, ⟨?_, isLUB_singleton, ?_, ?_⟩, ⟨{true}, Or.inl rfl⟩, ?_, rfl⟩ + · rintro a rfl b - + exact Finset.empty_subset b + · rintro b - + exact Finset.empty_subset b + · intro y hy b hb + have h1 := hy (Or.inl rfl) hb + have h2 := hy (Or.inr rfl) hb + simp only [Finset.mem_singleton] at h1 h2 + exact absurd (h1.symm.trans h2) (by decide) + · rintro ⟨m, hm, hmin⟩ + have h1 : m ≤ {true} := hmin (Or.inl rfl) + have h2 : m ≤ {false} := hmin (Or.inr rfl) + rcases hm with rfl | rfl + · exact absurd h2 (by decide) + · exact absurd h1 (by decide) + +/-! ### § IV. The ends of `ℝ≥0∞` and `ℕ∞` -/ + +/-- `Statement:` ⊤ of `ℝ≥0∞` is a joint of (the finite values, `{⊤}`). -/ +theorem ennreal_top_isJoint : IsJoint {x : ENNReal | x ≠ ⊤} {⊤} (⊤ : ENNReal) := by + refine ⟨⟨fun a _ b hb => hb ▸ le_top, ⟨fun _ _ => le_top, fun y hy => ?_⟩, + ⟨fun b hb => hb ▸ le_rfl, fun y _ => le_top⟩⟩, ⟨0, ENNReal.zero_ne_top⟩, ?_, rfl⟩ + · by_contra h + have hyt : y ≠ ⊤ := fun e => h (e ▸ le_rfl) + have h1 : y + 1 ≠ ⊤ := ENNReal.add_ne_top.2 ⟨hyt, ENNReal.one_ne_top⟩ + exact absurd (hy h1) (not_le.2 (ENNReal.lt_add_right hyt one_ne_zero)) + · rintro ⟨m, hm, hmax⟩ + have h1 : m + 1 ≠ ⊤ := ENNReal.add_ne_top.2 ⟨hm, ENNReal.one_ne_top⟩ + exact absurd (hmax h1) (not_le.2 (ENNReal.lt_add_right hm one_ne_zero)) + +/-- `Statement:` 0 of `ℝ≥0∞` is a dual joint of (`{0}`, the positive values). -/ +theorem ennreal_zero_isDualJoint : IsDualJoint {(0 : ENNReal)} {x : ENNReal | 0 < x} 0 := by + refine ⟨⟨fun a ha b hb => ha ▸ hb.le, ⟨fun a ha => ha ▸ le_rfl, fun y hy => hy rfl⟩, + ⟨fun b hb => zero_le, fun y hy => ?_⟩⟩, ⟨1, show (0 : ENNReal) < 1 from zero_lt_one⟩, ?_, rfl⟩ + · by_contra h + have hpos : 0 < y := not_le.1 h + have hyt : y ≠ ⊤ := fun e => absurd (hy (show (0 : ENNReal) < 1 from zero_lt_one)) + (by rw [e]; exact not_le.2 ENNReal.one_lt_top) + have := hy (show (0 : ENNReal) < y / 2 from ENNReal.half_pos hpos.ne') + exact absurd this (not_le.2 (ENNReal.half_lt_self hpos.ne' hyt)) + · rintro ⟨m, hm, hmin⟩ + have hm0 : m ≠ 0 := (show (0 : ENNReal) < m from hm).ne' + by_cases hmt : m = ⊤ + · exact absurd (hmin (show (0 : ENNReal) < 1 from zero_lt_one)) + (by rw [hmt]; exact not_le.2 ENNReal.one_lt_top) + · exact absurd (hmin (show (0 : ENNReal) < m / 2 from ENNReal.half_pos hm0)) + (not_le.2 (ENNReal.half_lt_self hm0 hmt)) + +-- `Statement:` 0 of `ℝ≥0∞` is ⊥ of `ℝ≥0∞`, so it is a joint of no `(A, B)` (`not_isJoint_of_isBot`). +example (A B : Set ENNReal) : ¬ IsJoint A B 0 := not_isJoint_of_isBot (fun _ => zero_le) A B + +/-- `Statement:` on `ℝ≥0∞`, `x ↦ x⁻¹` reverses the order, sends ⊤ to 0 and 0 to ⊤, and `x⁻¹` is + positive iff `x ≠ ⊤`. -/ +theorem ennreal_inv_exchanges : + (∀ a b : ENNReal, a⁻¹ ≤ b⁻¹ ↔ b ≤ a) ∧ (⊤ : ENNReal)⁻¹ = 0 ∧ (0 : ENNReal)⁻¹ = ⊤ ∧ + (∀ x : ENNReal, 0 < x⁻¹ ↔ x ≠ ⊤) := + ⟨fun _ _ => ENNReal.inv_le_inv, ENNReal.inv_top, ENNReal.inv_zero, fun _ => ENNReal.inv_pos⟩ + +/-- `Statement:` ⊤ of `ℕ∞` is a joint of (the finite values, `{⊤}`). -/ +theorem enat_top_isJoint : IsJoint (Set.range (Nat.cast : ℕ → ℕ∞)) {⊤} (⊤ : ℕ∞) := by + refine ⟨⟨fun a _ b hb => hb ▸ le_top, ⟨fun _ _ => le_top, fun y hy => ?_⟩, + ⟨fun b hb => hb ▸ le_rfl, fun y _ => le_top⟩⟩, ⟨0, 0, rfl⟩, ?_, rfl⟩ + · induction y using ENat.recTopCoe with + | top => exact le_rfl + | coe k => + have := hy ⟨k + 1, rfl⟩ + exact absurd (by exact_mod_cast this : k + 1 ≤ k) (by omega) + · rintro ⟨_, ⟨n, rfl⟩, hm⟩ + have := hm ⟨n + 1, rfl⟩ + exact absurd (by exact_mod_cast this : n + 1 ≤ n) (by omega) + +/-! ### § V. Order-reversing maps, and the 2-adic pole -/ + +/-- `Statement:` if `f` is onto and `f a ≤ f b ↔ b ≤ a`, then `f` sends a dual joint `x` of `(A, B)` + to a joint `f x` of `(f '' B, f '' A)`. -/ +theorem isJoint_image_of_isDualJoint {α β : Type*} [Preorder α] [Preorder β] (f : α → β) + (hf : ∀ a b, f a ≤ f b ↔ b ≤ a) (hs : Function.Surjective f) {A B : Set α} {x : α} + (h : IsDualJoint A B x) : IsJoint (f '' B) (f '' A) (f x) := by + obtain ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ := h + refine ⟨⟨?_, ⟨?_, ?_⟩, ⟨?_, ?_⟩⟩, hne.image f, ?_, Set.mem_image_of_mem f hx⟩ + · rintro _ ⟨b, hb, rfl⟩ _ ⟨a, ha, rfl⟩ + exact (hf b a).2 (hAB a ha b hb) + · rintro _ ⟨b, hb, rfl⟩ + exact (hf b x).2 (hg.1 hb) + · intro y hy + obtain ⟨z, rfl⟩ := hs y + exact (hf x z).2 (hg.2 fun b hb => (hf b z).1 (hy ⟨b, hb, rfl⟩)) + · rintro _ ⟨a, ha, rfl⟩ + exact (hf x a).2 (hl.1 ha) + · intro y hy + obtain ⟨z, rfl⟩ := hs y + exact (hf z x).2 (hl.2 fun a ha => (hf z a).1 (hy ⟨a, ha, rfl⟩)) + · rintro ⟨_, ⟨m, hm, rfl⟩, hmax⟩ + exact hng ⟨m, hm, fun b hb => (hf b m).1 (hmax ⟨b, hb, rfl⟩)⟩ + +/-- `Statement:` under the same hypotheses on `f`, a joint `x` of `(A, B)` goes to a dual joint + `f x` of `(f '' B, f '' A)`. -/ +theorem isDualJoint_image_of_isJoint {α β : Type*} [Preorder α] [Preorder β] (f : α → β) + (hf : ∀ a b, f a ≤ f b ↔ b ≤ a) (hs : Function.Surjective f) {A B : Set α} {x : α} + (h : IsJoint A B x) : IsDualJoint (f '' B) (f '' A) (f x) := by + obtain ⟨⟨hAB, hl, hg⟩, hne, hng, hx⟩ := h + refine ⟨⟨?_, ⟨?_, ?_⟩, ⟨?_, ?_⟩⟩, hne.image f, ?_, Set.mem_image_of_mem f hx⟩ + · rintro _ ⟨b, hb, rfl⟩ _ ⟨a, ha, rfl⟩ + exact (hf b a).2 (hAB a ha b hb) + · rintro _ ⟨b, hb, rfl⟩ + exact (hf b x).2 (hg.1 hb) + · intro y hy + obtain ⟨z, rfl⟩ := hs y + exact (hf x z).2 (hg.2 fun b hb => (hf b z).1 (hy ⟨b, hb, rfl⟩)) + · rintro _ ⟨a, ha, rfl⟩ + exact (hf x a).2 (hl.1 ha) + · intro y hy + obtain ⟨z, rfl⟩ := hs y + exact (hf z x).2 (hl.2 fun a ha => (hf z a).1 (hy ⟨a, ha, rfl⟩)) + · rintro ⟨_, ⟨m, hm, rfl⟩, hmin⟩ + exact hng ⟨m, hm, fun a ha => (hf m a).1 (hmin ⟨a, ha, rfl⟩)⟩ + +-- `Statement:` INVERSION on `ℝ≥0∞`: `x ↦ x⁻¹` sends 0's dual joint (`ennreal_zero_isDualJoint`) to a +-- joint at `0⁻¹`, which is ⊤ of `ℝ≥0∞` (`ennreal_inv_exchanges`). +example : IsJoint ((·⁻¹) '' {x : ENNReal | 0 < x}) ((·⁻¹) '' {(0 : ENNReal)}) (0 : ENNReal)⁻¹ := + isJoint_image_of_isDualJoint _ (fun _ _ => ENNReal.inv_le_inv) (fun y => ⟨y⁻¹, inv_inv y⟩) + ennreal_zero_isDualJoint + +/-- `Statement:` on ℤ_[2], `q2Val` reverses the norm order, ℤ_[2]'s 0 has least norm, and its + `q2Val` is ⊤ of `ℕ∞`, a joint of (the finite values, `{⊤}`). -/ +theorem q2Val_zero_isJoint : + (∀ x y : ℤ_[2], q2Val x ≤ q2Val y ↔ ‖y‖ ≤ ‖x‖) ∧ (∀ x : ℤ_[2], ‖(0 : ℤ_[2])‖ ≤ ‖x‖) ∧ + q2Val 0 = ⊤ ∧ IsJoint (Set.range (Nat.cast : ℕ → ℕ∞)) {⊤} (q2Val 0) := by + refine ⟨q2Val_le_iff_norm_le, fun x => by rw [norm_zero]; exact norm_nonneg x, q2Val_bot, ?_⟩ + rw [q2Val_bot] + exact enat_top_isJoint + +/-! ### § VI. `PinnedLimit` gives a joint; NInf's ∞ and ε₀ -/ + +/-- `Statement:` in a partial order, if `c` occupies `PinnedLimit g s c`, then `c` is a joint of + (the stages, the fixed points of `g`); one way. -/ +theorem PinnedLimit.isJoint {α : Type*} [PartialOrder α] {g : α → α} {s : ℕ → α} {c : α} + (h : PinnedLimit g s c) : IsJoint (Set.range s) {x | g x = x} c := by + obtain ⟨hlub, hnot, hleast, -⟩ := h + refine ⟨⟨fun a ha b hb => (hlub.1 ha).trans (hleast.2 hb), hlub, hleast.isGLB⟩, ⟨s 0, 0, rfl⟩, + ?_, hleast.1⟩ + rintro ⟨m, hm, hmax⟩ + exact hnot (by rw [hlub.unique ⟨hmax, fun _ hy => hy hm⟩]; exact hm) + +-- `Statement:` CONTROL: antisymmetry is a premise. Die.lean § XXIV's `Bool` preorder occupant of +-- `PinnedLimit id` (all points related) is no joint: its stages `{false}` have a greatest element. +example : ∃ inst : Preorder Bool, @PinnedLimit Bool inst id (fun _ => false) true ∧ + ¬ @IsJoint Bool inst (Set.range fun _ : ℕ => false) {x | id x = x} true := + ⟨{ le := fun _ _ => True, le_refl := fun _ => trivial, le_trans := fun _ _ _ _ _ => trivial, + lt := fun _ _ => False, lt_iff_le_not_ge := fun _ _ => by simp }, + ⟨⟨fun _ _ => trivial, fun _ _ => trivial⟩, fun ⟨_, h⟩ => by simp at h, ⟨rfl, fun _ _ => trivial⟩, + fun _ _ _ => trivial⟩, + fun ⟨_, _, hng, _⟩ => hng ⟨false, ⟨0, rfl⟩, fun _ _ => trivial⟩⟩ + +/-- `Statement:` NInf's `∞` is a joint of (the finite stages, `{∞}`). -/ +theorem NInf.infty_isJoint : IsJoint (Set.range NInf.ofNat) {NInf.infty} NInf.infty := by + have h := NInf.pinnedLimitUnique_succ.2.1.isJoint + have e : {x : NInf | NInf.succ x = x} = {NInf.infty} := Set.ext fun x => NInf.succ_fixed_iff x + rwa [e] at h + +-- `Statement:` ⊤ of `WithTop ℕ` is a joint of (the finite stages, the fixed points of `· + 1`), by +-- `pinnedLimitUnique_withTop`. +example : IsJoint (Set.range fun n : ℕ => (n : WithTop ℕ)) {x : WithTop ℕ | x + 1 = x} ⊤ := + pinnedLimitUnique_withTop.2.1.isJoint + +/-- `Statement:` ε₀ is a joint of (the ω-tower from ⊥ of `Ordinal`, the fixed points of `ω^·`). -/ +theorem epsilon0_isJoint : + IsJoint (Set.range fundamentalSeq.{0}) {o : Ordinal.{0} | Ordinal.omega0 ^ o = o} + epsilonZero := + epsilon0_pinnedLimit.{0}.2.isJoint + +-- `Statement:` something lies strictly above ε₀ in `Ordinal`, so it is no greatest point; and +-- ε₀ ≠ ⊥ of `Ordinal` (`epsilon0_ne_bot`): neither end. +example : epsilonZero.{0} < Order.succ epsilonZero ∧ epsilonZero.{0} ≠ ⊥ := + ⟨Order.lt_succ _, epsilon0_ne_bot⟩ + +-- `Statement:` CONTROL: the shape alone is not special to ε₀: ω is a joint of (the naturals, `Set.Ici ω`). +example : IsJoint (Set.range (Nat.cast : ℕ → Ordinal.{0})) (Set.Ici Ordinal.omega0) Ordinal.omega0 := by + refine ⟨⟨?_, ⟨?_, ?_⟩, ⟨fun _ hb => hb, fun y hy => hy (Set.mem_Ici.2 le_rfl)⟩⟩, ⟨0, 0, rfl⟩, ?_, + Set.mem_Ici.2 le_rfl⟩ + · rintro _ ⟨n, rfl⟩ b hb; exact (Ordinal.natCast_lt_omega0 n).le.trans hb + · rintro _ ⟨n, rfl⟩; exact (Ordinal.natCast_lt_omega0 n).le + · intro y hy; exact Ordinal.omega0_le.2 fun n => hy ⟨n, rfl⟩ + · rintro ⟨_, ⟨n, rfl⟩, hm⟩ + have := hm ⟨n + 1, rfl⟩ + simp at this + +-- `Statement:` CONTROL (no cut point at ε₀): against the fixed points at or above ε₁, the ω-tower has no cut point +-- at ε₀. +example : ¬ IsCutPoint (Set.range fundamentalSeq.{0}) + {o : Ordinal.{0} | Ordinal.omega0 ^ o = o ∧ Ordinal.epsilon 1 ≤ o} (Ordinal.epsilon 0) := by + rintro ⟨_, _, hglb⟩ + have h1 : Ordinal.epsilon 1 ∈ lowerBounds + {o : Ordinal.{0} | Ordinal.omega0 ^ o = o ∧ Ordinal.epsilon 1 ≤ o} := fun _ h => h.2 + exact absurd (hglb.2 h1) (not_le.2 (Ordinal.veblen_right_strictMono 1 zero_lt_one)) + +-- `Reading:` CARRIER. ε₀ ≠ ⊥ of `Ordinal` (`epsilon0_ne_bot`); ε₀, ⊤ of `ℝ≥0∞`, ⊤ of `ℕ∞` and +-- NInf's `∞` share the joint shape on four carriers, and no equation across them is well-typed. + +end ZeroParadox + +/-! ## Axiom Purity Check -/ +section PurityCheck +open ZeroParadox +#print axioms IsCutPoint +#print axioms IsJoint +#print axioms IsDualJoint +#print axioms isJoint_toDual_iff +#print axioms isDualJoint_toDual_iff +#print axioms not_isJoint_of_isBot +#print axioms not_isDualJoint_of_isTop +#print axioms not_isDualJoint_of_wellFoundedLT +#print axioms ennreal_top_isJoint +#print axioms ennreal_zero_isDualJoint +#print axioms ennreal_inv_exchanges +#print axioms enat_top_isJoint +#print axioms isJoint_image_of_isDualJoint +#print axioms isDualJoint_image_of_isJoint +#print axioms q2Val_zero_isJoint +#print axioms PinnedLimit.isJoint +#print axioms NInf.infty_isJoint +#print axioms epsilon0_isJoint +end PurityCheck diff --git a/ZeroParadox/Order/Lattice.lean b/ZeroParadox/Order/Lattice.lean index 0612c912..224ac3a0 100644 --- a/ZeroParadox/Order/Lattice.lean +++ b/ZeroParadox/Order/Lattice.lean @@ -62,9 +62,9 @@ neither adds a declaration to the corpus. -/ -- element. So there is no carrier that "fails a law": the laws come with the operations. example (L : Type*) [Nonempty L] : Nonempty (ZPSemilattice L) := by classical - letI : LinearOrder L := IsWellOrder.linearOrder (WellOrderingRel (α := L)) - letI : WellFoundedLT L := ⟨(IsWellFounded.wf : WellFounded (WellOrderingRel (α := L)))⟩ - letI : OrderBot L := WellFoundedLT.toOrderBot L + let : LinearOrder L := IsWellOrder.linearOrder (WellOrderingRel (α := L)) + let : WellFoundedLT L := (WellOrderingRel.isWellOrder (α := L)).wf + let : OrderBot L := WellFoundedLT.toOrderBot L exact ⟨{ join := max, bot := ⊥ , join_assoc := fun x y z => max_assoc x y z , join_comm := fun x y => max_comm x y @@ -274,10 +274,10 @@ variable {L : Type*} [ZPSemilattice L] #check @HasNoTop #check @IsStrictStateSequence -#print axioms le_refl -#print axioms le_antisymm -#print axioms le_trans -#print axioms bot_le +#print axioms ZeroParadox.ZPSemilattice.le_refl +#print axioms ZeroParadox.ZPSemilattice.le_antisymm +#print axioms ZeroParadox.ZPSemilattice.le_trans +#print axioms ZeroParadox.ZPSemilattice.bot_le #print axioms state_transition_iff #print axioms state_sequence_monotone #print axioms cc1 diff --git a/ZeroParadox/Order/LeastFixedPoint.lean b/ZeroParadox/Order/LeastFixedPoint.lean index 7ca94ccd..42f470ee 100644 --- a/ZeroParadox/Order/LeastFixedPoint.lean +++ b/ZeroParadox/Order/LeastFixedPoint.lean @@ -235,7 +235,7 @@ example : ¬ IsLeastFixedPointUpTo (fun A B : Type => Nonempty (A ↪ B)) (fun _ (`IsLeastFixedPointFrom`). -/ theorem aleph0_isLeastFixedPointFrom : IsLeastFixedPointFrom (· ≤ ·) (fun c : Cardinal.{0} => c + 1) 0 Cardinal.aleph0 where - seed_le := zero_le _ + seed_le := zero_le fixed := Cardinal.add_one_eq le_rfl least := fun b hb _ => by by_contra hlt @@ -296,7 +296,7 @@ theorem quot_optionMotion_step_iff (X Y : Cardinal.{0}) : (optionMotion.quot Cardinal.isEquivalent).step X Y ↔ Y = X + 1 := by induction X using Quotient.ind with | _ a => - rw [Motion.quot_step_mk_iff optionMotion_stepCompat] + refine (Motion.quot_step_mk_iff optionMotion_stepCompat a Y).trans ?_ constructor · rintro ⟨b, hb, rfl⟩ have hb' : b = Option a := hb @@ -325,14 +325,16 @@ end ZeroParadox /-! ## Axiom Purity Check -The schema's `selfApp_*` instances and `IsLeastFixedPointFrom.unique` are axiom-free (no axioms at -all); the Mathlib-`lfp` grounding `lfp_isLeastFixedPointFrom` is choice-free `[propext, Quot.sound]`. -The ordinal faces (`isLeastFixedPointFrom_nfp`, `epsilon0_*`) and the Kleene face are -STATEMENT-CARRIED (`ZeroParadox/Category/ChoiceCannotBe.md`): each statement, only assumed, already -reports `Classical.choice` (statement control, measured 2026-10-08), from Mathlib's `Ordinal`/`nfp` and -`Code`/`Partrec` machinery. The open question is a restatement on a choice-free carrier; ZP-N proves the -snap-from-below (the ascent) choice-free on `ONote`, which is evidence for that question, not a -restatement of these faces. -/ +The schema's `selfApp_*` instances and `IsLeastFixedPointFrom.unique` are axiom-free (no axioms at all); the +Mathlib-`lfp` grounding `lfp_isLeastFixedPointFrom` is choice-free `[propext, Quot.sound]`. The ordinal +faces (`isLeastFixedPointFrom_nfp`, `epsilon0_*`) and the Kleene face are STATEMENT-CARRIED +(`ZeroParadox/Category/ChoiceCannotBe.md`): each statement, with no proof attached, already carries +`Classical.choice`, from Mathlib's `Ordinal`/`nfp` and `Code`/`Partrec` machinery (for the ε₀ statements, +the statement controls printed in `ZeroParadox/Ordinal/Epsilon0MinMax.lean`). The remaining ordinal question +is a restatement on a carrier whose statements are choice-free, with two readings: a defined one, in Lean on +`E0Note`, and a derived one, on a well-founded carrier, not located as of 2026-10-13; both, with the search +record, are in `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". ZP-N proves the snap-from-below +(the ascent) choice-free on `ONote`, which is evidence for that question, not a restatement of these faces. -/ section PurityCheck open ZeroParadox diff --git a/ZeroParadox/Order/LeastFixedPoint.md b/ZeroParadox/Order/LeastFixedPoint.md index 855d5cc2..db885120 100644 --- a/ZeroParadox/Order/LeastFixedPoint.md +++ b/ZeroParadox/Order/LeastFixedPoint.md @@ -82,12 +82,13 @@ element of `Set.Ioi rung`, and closes at the next ε-number: `ε_(succ o) = nfp (`epsilon_succ_eq_nfp`; `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § I-b). `Reading:` **INVARIANT** (conjectural) — read the seed as a **role**, not an origin: the ratified -*"iterative bottoms"* picture, in which a rung is the base the next iteration re-seeds just above +*"iterative bottoms"* picture, in which a rung is the floor the next iteration re-seeds just above and, in that next iteration, the ε₀ role, the closure, is filled by the next ε-number. The same **shape** is a theorem in another carrier: `every_node_is_a_floor` (`ZeroParadox/Valuation/LocalFloor.lean`). ⚠ **SHAPE, never instance-of** — different carriers, different mechanisms, and different conclusions. -⚠ `ε₀ ≠ ⊥` is untouched bedrock (`epsilon0_ne_bot`); nothing here identifies a rung with ⊥. ⚠ The +⚠ `ε₀ ≠ ⊥` in `Ordinal` is untouched bedrock (`epsilon0_ne_bot`); nothing here identifies a rung +with ⊥ of `Ordinal` (a rung is ⊥ of the different carrier `Set.Ici rung`, as stated above). ⚠ The ratified term for the iteration sense is **iterative bottom**; do not substitute "local bottom" *there* — that phrase is taken for the per-domain MC-1 family (`ZeroParadox/Category/GlobalZero.lean`). (`ZeroParadox/Valuation/LocalFloor.lean` uses it for a third, subtree-local sense; that is that file's diff --git a/ZeroParadox/Order/MarkovContractionDual.lean b/ZeroParadox/Order/MarkovContractionDual.lean index ff1b6be3..b55fb675 100644 --- a/ZeroParadox/Order/MarkovContractionDual.lean +++ b/ZeroParadox/Order/MarkovContractionDual.lean @@ -18,11 +18,15 @@ defer to my AI assistant regarding the specifics of how the internals work. --- ## Formal Overview (AI-assisted) -The Markov analog, on `Fin 2 → ℝ`, of `ZeroParadox/Valuation/ContractionRate.lean`'s p-adic contraction -dichotomy; both halves are `markov_contraction_dichotomy`. Convergence covers `0 < a < 1`, starts on the -probability line; the non-convergence half is one orbit of `swap = markovStep 1`, and the `example` -after it is the other endpoint `a = 0`, where every orbit is constant. Prior art: Levin–Peres, -*Markov Chains and Mixing Times*. -/ +"#2" in the title is the bottom-diagram probe campaign's label for the Markov attractor node (the +p-adic floor is #3). The Markov analog, on `Fin 2 → ℝ`, of +`ZeroParadox/Valuation/ContractionRate.lean`'s p-adic contraction dichotomy; both halves are +`markov_contraction_dichotomy`. The convergence half covers `0 < a < 1` and starts on the probability +line `v₀ 0 + v₀ 1 = 1` (the hypothesis `hv` of `markov_contraction_tendsto`). The non-convergence half +is one orbit of `swap`, which is `markovStep 1`. The control `example` after +`swap_orbit_not_convergent` is the other endpoint `a = 0`, where every orbit is constant. Prior art: +Levin and Peres, *Markov Chains and Mixing Times*, 2nd ed., with contributions by E. L. Wilmer; the +two-state chain is their Example 1.1, p. 3. -/ namespace ZeroParadox @@ -81,8 +85,10 @@ theorem coord_from_imb {v : Fin 2 → ℝ} {s : ℝ} (hs : v 0 + v 1 = s) : /-- **GO — the geometric Markov attractor.** For `0 < a < 1` (so `|1 - 2a| < 1`) and any start `v₀` on the probability line `v₀ 0 + v₀ 1 = 1`, the iteration `P_aᵏ v₀` converges to the uniform stationary vector `unif = ![1/2,1/2]`. The convergence is at the explicit geometric rate - `|1 - 2a|ᵏ` (carried by `markov_imbalance_pow` + `tendsto_pow…of_abs_lt_one`), so #2 is - a genuine geometric ν-attractor, structurally matching `ZeroParadox/Valuation/ContractionRate.lean`'s p-adic `c`-contraction. -/ + `|1 - 2a|ᵏ` (carried by `markov_imbalance_pow` + `tendsto_pow…of_abs_lt_one`), so the uniform + vector is a geometric ν-attractor. `Reading:` its shape (a geometric rate toward one point) is + that of `ZeroParadox/Valuation/ContractionRate.lean`'s p-adic `c`-contraction; no map between the + two carriers is built here. -/ theorem markov_contraction_tendsto {a : ℝ} (ha0 : 0 < a) (ha1 : a < 1) {v₀ : Fin 2 → ℝ} (hv : v₀ 0 + v₀ 1 = 1) : Tendsto (fun k => (markovStep a)^[k] v₀) atTop (nhds unif) := by @@ -106,14 +112,16 @@ theorem markov_contraction_tendsto {a : ℝ} (ha0 : 0 < a) (ha1 : a < 1) simp only [unif] have : Tendsto (fun k => (1 + imb ((markovStep a)^[k] v₀)) / 2) atTop (nhds ((1 + 0) / 2)) := by exact ((tendsto_const_nhds.add himb).div_const 2) - simpa only [add_zero] using (this.congr (fun k => (e0 k).symm)) + exact (by simpa only [add_zero] using (this.congr (fun k => (e0 k).symm)) : + Tendsto (fun k => ((markovStep a)^[k] v₀) 0) atTop (nhds (1 / 2))) · -- coordinate 1 → unif 1 = 1/2 have e1 : ∀ k, ((markovStep a)^[k] v₀) 1 = (1 - imb ((markovStep a)^[k] v₀)) / 2 := fun k => (coord_from_imb (hline k)).2 simp only [unif] have : Tendsto (fun k => (1 - imb ((markovStep a)^[k] v₀)) / 2) atTop (nhds ((1 - 0) / 2)) := by exact ((tendsto_const_nhds.sub himb).div_const 2) - simpa only [sub_zero] using (this.congr (fun k => (e1 k).symm)) + exact (by simpa only [sub_zero] using (this.congr (fun k => (e1 k).symm)) : + Tendsto (fun k => ((markovStep a)^[k] v₀) 1) atTop (nhds (1 / 2))) /-! ### NO-GO half: the swap kernel (`a = 1`) has a non-convergent orbit -/ @@ -129,7 +137,8 @@ example : swap = markovStep 1 := by noncomputable def e0vec : Fin 2 → ℝ := ![1, 0] /-- The swap orbit is **periodic with period 2**: even iterates are `![1,0]`, odd are `![0,1]`. - This is the periodic structure at the spectral boundary `|λ₂| = 1`. -/ + This is the swap kernel `a = 1`, where `λ₂ = 1 - 2a = -1`: zero absolute spectral gap, in the + sense of Levin and Peres, 2nd ed., § 12.2, p. 163, eq. (12.6). -/ theorem swap_orbit_eq (k : ℕ) : swap^[k] e0vec = if Even k then (![1, 0] : Fin 2 → ℝ) else (![0, 1] : Fin 2 → ℝ) := by induction k with @@ -151,7 +160,7 @@ theorem swap_orbit_coord0 (k : ℕ) : /-- **NO-GO — non-convergence under the swap kernel.** The swap orbit started at `![1,0]` does NOT converge: its coordinate-0 sequence is `1, 0, 1, 0, …`, whose even-indexed subsequence is constant `1` and odd-indexed is constant `0`. A convergent limit would force `1 = 0`. So under the swap - kernel #2 is not a single attractor; the `example` below is the other endpoint `a = 0`. -/ + kernel the chain has no single attractor; the `example` below is the other endpoint `a = 0`. -/ theorem swap_orbit_not_convergent : ¬ ∃ w : Fin 2 → ℝ, Tendsto (fun k => swap^[k] e0vec) atTop (nhds w) := by rintro ⟨w, hw⟩ @@ -195,11 +204,11 @@ example (v₀ : Fin 2 → ℝ) (k : ℕ) : (markovStep 0)^[k] v₀ = v₀ := by /-! ### Dichotomy capstone -/ -/-- **The sharp contraction dichotomy for node #2 (spectral).** Both halves, with the spectral - reading: `|λ₂| < 1` (here `0 < a < 1`) ⇒ geometric attractor at the uniform vector; - spectral boundary `|λ₂| = 1` (the swap kernel) ⇒ no single attractor (periodic orbit). This - mirrors `ZeroParadox/Valuation/ContractionRate.lean`'s valuation dichotomy for #3 (`‖c‖₂ < 1` attractor / `‖c‖₂ = 1` non-attractor) in a - second ambient — the within-ν rate structure `ZeroParadox/Computability/StationaryUnique.lean` and `ZeroParadox/Valuation/NuRateEdge.lean` left unbuilt. -/ +/-- **The Markov contraction dichotomy.** For `0 < a < 1` (`|λ₂| = |1 - 2a| < 1`, `step_imb`) every + start on the probability line converges to `unif`; at `a = 1`, the swap (`λ₂ = -1`, zero absolute + spectral gap), the orbit from `e0vec` has no limit. `|λ₂| = 1` also at `a = 0`, where every orbit + converges (control `example` above). `Reading:` the shape of `ContractionRate.lean`'s p-adic + dichotomy, in another carrier; no map between the two is built. -/ theorem markov_contraction_dichotomy : (∀ (a : ℝ), 0 < a → a < 1 → ∀ (v₀ : Fin 2 → ℝ), v₀ 0 + v₀ 1 = 1 → Tendsto (fun k => (markovStep a)^[k] v₀) atTop (nhds unif)) ∧ @@ -218,7 +227,11 @@ section PurityCheck open ZeroParadox #print axioms markovStep +#print axioms step_sum #print axioms step_imb +#print axioms coord_from_imb +#print axioms swap_orbit_eq +#print axioms swap_orbit_coord0 #print axioms markov_imbalance_pow #print axioms markov_sum_pow #print axioms markov_contraction_tendsto diff --git a/ZeroParadox/Order/OrbitDichotomy.lean b/ZeroParadox/Order/OrbitDichotomy.lean index 28591f77..186b1a85 100644 --- a/ZeroParadox/Order/OrbitDichotomy.lean +++ b/ZeroParadox/Order/OrbitDichotomy.lean @@ -1,6 +1,7 @@ -- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the "1-or-∞, no finite middle" dichotomy as an orbit argument — a sufficient condition for that shape; the shape itself is not universal (§ fpp below). The framework's scale map runs the same argument (`valBridge_forces_infinite`). Curated results indexed in ZeroParadox/MANIFEST.md. import Mathlib.Tactic +import Mathlib.NumberTheory.Padics.PadicNumbers set_option maxHeartbeats 400000 @@ -23,13 +24,15 @@ the "one or infinitely many" shape only; for the λ-calculus see § fpp. -/ /-! ## § fpp — the λ-calculus name for the shape, where it holds and where it fails -Reading: there the shape is the **fixed point property (fpp)**: Manzonetto, Polonsky, Saurin & Simonsen, -*The fixed point property and a technique to harness double fixed point combinators*, J. Logic and -Computation (2019), doi:10.1093/logcom/exz013, Def. 2.15 (numbering as in the preprint; the journal -version was not checked). Their Problem 2 restates TLCA #25: "Does λβ satisfy the fixed point property?". -Holds: λβ satisfies the open fpp (their Thm 3.6); the closed question remains open (their abstract). -Fails: no sensible λ-theory satisfies the fpp (their Thm 5.4), and in each one, for every k > 0, some -closed term has exactly k fixed points modulo that theory (their Prop. 5.6). -/ +Reading: there the shape is the **fixed point property (fpp)**: Manzonetto, Polonsky, Saurin & Simonsen, *The fixed point +property and a technique to harness double fixed point combinators*, J. Logic and Computation (2019), +doi:10.1093/logcom/exz013, Def. 2.15 (every number cited here is the preprint's; journal not checked). Their Problem 2 +restates TLCA #25, "Does λβ satisfy the fixed point property?", first raised by Intrigila and Biasone, MSCS 10(5):595–615 +(2000) (their p. 1, ref. [17]; not consulted here). Holds: λβ satisfies the open fpp (their Thm 3.6); the closed question +was open as of that paper (2019, their abstract); a later solution was not located as of 2026-10-31 (one web search; the +TLCA problem page, last updated 2014, predates the paper and records no status). Fails: no sensible λ-theory satisfies +the fpp (their Thm 5.4), and in each one, for every k > 0, some closed term has exactly k fixed points modulo that theory +(their Prop. 5.6). λβ, the least λ-theory, is not sensible (from their p. 6 and Def. 1.8), so the two do not conflict. -/ namespace ZeroParadox @@ -38,14 +41,12 @@ namespace ZeroParadox subsingleton or infinite — never a finite set of size ≥ 2. The finite middle is excluded because a witness `x ≠ p` in `S` drags its whole (infinite) forward orbit into `S`. -**The framework's scale case is checked** at `valBridge_forces_infinite` (`ZeroParadox/Valuation/ScaleBridge.lean`) runs the same argument for the framework's scale map and concludes that a `ValBridge` carrier holding any point besides `bot` is infinite. ⚠ It is **not** an instance of this theorem, and the reason is the `hs` hypothesis here: -`ValBridge` does not supply `Function.Injective s`, and cannot be made to (`valBridge_scale_not_injective`, -`ZeroParadox/Valuation/ScaleBridge.lean`): `L = {bot} ⊎ (ℕ × Bool)` with `val (n, b) = n` and -`scale (n, b) = (n+1, false)` satisfies all four of its axioms while collapsing `(0, true)` with -`(0, false)`. There the valuation supplies injectivity **along an orbit** +`ValBridge` does not supply `Function.Injective s`, and cannot be made to: the counter-model is +`valBridge_scale_not_injective` (`ZeroParadox/Valuation/ScaleBridge.lean`). There the valuation supplies +injectivity **along an orbit** directly, which is all the argument consumes. Same argument, weaker hypothesis on that axis. -/ theorem orbit_dichotomy {X : Type*} (s : X → X) (hs : Function.Injective s) (p : X) (_hp : s p = p) (hper : ∀ (x : X) (n : ℕ), 0 < n → s^[n] x = x → x = p) @@ -92,9 +93,11 @@ theorem iterate_smul {k V : Type*} [Monoid k] [MulAction k V] (c : k) (n : ℕ) subsingleton or infinite — the "1 or ∞" dichotomy, no finite middle. Instance of `orbit_dichotomy` via the scaling action `v ↦ 2 • v`: its only periodic point is `0` (`2^n ≠ 1`), and `Fix f` is scaling-invariant because `f` is linear (`f (2•v) = 2•(f v)`). Stated over an ordered field for a clean -`2^n ≠ 1`; the framework's scale map `x ↦ 2x` on ℚ₂ (not ordered) obeys the same `orbit_dichotomy` argument -with `2^n ≠ 1` supplied by the 2-adic valuation (`v₂(2^n x) = n + v₂ x ≠ v₂ x` for `n ≥ 1`, `x ≠ 0`; -cf. `q2_unique_fp`, the "1" pole). Here the orbit hypothesis is *checkable*; for the λ-calculus see § fpp. -/ +`2^n ≠ 1`. The order is not what the argument consumes: `2^n ≠ 1` (for `n ≥ 1`) holds in every field of +characteristic zero, so ℚ₂ (not ordered) obeys the same `orbit_dichotomy` argument; the `example` after +this theorem checks it for ℚ₂-linear self-maps. Read in the 2-adic chart, the same inequality is visible in +the valuation (`v₂(2^n x) = n + v₂ x ≠ v₂ x` for `n ≥ 1`, `x ≠ 0`; cf. `q2_unique_fp`, the "1" pole). Here +the orbit hypothesis is *checkable*; for the λ-calculus see § fpp. -/ theorem linear_fix_dichotomy {k : Type*} [Field k] [LinearOrder k] [IsStrictOrderedRing k] {V : Type*} [AddCommGroup V] [Module k V] (f : V →ₗ[k] V) : {v : V | f v = v}.Subsingleton ∨ {v : V | f v = v}.Infinite := by @@ -108,6 +111,22 @@ theorem linear_fix_dichotomy {k : Type*} [Field k] [LinearOrder k] [IsStrictOrde simp only [Set.mem_setOf_eq] at hx ⊢ rw [map_smul, hx] +-- `Statement:` the same dichotomy for every ℚ₂-linear self-map: ℚ₂ is not an ordered field, and +-- `2^n ≠ 1` comes from characteristic zero (the cast of `2^n ≠ 1` in ℕ). +example {V : Type*} [AddCommGroup V] [Module ℚ_[2] V] (f : V →ₗ[ℚ_[2]] V) : + {v : V | f v = v}.Subsingleton ∨ {v : V | f v = v}.Infinite := by + apply orbit_dichotomy (fun v => (2 : ℚ_[2]) • v) (smul_right_injective V two_ne_zero) 0 (by simp) + · intro x n hn hx + rw [iterate_smul] at hx + have hne1 : (2 : ℚ_[2]) ^ n ≠ 1 := by + have h : (2 : ℕ) ^ n ≠ 1 := (Nat.one_lt_two_pow (by omega)).ne' + exact_mod_cast h + have h2 : ((2 : ℚ_[2]) ^ n - 1) • x = 0 := by rw [sub_smul, hx, one_smul, sub_self] + exact (smul_eq_zero.mp h2).resolve_left (sub_ne_zero.mpr hne1) + · intro x hx + simp only [Set.mem_setOf_eq] at hx ⊢ + rw [map_smul, hx] + /-- **No finite middle, explicit.** If a linear self-map (over an ordered field) has *finitely many* fixed points, it has at most one — the count can never be a finite number `≥ 2`. This is the sharp form of the "1 or ∞" dichotomy that the recurring self-reference pattern rhymes with. -/ diff --git a/ZeroParadox/Order/PadicLimitCone.lean b/ZeroParadox/Order/PadicLimitCone.lean index 37b4942f..be7c2626 100644 --- a/ZeroParadox/Order/PadicLimitCone.lean +++ b/ZeroParadox/Order/PadicLimitCone.lean @@ -1,4 +1,3 @@ --- EXPERIMENTAL (branch scaffolding): bottom-diagram probe campaign, not a finalized layer. Curated/load-bearing results are indexed in ZeroParadox/BottomCannotBe.lean and classified in ZeroParadox/MANIFEST.md. import ZeroParadox.Valuation.Padic import ZeroParadox.Valuation.TopFunctor import Mathlib.Topology.Category.TopCat.Limits.Basic @@ -108,8 +107,7 @@ theorem cone_val_const (S : Cone fB_functor) (x : S.pt) {m n : ℕ} (h : m ≤ n have hx := congrArg Subtype.val (ConcreteCategory.congr_hom hnat x) -- `fB_functor.map` is a value-preserving inclusion; `legVal` is already the `.val` simp only [legVal] - simpa [fB_functor, fBIncl, fBObj, Set.coe_inclusion, Function.comp, - TopCat.hom_comp, ContinuousMap.comp] using hx.symm + exact hx.symm /-- The underlying `Q₂` value of any cone leg `legVal S x n` is `0`: it lies in every ball (by `cone_val_const` collapsing all legs to one value) and hence in `⋂ q2Ball n = {0}`. -/ diff --git a/ZeroParadox/Order/PataraiaChoiceFree.lean b/ZeroParadox/Order/PataraiaChoiceFree.lean index 2e13b9d9..5067999a 100644 --- a/ZeroParadox/Order/PataraiaChoiceFree.lean +++ b/ZeroParadox/Order/PataraiaChoiceFree.lean @@ -132,16 +132,16 @@ example (a : Ordinal.{0}) (ha : Ordinal.omega0 ^ a = a) : ∃ (f : Set.Icc (0 : Ordinal.{0}) a →o Set.Icc (0 : Ordinal.{0}) a) (y : Set.Icc (0 : Ordinal.{0}) a), (∀ x, (f x).1 = Ordinal.omega0 ^ x.1) ∧ f y = y ∧ (∀ p, f p ≤ p → y ≤ p) ∧ y.1 = epsilonZero := by - haveI : Fact ((0 : Ordinal.{0}) ≤ a) := ⟨zero_le _⟩ + haveI : Fact ((0 : Ordinal.{0}) ≤ a) := ⟨zero_le⟩ have hmax := epsilon0_min_eq_max.{0, 0} let f : Set.Icc (0 : Ordinal.{0}) a →o Set.Icc (0 : Ordinal.{0}) a := - { toFun := fun x => ⟨Ordinal.omega0 ^ x.1, zero_le _, + { toFun := fun x => ⟨Ordinal.omega0 ^ x.1, zero_le, (Ordinal.opow_le_opow_right Ordinal.omega0_pos x.2.2).trans (le_of_eq ha)⟩ monotone' := fun _ _ h => Ordinal.opow_le_opow_right Ordinal.omega0_pos h } obtain ⟨y, hfy, hy⟩ := pataraia_least_prefixedPoint f have hle : epsilonZero ≤ a := hmax.2.2 ha - have e : (⟨epsilonZero, zero_le _, hle⟩ : Set.Icc (0 : Ordinal.{0}) a) = - f ⟨epsilonZero, zero_le _, hle⟩ := Subtype.ext hmax.2.1.symm + have e : (⟨epsilonZero, zero_le, hle⟩ : Set.Icc (0 : Ordinal.{0}) a) = + f ⟨epsilonZero, zero_le, hle⟩ := Subtype.ext hmax.2.1.symm refine ⟨f, y, fun _ => rfl, hfy, hy, le_antisymm ?_ (hmax.2.2 (congrArg Subtype.val hfy))⟩ exact hy _ (le_of_eq e.symm) diff --git a/ZeroParadox/Order/PowerSet.lean b/ZeroParadox/Order/PowerSet.lean index fe02bca1..eddd6012 100644 --- a/ZeroParadox/Order/PowerSet.lean +++ b/ZeroParadox/Order/PowerSet.lean @@ -44,7 +44,8 @@ theorem ps_bot_depth : psDepth (∅ : Finset α) = 0 := by /-! ## T-PS2: The discrete gap — any nonempty finset has depth ≥ 1 -/ theorem ps_nonempty_depth_pos (A : Finset α) (hA : A ≠ ∅) : 0 < psDepth A := by - simp [psDepth, Finset.card_pos, Finset.nonempty_iff_ne_empty.mpr hA] + -- [ZP port] Lean 4.35: `Finset.card_pos`/`nonempty_iff_ne_empty` now carry `Classical.choice`; `card_eq_zero` does not. + exact Nat.pos_of_ne_zero fun h => hA (Finset.card_eq_zero.mp h) /-! ## T-PS3: Depth 0 iff empty — nothing sits between ∅ and depth 1 -/ @@ -86,6 +87,14 @@ theorem ps_structural_floor : -- (`ZeroParadox/Reals/OrderedField.lean`). example : ∀ a : α, (∅ : Finset α) ⋖ {a} := Finset.empty_covBy_singleton +/-- `Statement:` finset membership read off the underlying multiset, `a ∈ s.val`; not an instance. -/ +abbrev psListMem : Membership α (Finset α) := ⟨fun s a => a ∈ s.val⟩ + +section ListMembership + +-- [ZP port] Lean 4.35: Finset `⊆` elaborates via `SetLike.instMembership`, whose proof spends `Classical.choice` (`Multiset.Nodup.ext`); this route keeps the statement below choice-free (ruling 165). +attribute [local instance high] psListMem LE.ofMembership + /-- Statement: a descending orbit of finsets that shrinks at every nonempty step (removing an element is one) is `∅` from step `(S 0).card` on. Analogs: `descent_with_strict_steps_reaches_floor` (`ZeroParadox/Order/WellFoundedObstruct.lean`) and Mathlib's `Finset.lt_wf`; adds `N ≤ (S 0).card`. -/ @@ -93,8 +102,10 @@ theorem ps_descent_reaches_floor (S : ℕ → Finset α) (hsub : ∀ k, S (k + 1 (hstrict : ∀ k, S k ≠ ∅ → S (k + 1) ≠ S k) : ∃ N, N ≤ (S 0).card ∧ ∀ k, N ≤ k → S k = ∅ := by -- via cardinality: Mathlib's `Finset.subset_empty` measures `Classical.choice`, this route does not + have card_le : ∀ {A B : Finset α}, A ⊆ B → A.card ≤ B.card := fun {A _} h => + Multiset.card_le_card ((Multiset.le_iff_subset A.nodup).mpr fun _ ha => h ha) have sub_empty : ∀ {A : Finset α}, A ⊆ ∅ → A = ∅ := fun hA => by - have h := Finset.card_le_card hA + have h := card_le hA rw [Finset.card_empty] at h exact Finset.card_eq_zero.mp (Nat.le_zero.mp h) have key : ∀ k, S k = ∅ ∨ (S k).card + k ≤ (S 0).card := by @@ -113,7 +124,10 @@ theorem ps_descent_reaches_floor (S : ℕ → Finset α) (hsub : ∀ k, S (k + 1 · have hk : S k ≠ ∅ := fun e => by rw [e, Finset.card_empty] at hc exact lt_irrefl 0 hc - have hlt := Finset.card_lt_card (Finset.ssubset_iff_subset_ne.mpr ⟨hsub k, hstrict k hk⟩) + have hlt : (S (k + 1)).card < (S k).card := Nat.lt_of_le_of_ne (card_le (hsub k)) + fun hc => hstrict k hk (Finset.val_inj.mp + (Multiset.eq_of_le_of_card_le ((Multiset.le_iff_subset (S (k + 1)).nodup).mpr + fun _ ha => hsub k ha) (Nat.le_of_eq hc.symm))) exact Or.inr (by omega) have stay : ∀ k, S k = ∅ → ∀ j, S (k + j) = ∅ := by intro k hk j @@ -131,6 +145,8 @@ theorem ps_descent_reaches_floor (S : ℕ → Finset α) (hsub : ∀ k, S (k + 1 obtain ⟨j, rfl⟩ := Nat.exists_eq_add_of_le hk exact stay _ hN j +end ListMembership + /-! ## Purity check -/ section PurityCheck @@ -140,6 +156,7 @@ section PurityCheck #print axioms ps_empty_not_limit #print axioms ps_no_subgap #print axioms ps_structural_floor +#print axioms psListMem #print axioms ps_descent_reaches_floor end PurityCheck diff --git a/ZeroParadox/Order/SeamSchema.lean b/ZeroParadox/Order/SeamSchema.lean index f0330c75..323bad0a 100644 --- a/ZeroParadox/Order/SeamSchema.lean +++ b/ZeroParadox/Order/SeamSchema.lean @@ -7,8 +7,7 @@ import ZeroParadox.Multihomed.SelfAppSeam import ZeroParadox.Computability.SelfApp /-! -# A shared "seam schema" for the QPF root-seam and the lattice selfApp seam, -with the cross-setting fence IN the statement. +# A shared "seam schema" for the QPF root-seam and the lattice selfApp seam; this file exhibits no map between the two settings ## Engineer's Take @@ -21,11 +20,11 @@ defer to my AI assistant regarding the specifics of how the internals work. ## Formal Overview (AI-assisted) -`ZeroParadox/Category/SeamComparisonMap.lean` fenced the **root-seam** (the QPF `constPF` seam, `Fix ≃ Cofix`) against the **node-seam** (the +`ZeroParadox/Category/SeamComparisonMap.lean` set the **root-seam** (the QPF `constPF` seam, `Fix ≃ Cofix`) against the **node-seam** (the #5 Hilbert zero object). This file tests a *different* pairing: the root-seam against the **lattice / selfApp seam** of `ZeroParadox/Multihomed/SelfAppSeam.lean` (`{x | selfApp x = x} = {⊥}`, ⊥ both least and greatest fixed point). The pre-registered question: do these two seams share a common Lean-statable schema, or is any -"shared schema" merely a prose juxtaposition (a modeling commitment)? +"shared schema" merely a prose juxtaposition? **The schema.** Both seams are, abstractly, the claim "the least-fixed-point carrier and the greatest-fixed-point carrier are connected by a canonical iso/equality." We capture that as a record @@ -57,10 +56,10 @@ greatest-fixed-point carrier are connected by a canonical iso/equality." We capt which is a denial the convention has no slot for, and is very likely false, since order-duality is exactly such an exchanging map.)* - To make the lattice selfApp seam an instance of `SeamSchema` the μ-carrier and the - ν-carrier must BOTH be taken to be the same object — the fixed-point subtype `{x // selfApp x = x}` — - and the seam witness is `Equiv.refl`. There is no pair of distinct carriers to relate: "least = greatest" - collapses them to one type before the schema is even applied. + To make the lattice selfApp seam an instance of `SeamSchema` this file DEFINES the μ-carrier and + the ν-carrier as the same object — the fixed-point subtype `{x // selfApp x = x}` — and the seam + witness as `Equiv.refl`. That collapse is a choice of definition, not a consequence of + "least = greatest". **The GO content (what is genuinely proved).** `both_satisfy_seam_schema`: BOTH nodes instantiate `SeamSchema`, with the discriminator witnessed in-statement — the QPF instance's `cmp` is the canonical @@ -68,25 +67,23 @@ bijective comparison; the lattice instance's carrier is the *nonempty* singleton is non-degenerate, not the vacuous empty case). The schema instantiates at both nodes. **The NO-GO fence (the load-bearing deflation, IN the statement).** `seam_schema_is_degenerate_for_lattice` -states the catch: the lattice instance fits `SeamSchema` ONLY because its two carriers are forced equal -(`μ = ν` as the same subtype) so the `cmp` is `Equiv.refl` — a trivial identity equivalence — whereas +states the catch: the lattice instance fits `SeamSchema` with its two carriers defined as one type +(`μ = ν` as the same subtype), so its `cmp` is `Equiv.refl` — a trivial identity equivalence — whereas the QPF instance relates two provably DISTINCT types (`Fix` and `Cofix` are not definitionally equal, and for the recursive functor `idPF_Coalgebra` they are not even equivalent, `idPF_no_seam`). So the shared schema is satisfied by both, but the *only* common content is "there is some equivalence between the μ-carrier and the ν-carrier" — which is automatically true once the lattice carriers are collapsed to a -single type. `no_cross_setting_map` records that there is NO map exhibited between the QPF setting -(a type equivalence `Fix ≃ Cofix`) and the lattice setting (a set equality `{x | selfApp x = x} = {⊥}`): -the two `SeamSchema` instances live over unrelated carrier types and nothing in this file transports one -to the other. Therefore the unification "the QPF root-seam IS the lattice selfApp seam" is a -cross-setting modeling commitment / fenced analogy, NOT a theorem. The schema is a common *shape*; it is -not a common *map*. +single type. `no_cross_setting_map` records the QPF setting (a type equivalence `Fix ≃ Cofix`) and the +lattice setting (a set equality `{x | selfApp x = x} = {⊥}`) side by side: the two `SeamSchema` +instances live over different carrier types, and nothing in this file transports one to the other. The schema is a common *shape*; it is not a common *map*. `Reading:` CARRIER — the shared +die role is occupied per chart (`selfApp_seam_role_unique`, `constPF_seam_role_unique`), no equation across. **Honest verdict.** The genuine new Lean content is: a single explicit `SeamSchema` record that both nodes provably instantiate, with the QPF instance's bijective canonical comparison and the lattice instance's nonempty singleton f.p. set both witnessed in-statement. What is fenced (and stated as a -theorem about the construction itself) is that the lattice instance is forced through `Equiv.refl` on a -collapsed carrier, the QPF instance relates distinct types, and no cross-setting map exists — so the -schema unifies the *shape*, not the seams. This is the DECORATIVE-vs-real test resolved honestly: the +theorem about the construction itself) is that the lattice instance is defined as `Equiv.refl` on a +collapsed carrier and the QPF instance relates distinct types; this file exhibits no cross-setting map, +so the schema unifies the *shape*, not the seams. This is the DECORATIVE-vs-real test resolved honestly: the shared schema is real and both-instantiated, but it is loose enough to be vacuous on the lattice side, and that looseness is itself proved. -/ @@ -141,9 +138,9 @@ abbrev FpSub (L : Type u) [ZPSemilattice L] [AbstractSelfApp L] : Type u := {x : L // AbstractSelfApp.selfApp x = x} /-- The lattice selfApp seam as a `SeamSchema`. The μ-carrier (least f.p.) and the ν-carrier -(greatest f.p.) are FORCED to be the same object — the fixed-point subtype `FpSub L` — because -"least = greatest" (`selfApp_bot_is_both_extremal`) collapses them before the schema applies. -Hence the seam witness can only be `Equiv.refl`. -/ +(greatest f.p.) are DEFINED here as the same object — the fixed-point subtype `FpSub L` — and the +seam witness as `Equiv.refl`. The collapse is this definition's choice; "least = greatest" +(`selfApp_bot_is_both_extremal`) is what makes one carrier serve for both readings. -/ def latticeSeam : SeamSchema (FpSub L) (FpSub L) := ⟨Equiv.refl _⟩ @@ -175,13 +172,13 @@ theorem both_satisfy_seam_schema : ∧ (bot : L) ∈ {x : L | AbstractSelfApp.selfApp x = x}) := ⟨qpfSeam_cmp_is_canonical Unit, latticeSeam_carrier_nonempty_singleton⟩ -/-! ## NO-GO fence: the schema is loose on the lattice side, and no cross-setting map exists -/ +/-! ## NO-GO fence: the schema is loose on the lattice side, and this file exhibits no cross-setting map -/ /-- **The lattice seam fits the schema only via `Equiv.refl` on a collapsed carrier.** In-statement: the `cmp` of `latticeSeam` is literally `Equiv.refl (FpSub L)` — the trivial identity equivalence. The lattice instance carries NO information beyond "the carrier is equivalent to itself", because -"least = greatest" already collapsed the two carriers to one type. This is the degeneracy fence: on the -lattice side the schema is vacuous. -/ +`latticeSeam` defines the two carriers as one type. This is the degeneracy fence: on the lattice side +the schema is vacuous. -/ theorem seam_schema_is_degenerate_for_lattice : (latticeSeam (L := L)).cmp = Equiv.refl (FpSub L) := rfl @@ -194,22 +191,22 @@ theorem qpf_seam_not_automatic : IsEmpty (Fix ZeroParadox.idPF_Coalgebra.Obj ≃ Cofix ZeroParadox.idPF_Coalgebra.Obj) := idPF_no_seam -/-- **No cross-setting map (the capstone fence, content IN the statement).** The two `SeamSchema` -instances are recorded side by side as living over UNRELATED carrier settings, with no transport -between them: +/-- **No cross-setting map exhibited (the capstone fence).** The two `SeamSchema` +instances are recorded side by side over two carrier settings, with no transport between them given +in this file: * QPF: a type equivalence `Fix (constPF Unit).Obj ≃ Cofix (constPF Unit).Obj` whose witness is the canonical bijective comparison (distinct carriers; the equivalence FAILS for the recursive functor `idPF_Coalgebra`, so it is genuine content); -* lattice: a set equality `{x | selfApp x = x} = {⊥}` whose `SeamSchema` witness is forced to be +* lattice: a set equality `{x | selfApp x = x} = {⊥}` whose `SeamSchema` witness is defined as `Equiv.refl` on the collapsed singleton carrier (vacuous content). Both are true; neither is derived from the other in this file, and there is NO function exhibited between the QPF carrier setting and the lattice carrier setting. The `SeamSchema` record unifies the *shape* "least-fp carrier ≃ greatest-fp carrier", but it is loose enough to be satisfied by `refl` on -the lattice side and is satisfied non-trivially only on the QPF side. Therefore "the QPF root-seam IS -the lattice selfApp seam" is a cross-setting modeling commitment / fenced analogy, NOT a Lean theorem. -The shared schema is a common shape, not a common map. -/ +the lattice side and is satisfied non-trivially only on the QPF side. The shared schema is a common +shape, not a common map; the shared die role is occupied per chart (`selfApp_seam_role_unique`, +`constPF_seam_role_unique`). -/ theorem no_cross_setting_map : -- QPF side: genuine equivalence (canonical, bijective) between distinct carriers ... (((qpfSeam Unit).cmp : Fix (constPF Unit).Obj → Cofix (constPF Unit).Obj) = canonicalCmp @@ -222,6 +219,15 @@ theorem no_cross_setting_map : ({x : L | AbstractSelfApp.selfApp x = x} = ({bot} : Set L)) := ⟨qpfSeam_cmp_is_canonical Unit, idPF_no_seam, rfl, selfApp_fp_set_eq_singleton_bot⟩ +/-- `Statement:` in the die motion `ofFun selfApp` on a `ZPSemilattice` with `AbstractSelfApp`, exactly + one point steps to itself only. The type names no point; the proof's witness is the least element + `bot`, from the class fields `fixed_bot` and `unique_fp`, and `selfApp_fp_set_eq_singleton_bot` + (with `Motion.selfOnlyAt_ofFun_iff`) states that identification. -/ +theorem selfApp_seam_role_unique : + ∃! y, (Motion.ofFun (AbstractSelfApp.selfApp (L := L))).SelfOnlyAt y := + ⟨bot, (Motion.selfOnlyAt_ofFun_iff _ _).2 AbstractSelfApp.fixed_bot, + fun y hy => AbstractSelfApp.unique_fp y ((Motion.selfOnlyAt_ofFun_iff _ _).1 hy)⟩ + section PurityCheck #print axioms qpfSeam_cmp_is_canonical #print axioms latticeSeam_carrier_nonempty_singleton @@ -229,6 +235,7 @@ section PurityCheck #print axioms seam_schema_is_degenerate_for_lattice #print axioms qpf_seam_not_automatic #print axioms no_cross_setting_map +#print axioms selfApp_seam_role_unique end PurityCheck end ZeroParadox diff --git a/ZeroParadox/Order/Snap.lean b/ZeroParadox/Order/Snap.lean index 61ee608f..605956b0 100644 --- a/ZeroParadox/Order/Snap.lean +++ b/ZeroParadox/Order/Snap.lean @@ -22,7 +22,12 @@ DA-1 is addressed in ZPJ and ZPK. DA-2 is addressed in ZPI. ## Formal Overview AX-1 is retired: the SHAPE of the snap is proved (`t_snap_derived`, `t_snap_given`), and that the snap OCCURS follows -from the occurrence commitment (instantiation occurs) together with DA-1, not from T-SNAP (`tsnap_holds_but_nothing_moves`). +from the occurrence commitment together with DA-1, not from T-SNAP (`tsnap_holds_but_nothing_moves`). +`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). `Reading:` CARRIER — the two charts correspond; a firing is not proved to be an execution event. The inserts DA-1, DA-2, DA-3 and the cross-framework link: `ZeroParadox/Order/Snap.md`. -/ @@ -120,6 +125,12 @@ theorem t_snap_given {L : Type*} [ZPSemilattice L] (S : ℕ → L) S 0 ≠ S 1 ∧ S 1 ≠ S 0 ∧ join (S 0) (S 1) = S 1 := ⟨fun h => hocc h.symm, hocc, by rw [hcc1]; exact bot_join _⟩ +-- Statement: in the occurrence commitment's slot chart, `t_snap_of_fires_once` +-- (`ZeroParadox/Information/CrossingTrials.lean` § VIII) supplies `hcc1` and `hocc` from a tape that +-- fired at least once, with `φ` sending `false` to ⊥ of `L` and `true` to a point other than ⊥ of +-- `L`; its sequence steps once, at index 1, and stays, so it is not an +-- `IsStrictStateSequence` (the example in `ZeroParadox/Order/SnapCannotBe.lean` § II). + -- Statement: `t_snap_derived` is the instance at the sequence `c₀, c₁, c₁, …`, chosen to move: `hcc1` is `rfl` and `hocc` is `c₁ ≠ c₀`. example : c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ join c₀ c₁ = c₁ := t_snap_given (fun n => if n = 0 then c₀ else c₁) rfl (by decide) @@ -188,8 +199,10 @@ example {L : Type*} [ZPSemilattice L] (S : ℕ → L) (n : ℕ) letI := zpSemilatticeSup L; IsAtom (⟨S (n + 1), hcov.le⟩ : Set.Ici (S n)) := by letI := zpSemilatticeSup L; exact (covBy_iff_atom_Ici hcov.le).1 hcov --- Statement: the binders are satisfiable: `t_snap_derived`'s run `c₀, c₁, c₁, …` meets all three. -example : (c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ join c₀ c₁ = c₁) ∧ +/-- Statement: in `MachinePhase`, `t_snap_derived`'s run `c₀, c₁, c₁, …` meets all three binders + of `t_snap_given_cover`: the T-SNAP triple holds and `c₁` covers ⊥ of `MachinePhase` (= `c₀`) + in ZP-A's induced order. -/ +theorem t_snap_derived_cover : (c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ join c₀ c₁ = c₁) ∧ letI := zpSemilatticeSup MachinePhase; (bot : MachinePhase) ⋖ c₁ := by refine t_snap_given_cover (fun n => if n = 0 then c₀ else c₁) rfl (by decide) ?_ letI := zpSemilatticeSup MachinePhase @@ -205,6 +218,22 @@ example {L : Type*} [ZPSemilattice L] : letI := zpSemilatticeSup L; letI := zpOrderBot L exact ⟨fun h => lt_irrefl _ h.1, fun h => h.1 rfl⟩ +-- Statement: `t_snap_given` needs no cover: on `ℚ≥0` under `max`, a densely ordered join-semilattice whose ⊥ +-- is 0 of `ℚ≥0`, the triple holds at the step 0 → 1/2 while nothing covers 0 (compare `t_snap_derived_cover`). +example : + letI : ZPSemilattice NNRat := ⟨max, 0, max_assoc, max_comm, max_self, fun x => max_eq_right (zero_le (a := x))⟩ + ((0 : NNRat) ≠ 1 / 2 ∧ (1 / 2 : NNRat) ≠ 0 ∧ join (0 : NNRat) (1 / 2) = 1 / 2) ∧ + ¬ ∃ y : NNRat, @CovBy NNRat (zpSemilatticeSup NNRat).toLT 0 y := by + letI : ZPSemilattice NNRat := ⟨max, 0, max_assoc, max_comm, max_self, fun x => max_eq_right (zero_le (a := x))⟩ + have key : ∀ a b : NNRat, @LT.lt NNRat (zpSemilatticeSup NNRat).toLT a b ↔ a < b := fun a b => by + show (max a b = b ∧ ¬ max b a = a) ↔ a < b + rw [max_eq_right_iff, max_eq_right_iff] + exact ⟨fun h => not_le.1 h.2, fun h => ⟨h.le, not_le.2 h⟩⟩ + refine ⟨t_snap_given (fun n => if n = 0 then 0 else 1 / 2) rfl (by norm_num), ?_⟩ + rintro ⟨y, h⟩ + obtain ⟨c, h1, h2⟩ := exists_between ((key 0 y).1 h.1) + exact h.2 ((key 0 c).2 h1) ((key c y).2 h2) + /-- T-SNAP (irreversibility): Algebraic form of ZP-A R1 (no subtraction operator). If x ≼ y and x ≠ y, no join from y can return to x. Complements c3_irreversible (topological irreversibility in Q₂). @@ -228,8 +257,7 @@ example {L : Type*} [ZPSemilattice L] : so there is no strict pair. In a carrier that has one, `⊥ ⋖ a` (`HasFirstStep`, `ZeroParadox/Reals/OrderedField.lean`) is that first inhabitant — note the order: `ZPSemilattice`'s `le` is a def with no `LT` instance, so `⋖` over it is stated in the order - `zpSemilatticeSup` builds (`t_snap_given_cover`). - Long form: `.claude-local/notes/no_subtraction_is_vacuous_at_bottom_2026-07-31.md`. -/ + `zpSemilatticeSup` builds (`t_snap_given_cover`). -/ theorem t_snap_irreversible {L : Type*} [ZPSemilattice L] {x y : L} (hle : le x y) (hne : x ≠ y) : ¬∃ z : L, join y z = x := by @@ -321,6 +349,12 @@ before the snap, ⊥ can reach ALL of L; after the snap, ε₀ can reach only a subset. This is the inverse face of the Zero Paradox: ⊥ is the universal source, yet transitioning away from it permanently forecloses access to ⊥ itself. -/ +section +-- [ZP port] Lean 4.35: `⊂` on `Set` now elaborates to `<` from `Set.instCompleteAtomicBooleanAlgebra`, +-- which carries `Classical.choice`; erasing the two Boolean-algebra instances here routes it through the +-- choice-free `Set.instDistribLattice` (`[propext, Quot.sound]`), the 4.30 footprint. +attribute [-instance] Set.instCompleteAtomicBooleanAlgebra Set.instBooleanAlgebra + /-- T-SNAP (accessible states shrink): the Binary Snap strictly narrows the set of reachable states. From ⊥, every element of L is accessible (A4: bot_le x always). From ε₀, only {x | ε₀ ≤ x} is accessible — a proper subset, since ⊥ is excluded: @@ -335,6 +369,7 @@ theorem t_snap_accessible_proper_subset {L : Type*} [ZPSemilattice L] {ε₀ : L · intro x _; exact bot_le x · intro h exact hne (le_antisymm (bot_le ε₀) (h (bot_le bot))) +end /-! ## VI. DP-2 — Execution Distinguishability and DA-1 Lean Formalization @@ -346,9 +381,9 @@ post-execution null and the pre-execution null are different instances. This separates two things the narrative might conflate: the *value* a machine produces (which can be ⊥ in both cases) and the *machine state* (c₀ before execution, c₁ after). -Given DP-2, DA-1 (instantiation = execution) is Lean-formalizable at the minimal-path -level: the act of instantiating ⊥ moves the machine from c₀ to c₁, regardless of what -value the operation returns. The "return to null" is a new null — not a return to c₀. -/ +DA-1's minimal-path form is `da1_minimal_path` below: it takes no hypothesis and does not +carry that the step is taken; given DA-1's precondition, c₀ → c₁ is D7's (ZP-E, T-SNAP +Step 3). Reading the returned null as a NEW null is C-DA2, a commitment (SnapCannotBe § IV). -/ /-! ### NO-GO gauge — `TrackedOutput` is a RECORD, not a requirements class. Two `MachinePhase` fields and no laws, so any pair inhabits it and nothing can fail to be one. Its content is the @@ -409,6 +444,7 @@ open ZeroParadox ZeroParadox ZPSemilattice ZeroParadox #print axioms zpSemilatticeSup #print axioms zpOrderBot #print axioms t_snap_given_cover +#print axioms t_snap_derived_cover #print axioms t_snap_irreversible #print axioms da2_bottom_characterization #print axioms c_da2_novelty diff --git a/ZeroParadox/Order/Snap.md b/ZeroParadox/Order/Snap.md index 7b3d583b..da2a1d0e 100644 --- a/ZeroParadox/Order/Snap.md +++ b/ZeroParadox/Order/Snap.md @@ -17,14 +17,24 @@ Cross-framework synthesis of ZP-A through ZP-D. Provides three formal inserts: at all, the executor is ⊥ itself; the premise "nothing external can execute ⊥" is the framework's requirement, not a theorem. That rules out an external executor, not an inert ⊥. Its Lean counterpart is `da1_closed_concrete`, which proves IsQuineAtom (bot : MachinePhase) and nothing - computational; the self-executing reading is carried by the KleeneStructure commitment. - - Path 2 (informational, ZP-C L-INF): surprisal at ⊥ is unbounded, so no finite interpreter holds - ⊥ as a static description. The step from there to executing is a bridge principle of its own, + computational. The self-executing reading splits: its identity half is retired, no code being + equated with ⊥ and the code chart having its own occupant of the die's Quine-atom role, a class + of codes up to equal `eval` for computable `eval`-respecting maps (`codes_vs_classes`) and never a + single code (`evalStepMotion_not_selfOnlyAt`), both `ZeroParadox/Computability/Kleene.lean` § IX; + that ⊥ runs is the occurrence commitment. + - Path 2 (informational), in two charts; the point chart's `Statement:` COINCIDENCE is named below. Depth chart, ZP-C L-INF: surprisal is unbounded in the + ball-hierarchy depth n while each value is finite (`l_inf`, `ZeroParadox/Information/Surprisal.lean`). + Point chart: at 0 of ℚ₂, the one point in every ball B(0, 2⁻ⁿ) of the chain centred at 0 + (`fB_bottom_is_limit`), the 2-adic additive valuation is ⊤ (`padic_addVal_bot`, + `ZeroParadox/Valuation/ValuationAFA_Padic.lean`); `Statement:` COINCIDENCE, the floor carrying ⊤ at + one point, is `infinitude_forces_infinite_complexity` at `q2InfinitudeFloor`. ⊥ of `MachinePhase`, c₀, + corresponds to that point (the `l_inf` docstring). From this the framework argues that no finite + interpreter holds ⊥ as a static description. The step from there 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. - Path 3 (computational, ZP-C D1 + AIT): incompressibility rules out a shorter external - generator, not an inert string, so executing is not derivable from incompressibility. Its Lean - counterpart is the machinePhaseKleene instance's botCode_is_quine field, a KleeneStructure + generator, not an inert string, so this path does not derive executing from incompressibility. + Its 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. diff --git a/ZeroParadox/Order/SnapCannotBe.lean b/ZeroParadox/Order/SnapCannotBe.lean index 2e3a4b3b..06f3ec70 100644 --- a/ZeroParadox/Order/SnapCannotBe.lean +++ b/ZeroParadox/Order/SnapCannotBe.lean @@ -4,6 +4,13 @@ import ZeroParadox.Valuation.SemilatticeInstance import ZeroParadox.Valuation.SnapDichotomy import ZeroParadox.Reals.OrderedField import ZeroParadox.Multihomed.BoundaryOrder +import ZeroParadox.Information.CrossingTrials +import ZeroParadox.Valuation.PolePassage +import ZeroParadox.Valuation.BallLine +import ZeroParadox.Reals.ConnectedNoFirstStep +import ZeroParadox.Information.TwoRequirements +import ZeroParadox.Information.MaxEntropy +import ZeroParadox.Information.SnapEpsilonZero /-! # Machine-checked characterization index of the snap ⊥ → ε₀ — what the snap IS and IS NOT @@ -26,7 +33,7 @@ section SnapCannotBeIndex /-! ### § I. What the snap IS NOT — not an axiom, not reversible, not a return to the same `TrackedOutput` configuration -/ #check @ZeroParadox.t_snap_derived -- Statement: in `MachinePhase`, `c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ join c₀ c₁ = c₁` — the shape (AX-1 is retired); that the snap occurs follows from the occurrence commitment together with DA-1, not from this line, and the next line is why #check @ZeroParadox.tsnap_holds_but_nothing_moves -- Statement: in `MachinePhase`, T-SNAP's statement holds together with a dynamics `stuckPhase` in which every phase is fixed, so T-SNAP is not an occurrence claim --- `Statement:` a state sequence in `MachinePhase` that starts at its ⊥ `c₀` and never steps is the `example` after `t_snap_given` in `ZeroParadox/Order/Snap.lean`. +-- `Statement:` a state sequence in `MachinePhase` that starts at its ⊥ `c₀` and never steps exists: the `example` in `ZeroParadox/Order/Snap.lean` stating that `MachinePhase` does not discharge `hocc` (`∃ S, S 0 = bot ∧ IsStateSequence S ∧ ∀ n, S (n + 1) = S n`). #check @ZeroParadox.t_snap_irreversible -- Statement: in any `ZPSemilattice`, for `le x y` and `x ≠ y`, no `z` has `join y z = x`. Reading: at `x := bot` and `y` any state above it (c₁ in `MachinePhase`, which the discrete chart names ε₀), no join from `y` returns to that semilattice's ⊥. The statement mentions neither ⊥ nor the snap #check @ZeroParadox.dp2_execution_distinguishability -- Statement: `preInstantiation` and `postInstantiation` share the output value and differ in machine state. Reading: the post-snap null and the pre-snap null are distinct instances in `TrackedOutput`; in the ℤ₂ chart the arc reapproaches the SAME 0 (`snap_arc_z2_loop`, § IV) #check @ZeroParadox.da1_minimal_path -- Statement: the two configurations are DISTINCT while sharing an output value, with states `c₀` before and `c₁` after. It does NOT carry that the step is taken, and irrecoverability is not in it — see the fence in its home docstring @@ -35,6 +42,22 @@ section SnapCannotBeIndex #check @ZeroParadox.t_snap_join -- Statement: in any `ZPSemilattice`, `join bot x = x` for every `x` (A4, `bot_join`); the binder is named ε₀. Reading: the algebraic core ⊥ ∨ ε₀ = ε₀ #check @ZeroParadox.t_snap_machine -- Statement: in `MachinePhase`, `join c₀ c₁ = c₁` (initial → running) #check @ZeroParadox.t_snap_given -- Statement: over any ZPSemilattice, `S 0 = bot` (CC-1) and `S 1 ≠ S 0` (occurrence at the first step) give `t_snap_derived`'s shape at S 0, S 1; the inequalities restate `hocc`, and only the join comes from A4. No binder makes `S 1` an atom above `S 0`, and the step is assumed (`hocc`), not forced. Two commitments are the binders; `t_snap_derived` is its MachinePhase instance at a sequence chosen to move, and `MachinePhase` does not discharge `hocc` +-- 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). +#check @ZeroParadox.t_snap_of_fires_once -- Statement: if `φ : Bool → L` sends `false` to ⊥ of `L` and `true` to a point other than ⊥ of `L`, and the tape `w` fires at some stage (`hw`), then `φ ∘ firedRun w hw` meets `t_snap_given`'s `hcc1` and `hocc` and is a state sequence; one way +#check @ZeroParadox.trials_fires_once -- Statement: if `0 < p ≤ 1`, the tapes that fire at some stage have `trials p hp` measure one; it names no tape +-- `Statement:` CONTROL, a particular tape need not fire: the all-`false` tape fires at no stage. +example : ¬ ∃ k, (fun _ => false : ℕ → Bool) k = true := fun ⟨_, h⟩ => Bool.false_ne_true h +-- `Statement:` occurrence once: the slot chart's sequence steps at index 1 and stays, so it is not an +-- `IsStrictStateSequence` (ZP-A's proper ascent at every step). +example {L : Type*} [ZeroParadox.ZPSemilattice L] (φ : Bool → L) (w : ℕ → Bool) (hw : ∃ k, w k = true) : + ¬ ZeroParadox.ZPSemilattice.IsStrictStateSequence (φ ∘ ZeroParadox.firedRun w hw) := fun h => by + have a : ZeroParadox.firedRun w hw 1 = true := (ZeroParadox.firedRun_spec w hw).2 0 + have b : ZeroParadox.firedRun w hw 2 = true := (ZeroParadox.firedRun_spec w hw).2 1 + exact h.2 1 (show φ (ZeroParadox.firedRun w hw 1) = φ (ZeroParadox.firedRun w hw 2) by rw [a, b]) +-- Reading: CARRIER — the two charts correspond: a firing is read as an instantiation. That correspondence is +-- not proved; a firing is not shown to be an execution event. -- Reading: CARRIER. "⊥ → ε₀" in the lines that use c₁ (`t_snap_derived`, `t_snap_machine`) is the -- discrete-state chart, where ε₀ names the first state above ⊥ (c₁ in `MachinePhase`), and "atom above -- ⊥" is a claim in that chart only. `t_snap_join`, `t_snap_irreversible` and @@ -77,6 +100,15 @@ example : ¬ @CovBy ℕ (ZeroParadox.zpSemilatticeSup ℕ).toLT 0 2 := fun h => show ¬ ZeroParadox.ZPSemilattice.join 1 0 = 0 by decide⟩ ⟨show ZeroParadox.ZPSemilattice.join 1 2 = 2 by decide, show ¬ ZeroParadox.ZPSemilattice.join 2 1 = 1 by decide⟩ +#check @ZeroParadox.snap_of_two_requirements -- Statement: if ⊥ of `L` has a first step in ZP-A's induced order (`BotHasFirstStep L`) and the tape `w` avoids every zero-block test for `trials p hp` with `0 < p` (`ZeroBlockTypical`), then some `φ : Bool → L` and some proof `hw` that `w` fires make `S := φ ∘ firedRun w hw` a state sequence with `S 0 = bot` and `S 1 ≠ S 0` that carries `t_snap_given_cover`'s conclusion, the triple and `bot ⋖ S 1`; one way. `φ` is built from the cover's witness; no map from ⊥ of `L` to a tape appears +-- Reading: CARRIER — the slot chart's `hw` from typicality of one tape, the cover from AX-B1's form on `L`, each a +-- hypothesis and neither discharged (the `NNReal` and all-`false` controls in `ZeroParadox/Information/TwoRequirements.lean`). +#check @ZeroParadox.snap_of_firstStep_MLRandom -- Statement: the same conclusion with `ZeroBlockTypical` replaced by Martin-Löf randomness for `trials p hp` (`MLRandom`, defined in `ZeroParadox/Information/TwoRequirements.lean`), which implies it (`zeroBlockTypical_of_MLRandom`); one way. No tape is named and ⊥ of `L` is not claimed random +#check @ZeroParadox.phase_snap_of_MLRandom -- Statement: CORNER, on `WithBot Ordinal` under join `max` (`ZeroParadox/Information/SnapEpsilonZero.lean`): if `w` is Martin-Löf random for `trials p hp` with `0 < p`, some run's `S 1` covers ⊥ of `WithBot Ordinal`, equals the snap `↑0 ≠ ↑ε₀`, and `phaseUpAndOver.up` sends it to `↑ε₀`; one way +#check @ZeroParadox.epsilonOrZero_snap_of_MLRandom -- Statement: COVER, on `EpsilonOrZero`, the carrier of the example above, under join `max`: if `w` is as above, some run's `S 1` covers 0 of `Ordinal` and has value ε₀ ≠ 0; one way. The two are related by `epsilonOrZeroIsoLanding_spec`, and neither is the snap's only form +#check @ZeroParadox.snap_ae_of_firstStep -- Statement: if ⊥ of `L` has a first step (`BotHasFirstStep L`) and `0 < p ≤ 1`, then for `trials p hp`-almost every tape `w` some `φ` and `hw` give `snap_of_two_requirements`'s conclusion; one way. Almost every, not every: the all-`false` tape never fires. No map from ⊥ of `L` to a tape or to `trials p hp` appears +#check @ZeroParadox.mlRandom_and_snap_ae -- Statement: the same, with `MLRandom (trials p hp) w` conjoined: almost every tape is Martin-Löf random for `trials p hp` and gives that conclusion; one way +#check @ZeroParadox.maxEntropy_mlRandom_and_snap_ae -- Statement: the same, with `0 < p` replaced by `binEntropy p = log 2`, the maximum-entropy coin `p = 1/2` (`ZeroParadox/Information/MaxEntropy.lean`); one way. No tape law of ⊥ of `L` is constructed, and `BotHasFirstStep L` stays a hypothesis -- `Statement:` on `Set Bool` (join `∪`, ⊥ = ∅) `∅` has two distinct covers in that order, with join -- `Set.univ`, so `hcov` does not fix the target; on a carrier with its own linear order, -- `axb1_gives_unique_target` fixes the cover in that order. Reading: prior art, Winskel, *Event @@ -135,6 +167,8 @@ example : ¬ @IsAtom (Set.Ici (0 : ℕ)) _ Set.Ici.orderBot ⟨2, Nat.zero_le 2 /-! ### § IV. The snap returns to a ⊥ (read as a successor null — a commitment); its 2-adic realization is a loop -/ #check @ZeroParadox.c_da2_novelty -- Statement: contrapositive of the role fact, in one `ZPSemilattice`: a state `≠ bot` cannot satisfy the join-identity. Reading: "distinct successor instantiation" is the reading, not the statement #check @ZeroParadox.snap_arc_z2_loop -- Statement: the `cnfToZp2` image of tower stage 0 is ℤ_[2]'s 0, every stage `n ≥ 1` has a nonzero image, and the images tend to that same 0 +#check @ZeroParadox.arc_q2Val -- Statement: read by `q2Val`, those images are ⊤ of `ℕ∞` at stage 0, `n` at every stage `n ≥ 1`, and tend to ⊤, which is `q2Val` of ℤ_[2]'s 0 (`q2Val_bot`; `ZeroParadox/Valuation/PolePassage.lean`) +#check @ZeroParadox.no_path_zero_infty -- Statement: no continuous path in `Sphere` (`OnePoint ℚ_[2]`) runs from 0 of `ℚ_[2]` to ∞ of `Sphere`. Reading: the loop returns to 0 of `ℚ_[2]` without passing ∞ of `Sphere` (`arc_never_meets_infty`); its `rInv` image is the loop at ∞ (`rInv_arcS`) #check @ZeroParadox.t_iz_limit_is_new_null -- Statement: role half only, in any `ZPSemilattice`: (∀ x, join terminal x = x) → terminal = bot of that semilattice. Novelty is NOT in this statement; do not cite it as the novelty witness /-! ### § V. WHERE the snap is RULED OUT — and what only removes the obstruction @@ -147,11 +181,21 @@ commitment is that the framework's carrier has it. AX-B1 holds at every state wi each has a first distinct state above it, with nothing strictly between. A state with nothing above it owes no step. -/ #check @ZeroParadox.axb1_gives_unique_target -- Statement: on a LINEAR order, AX-B1 at `bot` gives exactly one cover; the `Set Bool` control beside it in `ZeroParadox/Reals/OrderedField.lean` has two -#check @ZeroParadox.HasFirstStep -- Statement: an ORDER predicate — `∃ a, bot ⋖ a`, Mathlib's covering relation. ⚠ `LT ℚ_[p]` does not synthesize, so this is not statable of ℚ_p until an order is supplied (the norm preorder of `ZeroParadox/BottomCannotBe.lean` § ROLE); the p-adic line below fences NORM values, a different predicate +#check @ZeroParadox.HasFirstStep -- Statement: an ORDER predicate — `∃ a, bot ⋖ a`, Mathlib's covering relation. ⚠ `LT ℚ_[2]` does not synthesize (probed at p = 2, the `#check_failure` in `ZeroParadox/BottomCannotBe.lean` § ROLE), so this is not statable of ℚ₂ until an order is supplied (the norm preorder of `ZeroParadox/BottomCannotBe.lean` § ROLE); the p-adic line below fences NORM values, a different predicate #check @ZeroParadox.f_snap_blocked -- Statement: over `Field + LinearOrder + IsStrictOrderedRing`, every positive ε₀ admits a smaller positive δ; the binder ε₀ is any positive element of `F`, a candidate first step above `F`'s 0, not the ordinal #check @ZeroParadox.f_snap_impossible -- Statement: hence no such field has a least positive element. No Archimedean hypothesis appears in the binders #check @ZeroParadox.axb1_fails_in_ordered_field -- Statement: `¬ HasFirstStep (0 : F)`. Reading: AX-B1 is what supplies the step; an ordered field lacks it, and that the framework's carrier has it is the commitment -#check @ZeroParadox.axb1_fails_everywhere_iff_dense -- Statement: the obstruction CHARACTERIZED, over a bare `Preorder` with no field and no topology — `DenselyOrdered α ↔ ∀ bot, ¬ HasFirstStep bot`. `axb1_fails_in_ordered_field` directly above is an instance of its right-hand side; `f_snap_impossible` is the same fact in the halving vocabulary, not an instance of this statement. Density is what obstructs a first step — connectedness is a separate, topological fence (`real_no_snap`) +#check @ZeroParadox.axb1_fails_everywhere_iff_dense -- Statement: the obstruction CHARACTERIZED, over a bare `Preorder` with no field and no topology — `DenselyOrdered α ↔ ∀ bot, ¬ HasFirstStep bot`. `axb1_fails_in_ordered_field` directly above is an instance of its right-hand side; `f_snap_impossible` is the same fact in the halving vocabulary, not an instance of this statement. Reading: CARRIER — density is what obstructs a first step — connectedness is a topological fence (on ℝ, Mathlib's `PreconnectedSpace ℝ` instance, used by the ℝ `example` in `ZeroParadox/Reals/ConnectedNoFirstStep.lean`; `real_no_snap`, not totally disconnected, is weaker); on a linear order with its order topology it implies this one (`no_firstStep_of_preconnected`), and not conversely +#check @ZeroParadox.no_firstStep_of_preconnected -- Statement: on a linear order with its order topology, preconnected gives `¬ HasFirstStep bot` at every `bot`; Mathlib's `denselyOrdered_of_preconnectedSpace` in `HasFirstStep` form, at `[propext, Quot.sound]`. Reading: on one linearly ordered carrier the topological fence implies the order fence, not conversely (the ℚ control in `ZeroParadox/Reals/ConnectedNoFirstStep.lean`) +#check @ZeroParadox.preconnected_iff_no_firstStep -- Statement: on a conditionally complete linear order with its order topology, `PreconnectedSpace α ↔ ∀ bot, ¬ HasFirstStep bot`; the completeness binder carries the backward direction (ℚ is dense and not preconnected) +#check @ZeroParadox.cover_at_zero_iff_not_dense -- Statement: at one point, in a linearly ordered additive commutative group: `HasFirstStep 0` iff the order is not dense; no Archimedean hypothesis (`ZeroParadox/Valuation/PolePassage.lean` § VI) +#check @ZeroParadox.cover_at_zero_iff_int -- Statement: with `[Archimedean G]` added, `HasFirstStep 0` iff `G ≃+o ℤ` +#check @ZeroParadox.hahnArc_loop -- Statement: CONTROL, on `HahnSeries ℚ ℚ`, value group ℚ (no first step at 0), `addVal` of `hahnArc` is ⊤ at stage 0, finite after, and eventually above every rational. Reading: CARRIER — density refuses the value group a first step and does not refuse the valuation loop ⊤ → finite → ⊤ +#check @ZeroParadox.ballLine_covBy -- Statement: in `Set.range ballLine`, the closed balls of radius `2^(-n)` about 0 of `ℚ_[2]` under inclusion, `ballLine (n + 1) ⋖ ballLine n` (`ZeroParadox/Valuation/BallLine.lean`) +#check @ZeroParadox.end_bot_no_first_step -- Statement: in `WithBot (WithTop ℤ)`, that line with both ends adjoined, ⊥ has no first step. Reading: CARRIER — the first step lives at the vertices, not at the ends +#check @ZeroParadox.end_top_covers_nothing -- Statement: in `WithBot (WithTop ℤ)`, nothing is covered by ⊤ +#check @ZeroParadox.radiusPath -- Statement: CONTROL, a path in `ℝ≥0∞` from 0 to ⊤; `ℝ≥0∞` is densely ordered, so 0 has no first step there (`axb1_fails_everywhere_iff_dense`). Reading: CARRIER — the radius order joins the ends and has no first step; read back as balls, a positive radius lands on a vertex (`closedBall_eq_ballLine`) +#check @ZeroParadox.accPt_ballRadii_iff -- Statement: the radii `ballRadii = {2 ^ (-n) | n : ℤ}` of the vertices, in `ℝ≥0∞`, have accumulation points exactly 0 and ⊤ of `ℝ≥0∞`, and each radius is an isolated point (`ballRadii_discrete`). Reading: CARRIER — the radii are discrete away from the two ends and accumulate only at them, the ends at which `WithBot (WithTop ℤ)` has no cover (`end_bot_no_first_step`, `end_top_covers_nothing`); ℤ in ℝ, the control beside it, accumulates nowhere. No first step is supplied, and AX-B1 stays a commitment #check @ZeroParadox.real_no_snap -- Statement: CARRIER — ℝ is NOT totally disconnected #check @ZeroParadox.padic_snaps -- Statement: CARRIER — ℚ_p IS totally disconnected. Reading: this removes the obstruction and supplies no first step — norms accumulate at 0 in ANY non-trivially normed field (Mathlib `NormedField.exists_norm_lt`), ℝ included, so that half is not p-adic #check @ZeroParadox.snap_dichotomy -- Statement: every ℚ_p is totally disconnected and ℝ is not, and for NONTRIVIAL absolute values on ℚ, real and p-adic are exclusive and exhaustive (Ostrowski). ⚠ SCOPE: completions of ℚ only diff --git a/ZeroParadox/Order/UpAndOver.lean b/ZeroParadox/Order/UpAndOver.lean index 45d33c06..ecaebd8d 100644 --- a/ZeroParadox/Order/UpAndOver.lean +++ b/ZeroParadox/Order/UpAndOver.lean @@ -122,13 +122,13 @@ example [Fintype α] : 3 ≤ Fintype.card α := by simpa using Fintype.card_le_of_injective _ hinj /-- `Statement:` a densely ordered carrier carries no `UpAndOver`: density refuses the cover in the - corner (Mathlib `not_covBy`; the corpus form of "no cover anywhere" is + corner (Mathlib `not_covBy_of_denselyOrdered`; the corpus form of "no cover anywhere" is `axb1_fails_everywhere_iff_dense`). Density is sufficient for exclusion, not necessary: `Bool` is not densely ordered and is refused too (§ III). -/ theorem isEmpty_of_denselyOrdered [DenselyOrdered α] : IsEmpty (UpAndOver α) := ⟨fun U => by obtain ⟨y, b, -, hb, -⟩ := U.corner - exact not_covBy hb⟩ + exact not_covBy_of_denselyOrdered hb⟩ end UpAndOver @@ -178,7 +178,7 @@ example : ∃ c : ClosureOperator ℝ, (∀ x, c x = (⌈x⌉ : ℝ)) ∧ c (1 / let c : ClosureOperator ℝ := ClosureOperator.mk' (fun x => (⌈x⌉ : ℝ)) (fun _ _ h => Int.cast_mono (Int.ceil_mono h)) (fun x => Int.le_ceil x) (fun x => by simp) refine ⟨c, fun _ => rfl, ?_, ?_, c.isClosed_iff.2 ?_, c.isClosed_iff.2 ?_, by norm_num, - not_isMax 0, fun _ _ => not_covBy⟩ + not_isMax 0, fun _ _ => not_covBy_of_denselyOrdered⟩ · show ((⌈(1 / 2 : ℝ)⌉ : ℤ) : ℝ) ≠ 1 / 2 norm_num [Int.ceil_eq_iff] · intro h @@ -239,7 +239,7 @@ example : ∃ c : ClosureOperator (WithTop ℚ ⊕ WithTop ℚ), | inr _ => exact Sum.LiftRel.inr le_top) (fun a => by cases a <;> exact le_rfl) refine ⟨c, fun _ => rfl, ⟨Sum.inl ((0 : ℚ) : WithTop ℚ), fun h => ?_⟩, c.isClosed_iff.2 rfl, - c.isClosed_iff.2 rfl, Sum.inl_ne_inr, fun y hy b hb => ?_, fun _ _ => not_covBy⟩ + c.isClosed_iff.2 rfl, Sum.inl_ne_inr, fun y hy b hb => ?_, fun _ _ => not_covBy_of_denselyOrdered⟩ · have : (Sum.inl ⊤ : WithTop ℚ ⊕ WithTop ℚ) = Sum.inl ((0 : ℚ) : WithTop ℚ) := h simp at this · have hy' : f y = y := c.isClosed_iff.1 hy @@ -522,7 +522,7 @@ theorem omega0_opow_succ_ne (a : Ordinal.{u}) : Ordinal.omega0 ^ Order.succ a ≠ Order.succ a := by intro h have hlim := Ordinal.isSuccLimit_opow_left Ordinal.isSuccLimit_omega0 - (lt_of_le_of_lt (zero_le a) (Order.lt_succ a)).ne' + (lt_of_le_of_lt zero_le (Order.lt_succ a)).ne' rw [h] at hlim exact Order.not_isSuccLimit_succ a hlim @@ -592,6 +592,58 @@ theorem ordinalCornerStep_iterate_strictMono : simp only [Function.iterate_succ_apply'] exact lt_ordinalCornerStep _ +/-- `Statement:` at every floor `f`, the run of `α ↦ ω^α` from `succ f` has `ordinalCornerStep f`, the + least fixed point strictly above `f`, as occupant of the die role `PinnedLimitAbove` + (`ZeroParadox/Die.lean` § XXIV). -/ +theorem ordinalCornerStep_pinnedLimitAbove (f : Ordinal.{u}) : + (Motion.ofFun fun α : Ordinal.{u} => Ordinal.omega0 ^ α).IsRun + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ f)) ∧ + PinnedLimitAbove (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ f)) + (ordinalCornerStep f) := by + have hn := Ordinal.isNormal_opow (a := Ordinal.omega0.{u}) Ordinal.one_lt_omega0 + have ha : Order.succ f < Ordinal.omega0 ^ Order.succ f := + lt_of_le_of_ne (hn.strictMono.id_le _) (Ne.symm (omega0_opow_succ_ne f)) + refine ⟨fun n => ?_, ?_, fun ⟨n, hn'⟩ => (Ordinal.iterate_lt_nfp hn.strictMono ha n).ne hn', + ⟨⟨Ordinal.nfp_fp hn _, Ordinal.le_nfp _ _⟩, fun x ⟨hx, hax⟩ => + Ordinal.nfp_le_fp hn.strictMono.monotone hax hx.le⟩, + hn.strictMono.monotone.monotone_iterate_of_le_map ha.le⟩ + · show _ = Ordinal.omega0 ^ _ + simp only [Function.iterate_succ_apply'] + · refine ⟨?_, fun b hb => Ordinal.nfp_le fun n => hb ⟨n, rfl⟩⟩ + rintro _ ⟨n, rfl⟩ + exact (Ordinal.iterate_lt_nfp hn.strictMono ha n).le + +/-- `Statement:` at the floor `ε_o` that occupant is `ε_(o+1)` (Mathlib `Ordinal.epsilon_succ_eq_nfp`): + `ε_(o+1)` occupies `PinnedLimitAbove (ω^·)` at the run from `succ ε_o`, for every `o`. -/ +theorem epsilon_succ_pinnedLimitAbove (o : Ordinal.{u}) : + (Motion.ofFun fun α : Ordinal.{u} => Ordinal.omega0 ^ α).IsRun + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ (Ordinal.epsilon o))) ∧ + PinnedLimitAbove (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ (Ordinal.epsilon o))) + (Ordinal.epsilon (Order.succ o)) := by + rw [Ordinal.epsilon_succ_eq_nfp] + exact ordinalCornerStep_pinnedLimitAbove _ + +-- `Statement:` at the floor `ε_n` the occupant is the corner composite iterated `n + 2` times from 0, +-- ⊥ of `Ordinal` (`ordinalCornerStep_iterate`). +example (n : ℕ) : ordinalCornerStep^[n + 2] (0 : Ordinal.{u}) = + Ordinal.epsilon (Order.succ (n : Ordinal.{u})) := by + rw [ordinalCornerStep_iterate (n + 1), Nat.cast_succ, Order.succ_eq_add_one] + +-- `Statement:` CONTROL, the converse of `PinnedLimit.toAbove` fails: at the run from `succ ε₀`, ε₁ +-- occupies `PinnedLimitAbove (ω^·)` and not `PinnedLimit (ω^·)` (`pinnedLimit_opow_eq_epsilon0`). +example : PinnedLimitAbove (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ (Ordinal.epsilon 0))) + (Ordinal.epsilon 1) ∧ + ¬ PinnedLimit (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) + (fun n => (fun α : Ordinal.{u} => Ordinal.omega0 ^ α)^[n] (Order.succ (Ordinal.epsilon 0))) + (Ordinal.epsilon 1) := by + have h := (epsilon_succ_pinnedLimitAbove (0 : Ordinal.{u})).2 + rw [show Order.succ (0 : Ordinal.{u}) = 1 from by rw [Order.succ_eq_add_one, zero_add]] at h + exact ⟨h, fun hp => (Ordinal.veblen_right_strictMono 1 zero_lt_one).ne + (pinnedLimit_opow_eq_epsilon0 _ _ hp).symm⟩ + /-- `Statement:` no ordinal steps, under `ordinalSuccMotion`, to an iterate of the corner composite from 0: 0 is not a successor, and `ε_n` is fixed by `ω^·` while no successor is. -/ theorem not_step_into_ordinalCornerStep_iterate (n : ℕ) (a : Ordinal.{u}) : @@ -666,7 +718,7 @@ theorem ordinalView_zero_least_landing (y : Set.Ici (ordinalCornerStep^[0] (0 : rw [Ordinal.epsilon_zero_eq_nfp] exact Ordinal.nfp_le_fp (Ordinal.isNormal_opow (a := Ordinal.omega0.{u}) Ordinal.one_lt_omega0).strictMono.monotone - (zero_le _) hfix.le + zero_le hfix.le /-- `Statement:` every step of `ordinalView n` into its ⊥ starts at that ⊥. -/ theorem ordinalView_bot_noEntry (n : ℕ) : ∀ a, (ordinalView.{u} n).step a ⊥ → a = ⊥ := @@ -799,6 +851,8 @@ open ZeroParadox #print axioms ordinalSuccMotion_agree #print axioms ordinalSuccMotion_elbow #print axioms ordinalCornerStep_iterate_strictMono +#print axioms ordinalCornerStep_pinnedLimitAbove +#print axioms epsilon_succ_pinnedLimitAbove #print axioms not_step_into_ordinalCornerStep_iterate #print axioms ordinalView #print axioms ordinalView_bot_isLanding diff --git a/ZeroParadox/Order/WellFoundedObstruct.md b/ZeroParadox/Order/WellFoundedObstruct.md index d74b2136..ff71175a 100644 --- a/ZeroParadox/Order/WellFoundedObstruct.md +++ b/ZeroParadox/Order/WellFoundedObstruct.md @@ -7,7 +7,10 @@ described at each declaration, not listed again here. ## The question, and the complementary test it forms This is the **complementary test to `ZeroParadox/Valuation/PadicAttractor.lean`**, refining **Axis I** -of the bottom-diagram tree (`.claude-local/notes/thread_obstruction_table_2026-06-29.md`). +of the bottom-diagram tree, the split between well-founded and non-well-founded floors (here, the +well-founded floor against the contraction / attractor floors) +(node numbers `#2` to `#5` are those of the reading key in `BOTTOMELEMENT.md`; node #1, the floor 0 of +ℕ, is an instance of that key's unnumbered `Lat ⊥` row). `PadicAttractor.lean` gave node #3 (the p-adic floor `{0} ⊆ Q₂`) a genuine **dynamical attractor** character: `0` is the global attractor of the doubling map `x ↦ 2·x`, because `‖2‖₂ = ½ < 1` makes the map a strict contraction, so every orbit `2ⁿ·x` is an **infinite, non-terminating** sequence converging diff --git a/ZeroParadox/Ordinal/B6_CanonicalCNF.lean b/ZeroParadox/Ordinal/B6_CanonicalCNF.lean index aefa2365..82e62f2d 100644 --- a/ZeroParadox/Ordinal/B6_CanonicalCNF.lean +++ b/ZeroParadox/Ordinal/B6_CanonicalCNF.lean @@ -5,8 +5,8 @@ set_option maxHeartbeats 800000 /-! # B6 (pipeline): canonical (CNF / log-ω) ordinal → 2-adic, valuation growth NOT tower-defined -P8 built `α ↦ 2 ^ (least tower stage above α)`: a real ε₀→0 limit, but the rank is defined *via the -tower*, so the valuation growth is built into the encoding — a constructed witness, not an independent +P8 built `α ↦ 2 ^ (least tower stage above α)`: the tower's encodings tend to 0, but the rank is +defined *via the tower*, so the valuation growth is built into the encoding — a constructed witness, not an independent ordinal↔2-adic identity. B6 closes that gap with a measure read from the ordinal's **own** Cantor-normal structure: `cnfLogDepth α` = the number of times you can apply `log ω` before reaching 0. `log ω α` is the leading CNF exponent of `α`; iterating it walks down the CNF tree. The tower appears **only in the diff --git a/ZeroParadox/Ordinal/CnfBridge.lean b/ZeroParadox/Ordinal/CnfBridge.lean index 872e9818..4b25c75f 100644 --- a/ZeroParadox/Ordinal/CnfBridge.lean +++ b/ZeroParadox/Ordinal/CnfBridge.lean @@ -12,7 +12,9 @@ One sequence `towerNONote` has two realizations, connected by maps and never by into `Ordinal`, closing at the least fixed point ε₀, and `cnfToZp2` into `ℤ_[2]`, with norm-limit 0 (`mu_construction_correspondence`). The *identification of these two limits* — ε₀ (∈ `Ordinal`) with 0 (∈ `ℤ_[2]`) — is not a well-formed statement: it fails to elaborate (a type mismatch between -`Ordinal` and `ℤ_[2]`). `cnf_bridge_type_boundary` co-witnesses the two limits instead. +`Ordinal` and `ℤ_[2]`). `cnf_bridge_type_boundary` co-witnesses ε₀'s least-fixed-point face with +the images' limit 0 instead (its statement line: `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § V); +ε₀'s supremum face is a conjunct of `mu_construction_correspondence`. Long form: `ZeroParadox/Ordinal/CnfBridge.md`. ## Engineer's Take @@ -56,20 +58,22 @@ theorem tower_orders_agree (m n : ℕ) : ↔ (cnfToZp2 (towerNONote m)).valuation < (cnfToZp2 (towerNONote n)).valuation := (tower_repr_orderEmbedding m n).symm.trans (tower_valuation_orderEmbedding m n) -/-! ## § II. The shared seed maps to ⊥ on both sides -/ +/-! ## § II. The shared seed maps to each carrier's floor: ⊥ of `Ordinal`, and ℤ_[2]'s 0 -/ -/-- **Shared seed → both bottoms.** The NONote seed `towerNONote 0` (the NONote bottom `0`) maps to - the `Ordinal` bottom ⊥ under `NONote.repr`, and to the `ℤ_[2]` bottom 0 under `cnfToZp2`. -/ +/-- **Shared seed → both floors.** The NONote seed `towerNONote 0` (the NONote `0`) maps to + ⊥ of `Ordinal` under `NONote.repr`, and to ℤ_[2]'s 0 under `cnfToZp2` — least in ℤ_[2] under + the 2-adic norm and greatest under the valuation preorder (`z2_two_views`, indexed in + `ZeroParadox/BottomCannotBe.lean`). -/ theorem seed_maps_to_bot_both : NONote.repr (towerNONote 0) = (⊥ : Ordinal) ∧ cnfToZp2 (towerNONote 0) = (0 : ℤ_[2]) := ⟨by rw [towerNONote_repr, tower_stage_zero]; exact Ordinal.bot_eq_zero.symm, cnfToZp2_zero⟩ -/-! ## § III. The 2-adic realization loops through ⊥ (the diagonal fixed point, concretely) -/ +/-! ## § III. The 2-adic realization loops through ℤ_[2]'s 0 (the diagonal fixed point, concretely) -/ -/-- **Loop through ⊥.** Under `cnfToZp2` the seed's image and the limit of the stages' images are both the - *value* 0 in `ℤ_[2]`. So the ordinal ascent ⊥ → ε₀ realizes as a `ℤ_[2]` path departing 0 and - whose norm returns to 0. This is a value coincidence at 0, NOT an identity: ⊥ is never ε₀ (ε₀ is the least fixed +/-- **Loop through ℤ_[2]'s 0.** Under `cnfToZp2` the seed's image and the limit of the stages' images are both the + *value* 0 in `ℤ_[2]`. So the ordinal ascent from ⊥ of `Ordinal` to ε₀ realizes as a `ℤ_[2]` path departing 0 and + whose norm returns to 0. This is a value coincidence at 0, NOT an identity: ⊥ of `Ordinal` is never ε₀ (ε₀ is the least fixed point of `α ↦ ω^α`, never the same as ⊥ — and **not** order-adjacent to it, see `epsilonZero_tower_lt`), and the images of the finite stages n ≥ 1 are all ≠ 0 (next to the floor, never it; `snap_arc_z2_loop`). `ε₀ = 0` with 0 the 2-adic zero stays ill-typed: it fails to elaborate. -/ theorem tower_image_loops_to_seed : @@ -87,7 +91,7 @@ theorem tower_image_loops_to_seed : * in `Ordinal` via `NONote.repr`: as `fundamentalSeq`, closing at the **least fixed point** ε₀ of `α ↦ ω^α` from ⊥ (`epsilon0_isLeastFixedPointFrom`); * in `ℤ_[2]` via `cnfToZp2`: as a norm-limit to **0**; - sharing the seed ⊥ (§II). The object realized is the construction, not a value: ε₀ and 0 are its + sharing the seed, which lands on ⊥ of `Ordinal` and on ℤ_[2]'s 0 (§II). The object realized is the construction, not a value: ε₀ and 0 are its two carrier-specific closures. -/ theorem mu_construction_correspondence : -- ordinal realization of the shared tower @@ -121,12 +125,13 @@ example : epsilonZero ≠ (0 : Ordinal) := epsilon0_ne_zero -- (`Ordinal` against `ℤ_[2]`, with no coercion between them). #check_failure (epsilonZero = (0 : ℤ_[2])) -/-! ## § VI. The snap arc as one object — the ℤ_[2] loop through ⊥ -/ +/-! ## § VI. The snap arc as one object — the ℤ_[2] loop through 0 -/ -/-- **The snap arc, as one `ℤ_[2]` loop through ⊥.** The ordinal ascent ⊥ → ε₀ realizes, through - `cnfToZp2`, as a single arc in `ℤ_[2]` with three phases: +/-- **The snap arc, as one `ℤ_[2]` loop through 0.** The ordinal ascent from ⊥ of `Ordinal` to ε₀ + realizes, through `cnfToZp2`, as a single arc in `ℤ_[2]` with three phases: - 1. **START at the floor** — `cnfToZp2 (towerNONote 0) = 0`: the arc begins at ⊥. + 1. **START at the floor** — `cnfToZp2 (towerNONote 0) = 0`: the arc begins at ℤ_[2]'s 0, least + in ℤ_[2] under the 2-adic norm (and greatest under the valuation preorder). 2. **DEPARTURE by a discrete jump** — `∀ n ≥ 1, cnfToZp2 (towerNONote n) ≠ 0`: the trajectory genuinely leaves 0. The image of the first stage has 2-adic valuation 1 (`cnfToZp2_tower_valuation`), hence norm 1/2, so the norm jumps 0 → 1/2 with no intermediate stage — there is no continuous path @@ -137,7 +142,7 @@ example : epsilonZero ≠ (0 : Ordinal) := epsilon0_ne_zero The loop closes because the images reapproach 0 in `ℤ_[2]` (equivalently, their 2-adic norms tend to 0 in `ℝ`: the equivalence is Mathlib's `tendsto_zero_iff_norm_tendsto_zero`, and the `example` below applies its forward direction `.1`), landing back on the floor — NOT - because ⊥ and ε₀ are one point: **⊥ is never ε₀** (ε₀ is the least fixed point of `α ↦ ω^α`), never identical — and **not** order-adjacent, see + because ⊥ of `Ordinal` and ε₀ are one point: **⊥ of `Ordinal` is never ε₀** (ε₀ is the least fixed point of `α ↦ ω^α`), never identical — and **not** order-adjacent, see `epsilonZero_tower_lt` — and the images of the finite stages n ≥ 1 never even reach 0 (always next to, never the same). Honest fence: this is the `ℤ_[2]` realization *via the map*, NOT a proof of `ε₀ = 0` with 0 the 2-adic zero, which stays ill-typed: it fails diff --git a/ZeroParadox/Ordinal/ConstructiveOrdinals.md b/ZeroParadox/Ordinal/ConstructiveOrdinals.md index f72e380d..aee24451 100644 --- a/ZeroParadox/Ordinal/ConstructiveOrdinals.md +++ b/ZeroParadox/Ordinal/ConstructiveOrdinals.md @@ -19,7 +19,9 @@ Key move: ω^x at the notation level is just `oadd x 1 0` (the CNF term with lea coefficient 1, remainder 0) — no general `opow` needed. ε₀ itself is NOT an `ONote` element (the notations name exactly the ordinals < ε₀); ε₀ is their limit. So the snap threshold is characterised *from below*: the ω-tower climbs without bound, and **no notation is a fixed point of ω^·** — the fixed -point (ε₀) is precisely what the notation system cannot reach. +point (ε₀) is what the notation system does not name: no notation bounds the tower +(`tower_no_upper_bound`, `ZeroParadox/Ordinal/SnapNucleusConstructive.lean`), and across the crossing +every notation denotes below ε₀ (`repr_lt_epsilon0`, `ZeroParadox/Ordinal/PricedInterface.lean`). ## Result (proved, this build) @@ -31,14 +33,15 @@ notation is a fixed point of `ω^·`). **It does NOT classify ZP-L's footprint as "representational, not intrinsic"**. That is an *eliminability* claim, and -it cannot be asked of those ε₀ results as stated, because their statements themselves carry the -choice, as the statement control in the next sentence measured 2026-10-08: they are **STATEMENT-CARRIED** +the question does not apply to those ε₀ results as stated, because their statements themselves carry +the choice, as the statement control in the next sentence shows: they are **STATEMENT-CARRIED** (`ZeroParadox/Category/ChoiceCannotBe.md`). ZP-L's `epsilonZero_fixedPoint`, `epsilonZero_eq_nfp`, `epsilonZero_tower_lt` and `epsilonZero_le_fixedPoint` (`ZeroParadox/Ordinal/Gentzen.lean`), and the invariants `epsilon0_ne_zero`, `epsilon0_ne_bot`, `epsilon0_is_fixedpoint` (`ZeroParadox/Ordinal/Epsilon0LeastFP.lean`) and `epsilon0_eq_nfp_bot` (`ZeroParadox/Ordinal/Epsilon0MinMax.lean`), each only assumed in a theorem that proves `True`, already -report `Classical.choice` (statement control, measured 2026-10-08), so no re-proof of them can drop it. +report `Classical.choice` (statement control, measured 2026-10-08; for `epsilon0_eq_nfp_bot` the +live record is the named statement control `epsilon0EqNfpBotStatement`, printed in that file), so no re-proof of them can drop it. A restatement cannot be had on `ONote`, which does not name ε₀: inside the carrier no notation bounds the tower (`tower_no_upper_bound`, `ZeroParadox/Ordinal/SnapNucleusConstructive.lean`, `[propext]`), and @@ -48,15 +51,22 @@ across the crossing every notation denotes below ε₀ (`repr_lt_epsilon0`, (`ZeroParadox/Ordinal/PricedInterface.lean`), the notations with one top adjoined, the fixed point of `e0OmegaPow` (ω^· extended to fix ⊤ by definition) is unique by theorem (`e0OmegaPow_fixedpoint_iff`, `[propext]`) and exists by definition (`e0OmegaPow_top`, proved by `rfl`), on an order that is not well-founded (the `example` stating -`¬ WellFoundedLT E0Note`). The **derived** one is open: a well-founded Lean carrier on which -ε₀'s fixed point is derived, leastness included, with no `Classical.choice` in the `#print axioms` of -those declarations, is not located as of 2026-10-08. Leastness is proved on `Ordinal` with choice -(`epsilon0_min_eq_max`); how such a footprint splits between a statement as written and its proof is -measured in `ZeroParadox/Ordinal/OrdinalChoiceEssential.lean` § III, with the STATEMENT-CARRIED bin -defined in `ZeroParadox/Category/ChoiceCannotBe.md`. Searched -2026-10-08: `ZeroParadox/**/*.lean` for `WellFounded`, `IsWellOrder` and `Acc`; the Mathlib pin's -notation systems were surveyed 2026-08-02 in `ZeroParadox/Ordinal/SnapNucleusConstructive.md`. The -crossing into `Ordinal`, `e0Repr`, carries choice. The current state is in `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint. +`¬ WellFoundedLT E0Note`). The **derived** one is open: a well-founded Lean carrier whose statements +are choice-free, on which ε₀'s fixed point is derived, by a choice-free derivation, rather than set by definition, leastness included, +was not located as of 2026-10-13 (the record of that search is `ZeroParadox/Ordinal/SnapNucleus.md` +§ Axiom footprint), and again as of 2026-11-01, searched as follows: `ZeroParadox/**/*.lean` for +`WellFounded`, `IsWellOrder` and `Acc` together with ε₀ / `epsilon` / `nfp` (every ε₀ hit is on +`Ordinal` or on `E0Note`); the pinned Mathlib for `ε₀` / `epsilon0` / `epsilon_zero` (the hits naming the ordinal ε₀, as +opposed to real-valued variables of that name, are only `SetTheory/Ordinal/Veblen.lean`, on `Ordinal`, and `SetTheory/Ordinal/Notation.lean`, whose +`fastGrowingε₀` docstring says ε₀ "is not an `ONote`"); and LeanExplore for a well-founded notation carrying a +fixed point of ω^· (hits on `Ordinal`, `ONote`'s well-foundedness, and generic fixed-point +theorems). This file's own earlier corpus search for that item as then worded, 2026-10-08, grepped +`ZeroParadox/**/*.lean` for `WellFounded`, `IsWellOrder` and `Acc`; the Mathlib pin's notation systems +were surveyed 2026-08-02 in `ZeroParadox/Ordinal/SnapNucleusConstructive.md`. Leastness is proved on +`Ordinal` with choice (`epsilon0_min_eq_max`); how such a footprint splits between a statement as +written and its proof is measured in `ZeroParadox/Ordinal/OrdinalChoiceEssential.lean` § III, with the +STATEMENT-CARRIED bin defined in `ZeroParadox/Category/ChoiceCannotBe.md`. The crossing into +`Ordinal`, `e0Repr`, carries choice. The item was checked against two carriers of MaxWellApexLab/OrdinalAnalysis at commit `87baec70db931cda0df00167d68bd16defb4f7bf` (namespace `OrdinalAnalysis`, paths under `OrdinalAnalysis/Ordinal/`, @@ -101,9 +111,9 @@ is carried by its own statement (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom f This is the snap *from below* (ε₀ is the unreachable fixed point). On `ONote` the matching *minimality* ("ε₀ is the LEAST fixed point") cannot be stated, because it quantifies over the limit, -which no notation names (`tower_no_upper_bound`; across the crossing, `repr_lt_epsilon0`). Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); a -choice-free proof of it on a well-founded Lean carrier is part of the open item under Result above, where the searched -scope and its dates are stated. The other carriers +which no notation names (`tower_no_upper_bound`; across the crossing, `repr_lt_epsilon0`). Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); its +derivation on a well-founded Lean carrier whose statements are choice-free is the derived reading of the open item +under Result above, where the searched scope and its dates are stated. The other carriers are in `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint. ## Prior art @@ -140,15 +150,16 @@ Read from the arXiv v2 PDF: Two Lean carriers of MaxWellApexLab/OrdinalAnalysis, `ThetaNote` and `Gamma0Note`, are named against the open item under Result above. -The Coq precedent on the same carrier is Castéran and Contejean's *hydra-battles*; its credit, including -the comparator and the order construction, is in `ZeroParadox/Ordinal/SnapNucleusConstructive.md` -§ Prior art. +The Coq precedent on the same carrier is *hydra-battles*, credited to the hydra-battles authors, as in +`ZeroParadox/Ordinal/SnapNucleusConstructive.md` § Prior art, which also holds the credit for the +comparator and the order construction. **The delta, stated narrowly.** Their split is decidability and constructive taboos (excluded middle, WLPO) in homotopy type theory; ZP-N's is a `Classical.choice` footprint in Lean, measured by `#print axioms` against Mathlib's `Ordinal`. The instruments differ: a taboo result says a statement implies excluded middle or WLPO, while a footprint is about one proof, or, under the statement control, -about one statement's type. Their `Cnf` is the binary trees cut out by a predicate `isCNF` (§ 3.1, p. 4), the same shape as -Mathlib's `NONote`, the notations cut out by `NF`. The side finding above arises because Mathlib's `NF` is +about one statement's type. Their `Cnf` is the binary trees cut out by a predicate `isCNF` (§ 3.1, p. 4), analogous to +Mathlib's `NONote`, the notations cut out by `NF`; their trees are binary, while an `ONote` node +`oadd e n a` also carries a coefficient `n`. The side finding above arises because Mathlib's `NF` is defined through `repr` into `Ordinal`; `isCNF` is stated with the lexicographic order on trees. What is ZP-N's is the measurement on these Lean declarations, not the mathematics. diff --git a/ZeroParadox/Ordinal/Epsilon0CannotBe.lean b/ZeroParadox/Ordinal/Epsilon0CannotBe.lean index 2e94428d..dff8e253 100644 --- a/ZeroParadox/Ordinal/Epsilon0CannotBe.lean +++ b/ZeroParadox/Ordinal/Epsilon0CannotBe.lean @@ -7,6 +7,7 @@ import ZeroParadox.Ordinal.PricedInterface import ZeroParadox.Order.LeastFixedPoint import ZeroParadox.Valuation.SemilatticeInstance import ZeroParadox.Multihomed.BoundaryOrder +import ZeroParadox.Information.SnapEpsilonZero /-! # Machine-checked characterization index of ε₀ — what ε₀ IS and what it IS NOT @@ -122,9 +123,15 @@ example (o : NONote) : o.repr < Ordinal.epsilon 0 := ZeroParadox.repr_lt_epsilon -- Statement: in `Ordinal` under `α ↦ ω^α`, at every seed `a` the at-or-above closure `nfp (ω^·) a` -- equals § I-b's strict form `nfp (ω^·) (succ a)` exactly when `ω^a ≠ a`; at the seed `0`, ⊥ of -- `Ordinal`, the two are equal. --- Reading: the schema and the ε₀ role part exactly at the fixed points. At a fixed-point floor such --- as `ε_o` the schema returns that floor (§ I-b, `nfp f = f`), so the ε₀ role is taken strictly --- above it, at `ε_(o+1)` (`Ordinal.epsilon_succ_eq_nfp`, § I-b). +-- Reading: the BIFURCATION (Tim's word). One carrier, `Ordinal`, two operators: the at-or-above +-- closure `nfp (ω^·) a`, the schema at the seed `a`, and the strictly-above form +-- `nfp (ω^·) (succ a)`, the ε₀ role above the floor `a`. They part exactly at the fixed points of +-- `α ↦ ω^α`: at a fixed-point floor such as `ε_o` the schema returns that floor (§ I-b, +-- `nfp f = f`), so the ε₀ role is taken strictly above it, at `ε_(o+1)` +-- (`Ordinal.epsilon_succ_eq_nfp`). At the seed ε₀ the first holds at ε₀ and the second climbs to +-- ε₁: one point, two branches, both at once. Kind: INVARIANT off the fixed points; the parting is +-- the content. Not CARRIER: the carrier never changes. Not the dynamical-systems sense (a +-- qualitative change as a parameter of the map varies): only the seed varies; the map does not. example : (∀ a : Ordinal.{u}, Ordinal.nfp (fun α => Ordinal.omega0 ^ α) a = Ordinal.nfp (fun α => Ordinal.omega0 ^ α) (Order.succ a) ↔ Ordinal.omega0 ^ a ≠ a) ∧ Ordinal.nfp (fun α => Ordinal.omega0 ^ α) (0 : Ordinal.{u}) = @@ -151,6 +158,8 @@ example : (∀ a : Ordinal.{u}, Ordinal.nfp (fun α => Ordinal.omega0 ^ α) a = -- Statement: the strict form in the floor-below boundary model: `↑ε₀` is the least closed point -- (landing) of `phaseUpAndOver.up` strictly above ⊥ of `WithBot Ordinal`. #check @ZeroParadox.phase_epsilon0_isLeast_landing_above_floor +#check @ZeroParadox.phase_snap_of_MLRandom -- Statement: CORNER: on `WithBot Ordinal` under join `max`, if the tape `w` is Martin-Löf random for `trials p hp` with `0 < p`, some run's first step covers ⊥ of `WithBot Ordinal` at the snap `↑0`, not at `↑ε₀`, and `phaseUpAndOver.up` sends `↑0` to `↑ε₀`; one way +#check @ZeroParadox.epsilonOrZero_snap_of_MLRandom -- Statement: COVER: on `EpsilonOrZero`, whose ⊥ is 0 of `Ordinal`, under the same hypothesis some run's first step covers that ⊥ with value ε₀ ≠ 0; one way. Reading: ε₀ occupies the cover of that floor, never the floor (§ I) /-! ### § II. What ε₀ IS — the construction: first fixed point of the ω-tower from ⊥ of `Ordinal` -/ #check @ZeroParadox.epsilon0_eq_nfp_bot -- Statement: ε₀ = nfp (ω^·) ⊥, seeded at ⊥ of `Ordinal` @@ -163,6 +172,12 @@ example : (∀ a : Ordinal.{u}, Ordinal.nfp (fun α => Ordinal.omega0 ^ α) a = #check @ZeroParadox.epsilon0_min_eq_max -- Statement: ε₀ is the sup of the tower ∧ the least fixed point of ω^· (`IsLeast`) #check @ZeroParadox.epsilon0_least_fixedpoint -- Statement: the MIN face, lower-bound half only: ε₀ ≤ every fixed point of ω^· #check @ZeroParadox.epsilonZero_eq_iSup -- Statement: the MAX face: ε₀ is the supremum of the ω-tower +#check @ZeroParadox.snap_epsilon0_two_faces -- Statement: on `WithBot Ordinal`, `up` sends the snap `↑0` to `↑ε₀` and ε₀ is the tower's supremum; on `EpsilonOrZero`, ε₀ covers 0 of `Ordinal` and is the least fixed point of ω^·; the iso sends that cover to `up`'s landing from the snap. Reading: one face per carrier, related by the iso, neither collapsed into the other +#check @ZeroParadox.epsilon0_pinnedLimit -- Statement: the tower is a run of ω^·, and ε₀ occupies the die role `PinnedLimit` (least upper bound of the stages, not a stage, least fixed point, the run climbing: `Monotone s`, a property of the run, distinct from the motion property `Motion.Climb`) +#check @ZeroParadox.epsilon0_not_pinnedLimitUnique -- Statement: and not its strong form `PinnedLimitUnique`: ε₁ is another fixed point +#check @ZeroParadox.pinnedLimit_opow_eq_epsilon0 -- Statement: under ω^·, every occupant of `PinnedLimit`, over any run, is ε₀; so ε₁, the § I-b role at the floor ε₀, occupies none +#check @ZeroParadox.ordinalCornerStep_pinnedLimitAbove -- Statement: at every floor `f`, the § I-b strict form `ordinalCornerStep f` occupies the relative form `PinnedLimitAbove (ω^·)` at the run from `succ f` +#check @ZeroParadox.epsilon_succ_pinnedLimitAbove -- Statement: at the floor ε_o that occupant is ε_(o+1), for every `o` (`ZeroParadox/Order/UpAndOver.lean` § V) #check @ZeroParadox.nothing_between_is_a_step -- Statement: no ordinal below ε₀ is fixed by ω^·. Reading: the in-between ordinals are stages of the ascent, not landings #check @ZeroParadox.bot_is_not_a_step -- Statement: ω^0 ≠ 0: ⊥ of `Ordinal` is not fixed by ω^·. Reading: with the line above, ε₀ is the first landing in the FIXED-POINT order; ⊥ ⋖ ε₀ is false and is not claimed -- Reading: ε₀ is the minimum step next to the pole, never the pole: "next to" in the fixed-point order diff --git a/ZeroParadox/Ordinal/Epsilon0LeastFP.lean b/ZeroParadox/Ordinal/Epsilon0LeastFP.lean index 0da5f6db..a8440a60 100644 --- a/ZeroParadox/Ordinal/Epsilon0LeastFP.lean +++ b/ZeroParadox/Ordinal/Epsilon0LeastFP.lean @@ -50,9 +50,10 @@ theorem bot_is_not_a_step : Ordinal.omega0 ^ (0 : Ordinal) ≠ (0 : Ordinal) := `nothing_between_is_a_step` says no point strictly below ε₀ is a landing; the theorems below say the complement, that **every point at or below ε₀ reaches the SAME landing**. ⚠ The general fact is that -`nfp (ω^·) a` is the least ε-number `≥ a`, so no ε-number can test it. The cells partition the seeds; -the intervals `(ε_o, ε_(o+1)]` miss each limit-index ε-number (`limit_cell_eq_singleton`). -Veblen's classical form, the three traps, and the SHAPE-never-instance-of fence: `ZeroParadox/Ordinal/Epsilon0LeastFP.md`. -/ +`nfp (ω^·) a` is the least ε-number `≥ a`, so no ε-number can test it. Every landing is some `ε_o` with a +unique index, so the cells partition the seeds (the `example` after `limit_cell_eq_singleton`); the intervals +`(ε_o, ε_(o+1)]` do not cover them. What they miss, Veblen's classical form, the three traps, and the +SHAPE-never-instance-of fence: `ZeroParadox/Ordinal/Epsilon0LeastFP.md`. -/ /-- **`Statement:` every seed at or below ε₀ reaches ε₀.** The least fixed point *from* `a` is ε₀ for every `a ≤ ε₀`, so within that range the seed carries no information: `≤` because ε₀ is itself a @@ -162,7 +163,7 @@ example (s : Ordinal) : ∃! o, Ordinal.nfp (fun a => ω ^ a) s = Ordinal.epsilo have hr : Ordinal.nfp (fun a => ω ^ a) s ∈ Set.range (Ordinal.veblen 1) := by rw [Ordinal.mem_range_veblen one_ne_zero] intro b hb - have hb0 : b = 0 := Order.lt_one_iff_nonpos.mp hb |>.antisymm (zero_le b) + have hb0 : b = 0 := Order.lt_one_iff_nonpos.mp hb |>.antisymm (zero_le (a := b)) subst hb0 simpa [Ordinal.veblen_zero] using hfp obtain ⟨o, ho⟩ := hr diff --git a/ZeroParadox/Ordinal/Epsilon0LeastFP.md b/ZeroParadox/Ordinal/Epsilon0LeastFP.md index 0a414aef..a64a639b 100644 --- a/ZeroParadox/Ordinal/Epsilon0LeastFP.md +++ b/ZeroParadox/Ordinal/Epsilon0LeastFP.md @@ -99,21 +99,29 @@ on its own. Below ε₀ it is constantly ε₀; `epsilon_succ_eq_nfp` gives `nfp * **No ε-number can test it.** Every ε-number is a fixed point, so `nfp (ω^·) ε₁ = ε₁` and likewise at every rung — the whole family is blind to the difference between the general fact and *"above ε₀ the seed does all the work"*, which is false. Test above ε₀ with a **non**-fixed point such as `succ ε₀`. -* **The rungs do NOT partition.** The intervals `(ε_o, ε_(o+1)]` miss every **limit**-index ε-number, - e.g. `ε_ω`. +* **The intervals between rungs do not cover the seeds.** The intervals `(ε_o, ε_(o+1)]` + (`successor_cell_eq_Ioc`) miss the first cell `[0, ε₀]` (`first_cell_eq_Iic`; index 0 is neither a + successor nor a limit, `Order.not_isSuccLimit_bot`) and every **limit**-index ε-number, e.g. `ε_ω`, + which lies in no such interval (`Ordinal.veblen_right_strictMono`). The cells, as fibres of the landing + map, do partition the seeds: every landing is some `ε_o` with a unique index (`Ordinal.veblen_injective`; + the `example` after `limit_cell_eq_singleton` in `ZeroParadox/Ordinal/Epsilon0LeastFP.lean`). For any + normal map the landings are the values of its derivative, itself normal (`Ordinal.mem_range_deriv`, + `Ordinal.isNormal_deriv`). * **Normality is essential**: the implication fails for a non-normal operator. `Reading:` **INVARIANT** (conjectural) — the framework reads this as the ratified **"iterative bottoms"** -picture: the rungs of the succession are bottoms *relative to their iteration*, **never ⊥ itself**, and -⊥ sits at the base of the interval without being distinguished within it. The same **shape** is a +picture: the rungs of the succession are bottoms *relative to their iteration*, **never ⊥ of +`Ordinal`**, and ⊥ of `Ordinal` sits at the low end of `[0, ε₀]` without being distinguished +within it. The same **shape** is a theorem in another carrier, `every_node_is_a_floor` (`ZeroParadox/Valuation/LocalFloor.lean`). ⚠ **SHAPE, never instance-of.** Different carriers, different mechanisms — self-similarity there, the absence of fixed points strictly below ε₀ here — and the two theorems conclude **different propositions**. `ℕ → Fin 2` is not `Ordinal`; only the moral is shared. -⚠ **`ε₀ ≠ ⊥` is untouched bedrock** (`epsilon0_ne_bot`), and the ratified vocabulary exists precisely -because the rungs are **not** ⊥. **Nothing here identifies any rung with ⊥.** +⚠ **`ε₀ ≠ ⊥` in `Ordinal` is untouched bedrock** (`epsilon0_ne_bot`), and the ratified vocabulary +exists precisely because the rungs are **not** ⊥ of `Ordinal`. **Nothing here identifies any rung +with ⊥ of `Ordinal`**; a rung is ⊥ of its own up-set `Set.Ici rung`, which is a different carrier. ⚠ **"Iterative bottom" is the ratified term for the ITERATION sense.** Do not substitute "local bottom" *there* — that phrase is taken for the per-domain MC-1 family diff --git a/ZeroParadox/Ordinal/Epsilon0MinMax.lean b/ZeroParadox/Ordinal/Epsilon0MinMax.lean index ae33069d..4f06997e 100644 --- a/ZeroParadox/Ordinal/Epsilon0MinMax.lean +++ b/ZeroParadox/Ordinal/Epsilon0MinMax.lean @@ -15,8 +15,8 @@ redundant and believed to be stronger representation. --- ## Formal Overview -Minimum and maximum are the two faces of a **least fixed point**, so ε₀ -carrying both is a signature rather than a tension. Why, and the two fences on reading ⊥ as *the* +Minimum and maximum are the two faces of a **least fixed point** reached by iterating a normal +map (`α ↦ ω^α` here), so ε₀ carrying both is a signature rather than a tension. Why, and the two fences on reading ⊥ as *the* seed: `ZeroParadox/Ordinal/Epsilon0MinMax.md`. -/ @@ -87,19 +87,92 @@ theorem epsilon0_min_eq_max : refine ⟨epsilonZero_eq_iSup, epsilonZero_fixedPoint, fun o ho => ?_⟩ exact epsilon0_least_fixedpoint o ho +/-! ### Statement controls + +Each statement below, written as a `Prop` with no proof attached, so that the purity block prints the +footprint the STATEMENT carries by itself (the statement control of +`ZeroParadox/Category/ChoiceCannotBe.md`). The `example`s tie each control to its theorem: they stop +compiling if the theorem's statement changes. -/ + +/-- `Statement:` the statement of `epsilon0_eq_nfp_bot`, at universe 0, as a bare proposition. -/ +def epsilon0EqNfpBotStatement : Prop := + epsilonZero = Ordinal.nfp (fun α : Ordinal.{0} => Ordinal.omega0 ^ α) (⊥ : Ordinal.{0}) + +/-- `Statement:` the statement of `epsilon0_min_eq_max`, at universe 0, as a bare proposition. -/ +def epsilon0MinMaxStatement : Prop := + epsilonZero.{0} = ⨆ n : ℕ, fundamentalSeq.{0} n + ∧ IsLeast {o : Ordinal.{0} | Ordinal.omega0 ^ o = o} epsilonZero + +example : epsilon0EqNfpBotStatement := epsilon0_eq_nfp_bot +example : epsilon0MinMaxStatement := epsilon0_min_eq_max + +/-! ### § III. ε₀ occupies the die role `PinnedLimit` (`ZeroParadox/Die.lean` § XXIV) + +`Statement:` COINCIDENCE, the two faces of § II as one role: the tower from ⊥ of `Ordinal` is a climbing +run of `α ↦ ω^α` (`Monotone s`, a property of the run, distinct from the motion property +`Motion.Climb`), and ε₀ is its least upper bound, is not a stage, and is the least fixed point. Under +`α ↦ ω^α` every occupant of `PinnedLimit`, over any run, is ε₀ (`pinnedLimit_opow_eq_epsilon0`). -/ + +universe u + +/-- `Statement:` `fundamentalSeq` is a run of `Motion.ofFun (ω^·)`, and ε₀ occupies + `PinnedLimit (ω^·) fundamentalSeq`, by `epsilon0_min_eq_max`, `epsilonZero_tower_lt` and + `fundamentalSeq_strictMono`. -/ +theorem epsilon0_pinnedLimit : + (Motion.ofFun fun α : Ordinal => Ordinal.omega0 ^ α).IsRun fundamentalSeq ∧ + PinnedLimit (fun α : Ordinal => Ordinal.omega0 ^ α) fundamentalSeq epsilonZero := by + obtain ⟨hsup, hleast⟩ := epsilon0_min_eq_max + refine ⟨fun n => ?_, ?_, fun ⟨n, hn⟩ => (epsilonZero_tower_lt n).ne hn, hleast, + (strictMono_nat_of_lt_succ fundamentalSeq_strictMono).monotone⟩ + · show fundamentalSeq (n + 1) = Ordinal.omega0 ^ fundamentalSeq n + simp only [fundamentalSeq, Function.iterate_succ_apply'] + · rw [hsup] + exact isLUB_ciSup ⟨epsilonZero, fun _ ⟨n, hn⟩ => hn ▸ (epsilonZero_tower_lt n).le⟩ + +/-- `Statement:` ε₀ does not occupy `PinnedLimitUnique (ω^·) fundamentalSeq`: ε₁ is another fixed + point (Mathlib `Ordinal.omega0_opow_epsilon`). -/ +theorem epsilon0_not_pinnedLimitUnique : + ¬ PinnedLimitUnique (fun α : Ordinal => Ordinal.omega0 ^ α) fundamentalSeq epsilonZero := + fun ⟨_, h⟩ => (Ordinal.veblen_right_strictMono 1 (show (0 : Ordinal) < 1 from zero_lt_one)).ne + (h _ (Ordinal.omega0_opow_epsilon 1)).symm + +/-- `Statement:` under `α ↦ ω^α`, for every run `s`, an occupant of `PinnedLimit (ω^·) s` is ε₀: + clause (c) is leastness over all of `Ordinal`, and ε₀ is that least fixed point. -/ +theorem pinnedLimit_opow_eq_epsilon0 (s : ℕ → Ordinal.{u}) (c : Ordinal.{u}) + (h : PinnedLimit (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) s c) : c = epsilonZero := + h.2.2.1.unique ⟨epsilonZero_fixedPoint, fun o ho => epsilon0_least_fixedpoint o ho⟩ + +-- `Statement:` ε₀'s occupancy is closure ordinal ω for `α ↦ ω^α` from ⊥ of `Ordinal`: the tower's +-- least upper bound is fixed and no stage is (`pinnedLimit_iff_closure_omega`). +example : PinnedLimit (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) fundamentalSeq.{u} epsilonZero.{u} ↔ + (IsLUB (Set.range fundamentalSeq.{u}) epsilonZero.{u} ∧ Ordinal.omega0 ^ epsilonZero.{u} = epsilonZero ∧ + ∀ n, Ordinal.omega0 ^ fundamentalSeq.{u} n ≠ fundamentalSeq n) := by + have := pinnedLimit_iff_closure_omega (fun α : Ordinal.{u} => Ordinal.omega0 ^ α) + (Ordinal.isNormal_opow Ordinal.one_lt_omega0).strictMono.monotone epsilonZero + rw [Ordinal.bot_eq_zero] at this + exact this + end ZeroParadox /-! ## Axiom Purity Check -Both results are corollaries of Mathlib's `Ordinal` fixed-point theory (`nfp`, `epsilon`), which is -classically built. **Status: STATEMENT-CARRIED** (`ZeroParadox/Category/ChoiceCannotBe.md`): both -statements, only assumed, already report `Classical.choice` (statement control, measured 2026-10-08). -The choice is NOT in the `Ordinal` type (`[propext, Quot.sound]`); it enters through the order instance -and the operations. The open question is a restatement on a choice-free carrier: ZP-N's snap-from-below -on `ONote` (`ZeroParadox/Ordinal/ConstructiveOrdinals.lean`) is evidence for it, not a re-proof. -/ +Both results are corollaries of Mathlib's classically built `Ordinal` fixed-point theory (`nfp`, +`epsilon`). **Status: STATEMENT-CARRIED** (`ZeroParadox/Category/ChoiceCannotBe.md`): both statements, +with no proof attached, carry `Classical.choice` (the statement controls `epsilon0EqNfpBotStatement` and +`epsilon0MinMaxStatement`, printed below). The choice is NOT in the `Ordinal` type; it enters through the +order instance and the operations. The remaining question is a restatement on a carrier whose statements +are choice-free, with two readings: a defined one, in Lean on `E0Note`, and a derived one, on a well-founded +carrier, not located as of 2026-10-13; both, with the search record: `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". ZP-N's ascent on +`ONote` (`ZeroParadox/Ordinal/ConstructiveOrdinals.lean`) is evidence for it, not a re-proof. -/ section PurityCheck open ZeroParadox #print axioms epsilon0_eq_nfp_bot #print axioms epsilon0_min_eq_max +-- The statement controls: the statements alone. +#print axioms epsilon0EqNfpBotStatement +#print axioms epsilon0MinMaxStatement +#print axioms epsilon0_pinnedLimit +#print axioms epsilon0_not_pinnedLimitUnique +#print axioms pinnedLimit_opow_eq_epsilon0 end PurityCheck diff --git a/ZeroParadox/Ordinal/Epsilon0MinMax.md b/ZeroParadox/Ordinal/Epsilon0MinMax.md index 2b021240..f369d1b6 100644 --- a/ZeroParadox/Ordinal/Epsilon0MinMax.md +++ b/ZeroParadox/Ordinal/Epsilon0MinMax.md @@ -48,6 +48,3 @@ point is the error CLAUDE.md's determinism section names. Already-proved neighbo new mathematics: `ZeroParadox/Ordinal/SnapNucleus.lean`'s `snapNucleus_bot_ne_bot` (*"it does not fix the floor"* — in a file that imports the Lean file) and the choice-free `ZeroParadox/Ordinal/ConstructiveOrdinals.lean`'s `omegaPow_no_fixedpoint`. - -Long form: `.claude-local/notes/future-research/tower_seed_is_not_load_bearing_2026-07-31.md`, -`.claude-local/notes/future-research/forced_movement_two_operators_2026-07-31.md`. diff --git a/ZeroParadox/Ordinal/Gentzen.lean b/ZeroParadox/Ordinal/Gentzen.lean index 736fa1ec..5d4eea29 100644 --- a/ZeroParadox/Ordinal/Gentzen.lean +++ b/ZeroParadox/Ordinal/Gentzen.lean @@ -52,21 +52,23 @@ end AxiomFootprintEvidence Any computable transformation of a Code has a behavioral fixed point — a code c such that eval (f c) = eval c. This is **Rogers' fixed-point theorem**: the fixed-point structure is -stable under any computable transformation. *(Corrected 2026-08-02: this read "Rogers' fixed-point -theorem (Kleene's second recursion theorem)", equating the two. Mathlib splits them — `fixed_point` is -Roger's fixed point theorem, `fixed_point₂` is Kleene's second recursion theorem -(`Mathlib/Computability/PartrecCode.lean`, the module index and the docstrings on `fixed_point` and -`fixed_point₂`) — and the -declaration below wraps the `fixed_point` route. They are inter-derivable, so this was naming rather -than falsehood.)* +stable under any computable transformation. The names follow Mathlib, which calls `fixed_point` +Rogers' fixed-point theorem and `fixed_point₂` Kleene's second recursion theorem +(`Mathlib/Computability/PartrecCode.lean`); the declaration below wraps `fixed_point`. In Rogers 1967 +`fixed_point` is Theorem 11-I (p. 180), a special case of his Theorem 11-IV, which he notes is +sometimes called the second recursion theorem (p. 196); "The recursion theorem is due to Kleene" +(p. 180). The two-place form, Mathlib's `fixed_point₂`, is his Exercise 11-4(i), "Kleene's version +of Theorem I" (p. 214), where he also asks for the proof that the two are equivalent. Note on scope: the ZPL architecture initially proposed that eval (f botCode) = eval botCode for ALL computable f. This overclaims — botCode is one specific Classical.choose witness and carries no special stability under arbitrary f. The existential version is the correct formalization. -/ -/-- Rogers' fixed-point theorem (Mathlib `Nat.Partrec.Code.fixed_point`; **not** Kleene's second - recursion theorem, which Mathlib names `fixed_point₂`): for any computable transformation f, +/-- Rogers' fixed-point theorem (Mathlib `Nat.Partrec.Code.fixed_point`; Mathlib gives the name + Kleene's second recursion theorem to `fixed_point₂`, while Rogers places this one-place form + under the theorem sometimes called the second recursion theorem, see § II above): for any + computable transformation f, some code is behaviorally fixed by f. Proved as a wrapper around ZPK's roger_fixed_point_exists. -/ theorem roger_fixed_point_stability (f : Code → Code) (hf : Computable f) : @@ -210,7 +212,8 @@ theorem towerNONote_repr (n : ℕ) : NONote.repr (towerNONote n) = fundamentalSe -- fundamentalSeq (n+1) = ω^(fundamentalSeq n) by Function.iterate_succ' unfolding. have hfund : fundamentalSeq (n + 1) = Ordinal.omega0 ^ fundamentalSeq n := by simp only [fundamentalSeq, Function.iterate_succ', Function.comp] - rw [hunfold, repr_oadd, ih, hzero, hcast, mul_one, add_zero, ← hfund] + rw [hunfold, repr_oadd (towerNONote n) 1 0 ONote.NFBelow.zero, ih, hzero, hcast, mul_one, + add_zero, ← hfund] /-- The valuation of cnfToZp2 at the n-th tower stage equals n. -/ theorem cnfToZp2_tower_valuation (n : ℕ) : (cnfToZp2 (towerNONote n)).valuation = n := by @@ -221,13 +224,12 @@ theorem cnfToZp2_tower_valuation (n : ℕ) : (cnfToZp2 (towerNONote n)).valuatio -- Similarly, norm_cast handles ↑(1 : ℕ+) : ℤ_[2] = 1. have hcast : ((1 : ℕ+) : ℤ_[2]) = 1 := by norm_cast have hstep : cnfToZp2 (towerNONote (n + 1)) = (2 : ℤ_[2]) ^ (n + 1) := by - rw [hunfold, cnfToZp2_oadd, ih, cnfToZp2_zero, hcast, mul_one, add_zero] + rw [hunfold, cnfToZp2_oadd (towerNONote n) 1 0 ONote.NFBelow.zero, ih, cnfToZp2_zero, hcast, + mul_one, add_zero] rw [hstep, PadicInt.valuation_pow] - -- (2 : ℤ_[2]) is a numeral; valuation_p expects the cast form (↑p : ℤ_[p]). - -- Nat.cast_ofNat converts the numeral to cast form so valuation_p fires. - have hval : (2 : ℤ_[2]).valuation = 1 := by - rw [show (2 : ℤ_[2]) = ((2 : ℕ) : ℤ_[2]) from Nat.cast_ofNat.symm] - exact PadicInt.valuation_p + -- At the pinned Mathlib `valuation_p` closes the numeral goal directly (the `example` before + -- `q2Val_scale`, `ZeroParadox/Valuation/Scale.lean`). + have hval : (2 : ℤ_[2]).valuation = 1 := PadicInt.valuation_p simp [hval] /-- The 2-adic valuation of cnfToZp2 is unbounded: for every k there is an ordinal @@ -256,7 +258,8 @@ private theorem cnfToZp2_tower_explicit (n : ℕ) : cnfToZp2 (towerNONote (n + 1)) = (2 : ℤ_[2]) ^ (n + 1) := by have hunfold : towerNONote (n + 1) = NONote.oadd (towerNONote n) 1 0 ONote.NFBelow.zero := rfl have hcast : ((1 : ℕ+) : ℤ_[2]) = 1 := by norm_cast - rw [hunfold, cnfToZp2_oadd, cnfToZp2_tower_valuation, cnfToZp2_zero, hcast, mul_one, add_zero] + rw [hunfold, cnfToZp2_oadd (towerNONote n) 1 0 ONote.NFBelow.zero, cnfToZp2_tower_valuation, + cnfToZp2_zero, hcast, mul_one, add_zero] /-- The tower images converge to 0 = ⊥ in ℤ_[2]. Each stage's image cnfToZp2(towerNONote (n+1)) = 2^(n+1) in ℤ_[2], so its 2-adic norm is @@ -538,6 +541,7 @@ open ZeroParadox -- § III: fully proved #print axioms epsilonZero_fixedPoint +#print axioms epsilonZero_eq_nfp #print axioms epsilonZero_eq_iSup #print axioms epsilonZero_tower_lt #print axioms epsilonZero_le_fixedPoint diff --git a/ZeroParadox/Ordinal/Gentzen.md b/ZeroParadox/Ordinal/Gentzen.md index 6e0ef963..c5ca2031 100644 --- a/ZeroParadox/Ordinal/Gentzen.md +++ b/ZeroParadox/Ordinal/Gentzen.md @@ -61,12 +61,15 @@ proof shows dependence, not a principle's necessity. | Layer | Formal Language | Expression of non-constructibility | |-------|----------------|--------------------------------------| | ZPB | Topology | C3: no continuous path ⊥ → x ≠ ⊥ | -| ZPC | Information | L-INF: infinite surprisal at ⊥ | +| ZPC | Information | L-INF (`l_inf`): the surprisal I(n) = n is unbounded in the depth n ∈ ℕ. `Reading:` ZP-C reads depth n → ∞ as approach to the limit point 0 of ℚ₂ (ZP-I § II.B) | | ZPJ/K | Set + Compute | bot_self_mem (AFA); botCode (Kleene) | -| ZPI | Algorithmic IT | K uncomputable; the K-ratio bridge is refuted (counterexample Sₙ = 2ⁿ, ZP-I § II.B); T-IZ never depended on it (it goes through `t_iz_cauchy`) | +| ZPI | Algorithmic IT | K uncomputable; the K-ratio (valuation-complexity) bridge, where K is Kolmogorov complexity, is refuted (status, counterexample and Lean valuation half: the R-BRIDGE row of `CLAIMS.md`); T-IZ never depended on it (it goes through `t_iz_cauchy`) | -K is not computed in Lean in this framework. The AFA/Kleene route reaches the same -fixed-point structure via a path whose Kleene step is a KleeneStructure requirement. +K is not computed in Lean in this framework. The AFA/Kleene row is a conjunction, not an identity: +`da1_paths_unified` (`ZeroParadox/Computability/Kleene.lean`) states that ⊥ of a `ZPSemilattice` is +a Quine atom and that `KleeneStructure`'s `botCode` is a computational quine, the second conjunct +being the `KleeneStructure` requirement (a periodicity condition that constant codes also meet, +`ZeroParadox/Computability/Kleene.lean` § VI). ## § IV. Cantor Normal Form Bridge diff --git a/ZeroParadox/Ordinal/Incompleteness.lean b/ZeroParadox/Ordinal/Incompleteness.lean index 36f2aad0..45820d52 100644 --- a/ZeroParadox/Ordinal/Incompleteness.lean +++ b/ZeroParadox/Ordinal/Incompleteness.lean @@ -11,9 +11,9 @@ **Gap 2 (ZP-K / ZP-L):** ZP-K establishes that the Quine atom is ⊥ = c₀ (bottom of MachinePhase) — an order-theoretic fact about MachinePhase, with no `Code` and no - execution in the statement. Reading c₀ as *the Kleene quine* is ZP-K's - `KleeneStructure` commitment, not a theorem, and no equation between a `Code` and a - `MachinePhase` is well-formed. Where ZP-L places the transition, and under which hypotheses: + execution in the statement. Reading c₀ as *the Kleene quine* splits (ZP-K § II): no equation + between a `Code` and a `MachinePhase` is well-formed, so its identity half is retired, and that + ⊥ of `MachinePhase` runs is the occurrence commitment. Where ZP-L places the transition, and under which hypotheses: `snap_unconditional` and the `example`s after it, § II. The formal path from c₀ = ⊥ through the snap at ε₀ to c₁ (ZP-L), mediated through `ℤ_[2]` by `cnfToZp2` from the ordinal side and `snapEmbed` from `MachinePhase`, is the missing structural triangle: ⊥ → ε₀ → c₁. @@ -78,7 +78,7 @@ theorem snapEmbed_injective : Function.Injective snapEmbed := by Under multiplication, 0 is absorbing — matching c₁ absorbing in MachinePhase. -/ theorem snapEmbed_mul_morphism (a b : MachinePhase) : snapEmbed (join a b) = snapEmbed a * snapEmbed b := by - cases a <;> cases b <;> simp [snapEmbed] + cases a <;> cases b <;> simp [snapEmbed] <;> rfl /-- The 2-adic valuation of snapEmbed c₀ is 0 (it is a unit). -/ theorem snapEmbed_c0_val : (snapEmbed c₀).valuation = 0 := by @@ -88,6 +88,94 @@ theorem snapEmbed_c0_val : (snapEmbed c₀).valuation = 0 := by theorem snapEmbed_c1_dvd (n : ℕ) : (2 : ℤ_[2])^n ∣ snapEmbed c₁ := by simp [snapEmbed_c1] +/-! ### § I-b. snapEmbed in the die + +The die's Quine-atom role is `Motion.SelfOnlyAt` (`ZeroParadox/Die.lean`): a point that steps to +itself and to nothing else. Two pairings are stated below, each through the map `snapEmbed`; no +equation across `MachinePhase` and `ℤ_[2]` is stated. Long form: `ZeroParadox/Ordinal/Incompleteness.md` § I. -/ + +/-- `Statement:` the join motion on `MachinePhase`: UP the identity, OVER `a → join a z` for some `z`. -/ +def machineJoinMotion : Motion MachinePhase := + Motion.ofTotal id (fun _ => rfl) (fun a b => ∃ z, b = join a z) + +/-- `Statement:` the multiplication motion on `ℤ_[2]`: UP the identity, OVER `x → x * w` for some `w`. -/ +def z2MulMotion : Motion ℤ_[2] := + Motion.ofTotal id (fun _ => rfl) (fun x y => ∃ w, y = x * w) + +/-- `Statement:` `snapEmbed` is a strict map of motions from `machineJoinMotion` to `z2MulMotion`: + steps go to steps (`snapEmbed_mul_morphism`) and the UP squares commute. -/ +noncomputable def snapEmbedHom : Motion.Hom machineJoinMotion z2MulMotion where + toFun := snapEmbed + map_step := by + rintro a b ⟨z, rfl⟩ + exact ⟨snapEmbed z, snapEmbed_mul_morphism a z⟩ + map_up := fun x => by simp [machineJoinMotion, z2MulMotion, Motion.ofTotal] + +/-- `Statement:` in `machineJoinMotion`, `y` steps to itself and to nothing else iff `y = c₁`; both + directions. -/ +theorem machineJoinMotion_selfOnlyAt_iff (y : MachinePhase) : + machineJoinMotion.SelfOnlyAt y ↔ y = c₁ := by + constructor + · rintro ⟨_, h⟩ + cases y + · exact absurd (h c₁ ⟨c₁, rfl⟩) (by decide) + · rfl + · rintro rfl; exact ⟨⟨c₁, rfl⟩, by rintro b ⟨z, rfl⟩; cases z <;> rfl⟩ + +/-- `Statement:` in `z2MulMotion`, `y` steps to itself and to nothing else iff `y = 0`; both + directions. -/ +theorem z2MulMotion_selfOnlyAt_iff (y : ℤ_[2]) : z2MulMotion.SelfOnlyAt y ↔ y = 0 := by + constructor + · rintro ⟨_, h⟩ + simpa using (h (y * 0) ⟨0, rfl⟩).symm + · rintro rfl; exact ⟨⟨0, (mul_zero 0).symm⟩, by rintro b ⟨w, rfl⟩; exact zero_mul w⟩ + +-- `Statement:` `snapEmbedHom` has no back clause at `c₀`: `snapEmbed c₀ = 1` steps to `2` in +-- `z2MulMotion`, and no state maps to `2`. So `Motion.LaxHom.selfOnlyAt` does not apply as a whole; +-- at `c₁` the role does carry over (`snapEmbed_selfOnlyAt_c1`). +example : ¬ Motion.StepBack machineJoinMotion z2MulMotion snapEmbed := by + intro h + obtain ⟨b, _, hb⟩ := h c₀ 2 ⟨2, by rw [snapEmbed_c0, one_mul]⟩ + cases b + · exact absurd (hb.symm.trans snapEmbed_c0) (by norm_num) + · exact two_ne_zero (hb.symm.trans snapEmbed_c1) + +/-- `Statement:` the role carries over at `c₁`: `c₁` steps to itself only in `machineJoinMotion`, + and its image `0` has at most one successor in `z2MulMotion`, so the image steps to itself only + (`Motion.selfOnlyAt_relHom`, applied along `snapEmbedHom`'s steps). -/ +theorem snapEmbed_selfOnlyAt_c1 : z2MulMotion.SelfOnlyAt (snapEmbedHom.toFun c₁) := + Motion.selfOnlyAt_relHom (M := machineJoinMotion) (N := z2MulMotion) + ⟨snapEmbedHom.toFun, snapEmbedHom.map_step⟩ + ((machineJoinMotion_selfOnlyAt_iff c₁).2 rfl) + (by rintro b c ⟨w, rfl⟩ ⟨w', rfl⟩; simp [snapEmbedHom, snapEmbed_c1]) + +/-- `Statement:` doubling on `ℤ_[2]`: `y` steps to itself and to nothing else iff `y = 0`; both + directions. -/ +theorem z2_double_selfOnlyAt_iff (y : ℤ_[2]) : + (Motion.ofFun (fun x : ℤ_[2] => 2 * x)).SelfOnlyAt y ↔ y = 0 := + (Motion.selfOnlyAt_ofFun_iff _ y).trans + ⟨fun h => by linear_combination h, fun h => by rw [h, mul_zero]⟩ + +/-- `Statement:` the doubling pairing: if `snapEmbed` carries every step of a motion `M` on + `MachinePhase` to a step of doubling on `ℤ_[2]`, then `c₀` has no step in `M`. Under doubling + the role's only occupant is `0` (`z2_double_selfOnlyAt_iff`). -/ +theorem snapEmbed_doubling_noStepAt (M : Motion MachinePhase) + (h : ∀ a b, M.step a b → + (Motion.ofFun (fun x : ℤ_[2] => 2 * x)).step (snapEmbed a) (snapEmbed b)) : + M.NoStepAt c₀ := by + intro b hb + have hs : snapEmbed b = 2 * snapEmbed c₀ := h _ _ hb + rw [snapEmbed_c0, mul_one] at hs + cases b + · exact absurd (hs.symm.trans snapEmbed_c0) (by norm_num) + · exact two_ne_zero (hs.symm.trans snapEmbed_c1) + +-- `Statement:` so the snap step `c₀ → c₁` maps to `1 → 0`, which is not a doubling step. +example : ¬ (Motion.ofFun (fun x : ℤ_[2] => 2 * x)).step (snapEmbed c₀) (snapEmbed c₁) := by + change ¬ (snapEmbed c₁ = 2 * snapEmbed c₀) + rw [snapEmbed_c0, snapEmbed_c1, mul_one] + exact (two_ne_zero (α := ℤ_[2])).symm + /-! ## §II. Deriving hfp from ε₀ Initialization `hfp` is the free hypothesis of `snap_exactly_at_epsilon_zero`. @@ -206,21 +294,21 @@ example (φ : Ordinal → MachinePhase) (h0 : ∀ n : ℕ, φ (fundamentalSeq n) ZP-K established: ⊥ = c₀ is the unique Quine atom of MachinePhase (`da1_closed_concrete`). Note what that theorem does *not* say — it mentions no `Code` -and no execution. Reading c₀ as *the Kleene quine* is ZP-K's `KleeneStructure` -commitment, not a theorem, and it is not a Lean `=`: a quine is a `Code` and c₀ is a -`MachinePhase`, so no equation between them is well-formed. See ZP-K § II / § III. -ZP-L established: **given** that the snap happens at ε₀, it happens **nowhere below** it. The -same caution as the ZP-K sentence above applies here: `snap_unconditional` is named for its lack -of a fixed-point hypothesis, not for lacking hypotheses — it takes `hε₀ : φ epsilonZero = c₁` as -an argument, so the snap is assumed and its *minimality* is what is derived. ZP-L does not force -the snap. (Corrected 2026-07-31; this line read "ε₀ forces the snap from c₀ to c₁".) - -The triangle (the top node read under that commitment): - c₀ = ⊥ (the Quine atom; read as the Kleene quine, ZP-K) +and no execution. Reading c₀ as *the Kleene quine* splits as in the header: no `=` between a +`Code` and a `MachinePhase` is well-formed, so its identity half is retired (the code chart has its +own occupants of the die's Quine-atom role); its running half is the occurrence commitment. +ZP-L established, under `hmono`, `h0` (every tower stage sent to c₀) and `hε₀` (φ ε₀ = c₁), that φ +sends nothing below ε₀ to c₁ (`snap_unconditional`, § II). The ZP-K caution applies here too: +`snap_unconditional` is named for its lack of a fixed-point hypothesis, not for lacking hypotheses; +it takes `hε₀` as an argument, so the snap is assumed and its *minimality* is derived. ZP-L does +not force the snap. + +The triangle: + c₀ = ⊥ of `MachinePhase` (its Quine atom, ZP-K) ↕ snap at ε₀ c₁ (snap state, ZP-L) ↕ snapEmbed - 0 ∈ ℤ_[2] (2-adic limit of tower, ZP-L) + 0 ∈ ℤ_[2] (limit of the tower's `cnfToZp2` images, ZP-L; the tower's supremum is ε₀) This section makes the full triangle formal. -/ @@ -249,18 +337,17 @@ theorem zpm_triangle : tower_converges_to_zero, snap_state_zp2_is_zero⟩ -/-! ## §IV. Shared Diagonalization Pattern +/-! ## §IV. Two Fixed-Point Existentials -Both the Kleene recursion theorem (ZP-K) and ε₀'s fixed-point property (ZP-L) follow -the same diagonalization pattern: a self-referential operation has a fixed point. - - Kleene: ∃ c, ∀ n, eval c n = eval c (encode c + n) [diagonal on codes] - ε₀: ∃ α, ω^α = α ∧ (∀ β, ω^β = β → α ≤ β) [diagonal on ordinals] - -This section records that both fixed points exist in the same formal context. -/ +`both_fixed_points_exist` conjoins one existential over codes and one over ordinals. The code +conjunct is a periodicity with period the code's Gödel number, met by any code that ignores its +input (`Code.zero`, the `example` in `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § IV), so it is +not diagonal content by itself; the ordinal conjunct is ε₀'s least-fixed-point face. Long form: +`ZeroParadox/Ordinal/Incompleteness.md` § Remark R-M.1. -/ -/-- Both diagonalization patterns produce fixed points in their respective domains. - Kleene: periodic code (period = Gödel number). Ordinal: ε₀ = ω^ε₀, least such. -/ +/-- A conjunction of two fixed-point existentials, one over codes and one over ordinals. + Codes: some code is periodic with period its own Gödel number, a condition constant codes also + meet (§ IV). Ordinals: ε₀ = ω^ε₀, least such. -/ theorem both_fixed_points_exist : (∃ c : Code, ∀ n, eval c n = eval c (Encodable.encode c + n)) ∧ (∃ α : Ordinal, omega0 ^ α = α ∧ @@ -272,8 +359,7 @@ theorem both_fixed_points_exist : /-! ### Remark R-M.1: DA-1 Path 2 and the Limits of the Diagonalization Frame -`both_fixed_points_exist` is a conjunction of two existentials: each diagonalization yields a -fixed point in its own domain, and no equation between a `Code` and an `Ordinal` is well-formed. +`both_fixed_points_exist` is a conjunction of two existentials, one per domain (§ IV), and no equation between a `Code` and an `Ordinal` is well-formed. Where L-INF stands relative to that schema, and how that differs from DA-1 Path 2: `ZeroParadox/Ordinal/Incompleteness.md` § Remark R-M.1. -/ @@ -283,8 +369,20 @@ end ZeroParadox section PurityCheck open ZeroParadox +#print axioms snapEmbed_c0 +#print axioms snapEmbed_c1 +#print axioms snapEmbed_c0_val +#print axioms snapEmbed_c1_dvd #print axioms snapEmbed_injective #print axioms snapEmbed_mul_morphism +#print axioms machineJoinMotion +#print axioms z2MulMotion +#print axioms snapEmbedHom +#print axioms machineJoinMotion_selfOnlyAt_iff +#print axioms z2MulMotion_selfOnlyAt_iff +#print axioms snapEmbed_doubling_noStepAt +#print axioms snapEmbed_selfOnlyAt_c1 +#print axioms z2_double_selfOnlyAt_iff #print axioms hfp_from_epsilon_zero #print axioms snap_unconditional #print axioms snap_state_zp2_is_zero diff --git a/ZeroParadox/Ordinal/Incompleteness.md b/ZeroParadox/Ordinal/Incompleteness.md index a6410d96..318c0eec 100644 --- a/ZeroParadox/Ordinal/Incompleteness.md +++ b/ZeroParadox/Ordinal/Incompleteness.md @@ -4,32 +4,68 @@ Moved from `ZeroParadox/Ordinal/Incompleteness.lean`. ⚠ **This content was GRA ## § I. The snapEmbed Morphism -snapEmbed sends the snap state c₁ to 0 in ℤ_[2] (the 2-adic limit of the tower -encodings) and the pre-snap state c₀ to 1 (a nonzero 2-adic integer). +snapEmbed sends the snap state c₁ to 0 in ℤ_[2] (the limit of the tower stages' `cnfToZp2` +images, `tower_converges_to_zero`) and the pre-snap state c₀ to 1 (a nonzero 2-adic integer). The +tower itself, in `Ordinal`, has supremum ε₀ (`epsilonZero_eq_iSup`), a different carrier. -This formalizes the embedding: c₁ maps to 0 ∈ ℤ_[2], the 2-adic limit of the tower -encodings. Within the ZP framework, 0 here plays the role of ⊥; in the Scale.lean chart (⊥ = 0) -0 fills ℤ_[2]'s bottom role (a ZPSemilattice on ℤ_[2] with ⊥ = 0 is built in -`ZeroParadox/Valuation/Scale.lean` § V), and in the multiplicative reading `snapEmbed c₀ = 1` is -the identity, and that reading is not a ZPSemilattice, since multiplication on ℤ_[2] is not idempotent (2 · 2 ≠ 2) — the identification is a modelling commitment, not a -ring-theoretic fact. +No equation between a `MachinePhase` state and a point of ℤ_[2] is stated. What the two carriers +share is a role, the die's Quine-atom role `Motion.SelfOnlyAt` (`ZeroParadox/Die.lean`, a point +that steps to itself and to nothing else), whose occupant in each carrier depends on the step +chosen there. On `MachinePhase` under join it is c₁ (c₀ steps to c₀ and to c₁), while under a +self-application map supplied by `AbstractSelfApp` it is c₀, ⊥ of `MachinePhase`, by that class's +fields (`selfApp_quine_role_iff`). § I-b of +the `.lean` file states two pairings, each through `snapEmbed`: -The morphism property: join on MachinePhase (c₁ is absorbing) corresponds to -multiplication on ℤ_[2] (0 is absorbing). Both structures have the same absorbing -element pattern: c₁ absorbs all joins, 0 absorbs all products. +- **The absorbing pairing.** Under the join motion on `MachinePhase` (`a → join a z`) only c₁ + steps to itself only (`machineJoinMotion_selfOnlyAt_iff`); under the multiplication motion on + ℤ_[2] (`x → x · w`) only 0 does (`z2MulMotion_selfOnlyAt_iff`). `snapEmbed` is a map of these + motions (`snapEmbedHom`, from `snapEmbed_mul_morphism`) and sends c₁ to 0 (`snapEmbed_c1`). It + has no back clause at c₀ (the `example` after `z2MulMotion_selfOnlyAt_iff`), so the general + transport `Motion.LaxHom.selfOnlyAt` does not apply; at c₁ the role does carry over, since 0 has + only itself as successor (`snapEmbed_selfOnlyAt_c1`, from `Motion.selfOnlyAt_relHom`). +- **The doubling pairing.** Under doubling on ℤ_[2], only 0 steps to itself only + (`z2_double_selfOnlyAt_iff`), and 0 is divisible by every power of 2 + (`snapEmbed_c1_dvd`). `snapEmbed` carries no motion on `MachinePhase` with a step at c₀ into + doubling steps (`snapEmbed_doubling_noStepAt`): the snap step c₀ → c₁ goes to 1 → 0, which is + not a doubling step. + +A third chart is a chosen one: a `ZPSemilattice` on ℤ_[2] with ⊥ = 0 is built in +`ZeroParadox/Valuation/Scale.lean` § V from a join picked through a well-ordering, and there 0 +occupies the join-identity role by that choice. ## Remark R-M.1: DA-1 Path 2 and the Limits of the Diagonalization Frame -`both_fixed_points_exist` shows that Kleene diagonalization (a code acting on its own -Gödel number) and ordinal diagonalization (ε₀ = ω^ε₀, least fixed point) each produce a -fixed point in their own domain. The statement is a conjunction of two existentials, so -it establishes that both exist, not that they are one structural pattern; reading them as -the same pattern is the framework's interpretation, and no equation between a `Code` and -an `Ordinal` is well-formed. +`both_fixed_points_exist` conjoins two existentials, one per domain: a code periodic with +period its own Gödel number, and ε₀ = ω^ε₀ as the least fixed point. The first conjunct is not +diagonal content on its own, since any code whose evaluation ignores its input meets it +(`Code.zero`, the `example` in `ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § IV; the constant +codes in `infinite_quine_family`, `ZeroParadox/Computability/Kleene.lean`); the proof supplies it +from the recursion-theorem witness `computational_quine_exists`, which the statement does not +record. The ordinal conjunct is ε₀'s least-fixed-point face; its supremum face is +`epsilonZero_eq_iSup`. The statement establishes that both exist, not +that they are one structural pattern; reading them as the same pattern is the framework's +interpretation, and no equation between a `Code` and an `Ordinal` is well-formed. -L-INF (ZP-C Lemma L-INF: the surprisal of ⊥ is unbounded above) is structurally -analogous. The Kleene and -ordinal cases are both textbook instances of the diagonalization schema; whether +`Statement:` **CARRIER** — two theorems, one per chart, both in Lean. In the depth chart, ZP-C Lemma L-INF (`l_inf`, +`ZeroParadox/Information/Surprisal.lean`) says the surprisal I(n) = n exceeds every bound at some +depth n, while every value I(n) is finite. In the point chart, the coincidence witness +`infinitude_forces_infinite_complexity` (`ZeroParadox/Valuation/InfinitudeFloor.lean`) says the floor +of any `InfinitudeFloor` has complexity ⊤ in ℕ∞, the supremum of its members' complexities, each +of which is finite (`member_cx_lt_top`). On ℤ_[2] a witness is `towerInfinitudeFloor` (a def, not a +global instance), floor 0, complexity `towerCx` (⊤ at 0, the 2-adic valuation elsewhere), applied in +`tower_height_floor_reconciliation` (`ZeroParadox/Valuation/TowerHeightFloor.lean`); on ℚ_[2] the +global instance is `q2InfinitudeFloor`, floor 0. `Statement:` **CARRIER** — the point-chart measure +`cxQ2` (`ZeroParadox/Valuation/InfinitudeFloor.lean`) is ⊤ at 0 and elsewhere the 2-adic valuation +truncated at 0; on the members it is the valuation (`cxQ2_two_pow`), and Mathlib's `Padic.valuation` +returns 0 at 0 (`Padic.valuation_zero`). It is not `surprisal`, and the two agree along the members: `info_valuation_eq_surprisal` +(`ZeroParadox/Multihomed/TopNumEdge.lean`) says the 2-adic valuation of 2ⁿ ∈ ℚ_[2] equals I(n), and +the members of `q2InfinitudeFloor` are the points 2ⁿ⁺¹. That equation is indexed by depth n and stops +at the floor 0, which sits at no finite depth: there the complexity `cxQ2` is ⊤ and `surprisal`, a +function of the depth, has no argument. `Reading:` ⊥ of +`MachinePhase`, c₀, corresponds to that point 0 under the `l_inf` docstring's reading, which names +0 ∈ ℚ_[2]; that is a different pairing from `snapEmbed` in § I, which sends c₀ to 1 and c₁ to 0. L-INF is structurally analogous to the two +fixed points above. The Kleene recursion theorem and ε₀'s fixed point are both textbook +instances of the diagonalization schema; whether L-INF fits the same schema formally is the open question this remark is tracking. The formally unconnected instance is L-INF. L-INF is a measure-theoretic statement diff --git a/ZeroParadox/Ordinal/KirbyParis.lean b/ZeroParadox/Ordinal/KirbyParis.lean index e20be05e..1ad3b35f 100644 --- a/ZeroParadox/Ordinal/KirbyParis.lean +++ b/ZeroParadox/Ordinal/KirbyParis.lean @@ -20,7 +20,7 @@ This file proves it. The order-independent valuation needs the natural sum `♯` from Mathlib (it lived in Combinatorial Game Theory, moved to an external repo), so it is recovered here from a vendored Mathlib-v4.28 snapshot (`Vendored.NaturalOps`) plus the ω-power closure `nadd_lt_omega0_opow` (`Ordinal.NaturalOpsPow`, the CNF characterization that the snapshot left as a -TODO). See `.claude-local/notes/kirby_paris_nadd_absent_2026-06-29.md`. +TODO); the vendoring rationale is in the header of `ZeroParadox/Vendored/NaturalOps.lean`. What is proved: * `Step` — the Kirby–Paris cut relation (a superset of the genuine battle moves; its well-foundedness diff --git a/ZeroParadox/Ordinal/Kruskal.md b/ZeroParadox/Ordinal/Kruskal.md index 63335852..baf4c6b2 100644 --- a/ZeroParadox/Ordinal/Kruskal.md +++ b/ZeroParadox/Ordinal/Kruskal.md @@ -5,7 +5,8 @@ declarations, the Engineer's Take and the per-declaration glosses, and its `Puri EMITS the axiom footprints this document reasons about, so no footprint below is asserted here. ⚠ **What a footprint reports is what a route CONSUMES, never what it REACHES** — so the separate question of which routes pass through the minimal bad sequence construction is NOT settled by the -block, and is settled below by Mathlib's import graph instead. +block, and is settled below instead, by Mathlib's import graph and, for the third route, by +declaration order within a module. ## The proof @@ -21,7 +22,11 @@ re-proves): - `Set.PartiallyWellOrderedOn.IsBadSeq` / `exists_min_bad_of_exists_bad` — the Nash-Williams minimal bad sequence construction. - `Set.PartiallyWellOrderedOn.partiallyWellOrderedOn_sublistForall₂` — **Higman's lemma** (lists under - `List.SublistForall₂` are WQO when the alphabet is). + `List.SublistForall₂` are WQO when the alphabet is). Mathlib proves it through the minimal bad + sequence construction too: its proof rewrites with `iff_not_exists_isMinBadSeq`, whose forward + direction is proved by applying `exists_min_bad_of_exists_bad` (both in + `Mathlib/Order/WellFoundedSet.lean`). So this file reaches that construction twice, in its own + minimal bad sequence of trees and inside Higman's lemma. Kruskal's tree theorem is **not formalized in the pinned Mathlib, and Mathlib records that itself**: its machine-readable theorem index lists `Q3527100`, *"Kruskal's tree theorem"*, **with @@ -53,8 +58,9 @@ formalizes the labeled tree theorem on Mathlib's WQO machinery. Two threads must construction. Measured: `exists_min_bad_of_exists_bad`, `exists_monotone_subseq` and `Nat.sInf_le` all report the IDENTICAL `[propext, Classical.choice, Quot.sound]`, and `Classical.choose` differs only by being smaller. What separates them is **where each route is DECLARED**, which is read - rather than emitted. Lean gives two independent bounds and **the three routes need both** — a - declaration can reach only its own module's earlier lines, plus that module's import closure. + rather than emitted. Lean gives two independent bounds; each of the three routes is settled by + one of them, and **between them the three routes need both**: a declaration can reach only its own module's + earlier lines, plus that module's import closure. ⚠ **Two of the three are settled by the IMPORT CLOSURE.** `Nat.sInf_le` is declared in `Mathlib.Data.Nat.Lattice` and `Classical.choose` in core's `Init.Classical`; measured over the @@ -70,10 +76,19 @@ formalizes the labeled tree theorem on Mathlib's WQO machinery. Two threads must and `exists_min_bad_of_exists_bad` (:795). Its own module therefore contains the machinery and the import closure excludes nothing for it. What excludes it is that Lean has **no forward references within a file**: `:366` is proved four hundred lines before either exists. (Its body delegates - into `Mathlib.Order.WellQuasiOrder`, which is upstream — but a delegate's closure bounds the - delegate, never the caller.) **On both legs together, three of the four routes cannot reach the - machinery**, and a choice-free minimal bad sequence would leave them standing. Sternagel's - Isabelle/HOL *Certified Kruskal's Tree Theorem* takes this route. + into `Mathlib.Order.WellQuasiOrder`, which is upstream — but a walk of the delegate's closure + alone does not bound the caller.) **On both legs together, three of the four routes cannot reach + the machinery**, and a choice-free minimal bad sequence would leave them standing. + Sternagel's Isabelle/HOL *Certified Kruskal's Tree Theorem* (J. Formalized Reasoning 7(1), 2014) + takes the same Nash-Williams route as this file, and its minimal bad sequence is not choice-free: + it picks minimal elements with Hilbert's choice operator (§ 5, p. 51). An earlier Lean 3 + formalization, for unlabeled finite trees, is Minchao Wu's `minchaowu/Kruskal.lean3` (GitHub; last commit 2017-06-20, + `a14516f`): its `theorem.lean` builds a minimal bad sequence of finite trees + (`mbs_of_finite_tree := minimal_bad_seq size H`), derives `Kruskal's_contradiction : false`, and + defines `wqo_finite_tree : wqo finite_tree`, under `open classical` and `noncomputable theory`. + It predates this file and takes the same Nash-Williams route, with its own Higman-type lemma in a + finite-subset form (`wqo_finite_subsets`, `higman.lean`), not Mathlib's list form; this file proves + the labeled form on Mathlib's Higman. - **The constructive route, and why its HYPOTHESIS side does not transfer to this statement.** Kruskal's theorem and Higman's lemma have choice-free proofs built on the inductively defined **almost-full** predicate `af`. Bar induction is not a rival CHARACTERISATION but an diff --git a/ZeroParadox/Ordinal/NaturalOpsPow.lean b/ZeroParadox/Ordinal/NaturalOpsPow.lean index f33f4677..51f79458 100644 --- a/ZeroParadox/Ordinal/NaturalOpsPow.lean +++ b/ZeroParadox/Ordinal/NaturalOpsPow.lean @@ -18,7 +18,7 @@ what bounds the hydra's regrowth (a finite natural sum of `ω^β` terms) below t Provenance: the proof structure (the `wpow_mul_natCast_add_of_lt_aux` induction, `termination_by (x,n,y)`) is Violeta Hernández's, from `vihdzp/combinatorial-games`. Port changes are marked `-- [ZP]`. -See `.claude-local/notes/kirby_paris_nadd_absent_2026-06-29.md`. +Why the natural-sum API is vendored at all: the header of `ZeroParadox/Vendored/NaturalOps.lean`. -/ namespace ZeroParadox.NaturalOpsPow diff --git a/ZeroParadox/Ordinal/OrdinalChoiceEssential.lean b/ZeroParadox/Ordinal/OrdinalChoiceEssential.lean index 56588170..7ce5ddbc 100644 --- a/ZeroParadox/Ordinal/OrdinalChoiceEssential.lean +++ b/ZeroParadox/Ordinal/OrdinalChoiceEssential.lean @@ -42,7 +42,7 @@ abbrev Pt : Type := PUnit instance : Std.Trichotomous (@emptyRelation Pt) := ⟨fun a b _ _ => Subsingleton.elim a b⟩ instance : IsTrans Pt emptyRelation := ⟨fun _ _ _ h => h.elim⟩ -instance : IsWellFounded Pt emptyRelation := ⟨⟨fun a => ⟨a, fun _ h => h.elim⟩⟩⟩ +instance : WellFounded (@emptyRelation Pt) := ⟨fun a => ⟨a, fun _ h => h.elim⟩⟩ instance : IsWellOrder Pt emptyRelation where /-- The Kraus-Nordvall Forsberg-Xu witness: a carrier with **two** elements when `p` holds and @@ -65,8 +65,8 @@ instance (p : Prop) : Std.Trichotomous (twoRel p) := by instance (p : Prop) : IsTrans (Two p) (twoRel p) := ⟨fun _ _ _ h1 h2 => absurd (h1.2.symm.trans h2.1) (by simp)⟩ -instance (p : Prop) : IsWellFounded (Two p) (twoRel p) := by - refine ⟨⟨fun a => ?_⟩⟩ +instance (p : Prop) : WellFounded (twoRel p) := by + refine ⟨fun a => ?_⟩ have base : ∀ c : Two p, c.2 = false → Acc (twoRel p) c := fun c hc => ⟨c, fun d hd => absurd (hd.2.symm.trans hc) (by simp)⟩ exact ⟨a, fun d hd => base d hd.1⟩ @@ -117,8 +117,9 @@ theorem em_of_wellOrder_comparable · exact Or.inl (p_of_pt_le p h) /-- **The hypothesis is not vacuous.** Mathlib's `InitialSeg.total` supplies it, so -`em_of_wellOrder_comparable` cannot be dismissed as an implication with an unsatisfiable -antecedent (`comparable_of_classical`). Classical by construction — that is the point: this is the source end of the arrow. +`em_of_wellOrder_comparable` is not an implication with an unsatisfiable antecedent: this +theorem inhabits that antecedent. Classical by construction — that is the point: this is the +source end of the arrow. `InitialSeg.total` (`Mathlib/Order/InitialSeg.lean`) is the **data** form, and spends a literal `Classical.choice` application in its final branch. -/ @@ -148,14 +149,14 @@ Traced to source, three independent classical entry points feed that instance: * `Ordinal.instLinearOrder`'s own `toDecidableLE := Classical.decRel _` — a data field, classical by fiat. -**Consequence for the framework's ledger.** The recorded `[propext, Classical.choice, Quot.sound]` -readings on `epsilon0_ne_zero`, `epsilon0_ne_bot`, `epsilon0_eq_nfp_bot` and their kin are -measuring the ambient instance, not those proofs. They are **not evidence** that the ε₀ -mathematics is non-constructive, in either direction. `epsilon0_ne_zero` is the clearest case: its -own argument is `ω^0 = 1 ≠ 0`, entirely constructive, and its whole footprint is inherited from -the ε₀ term. Re-proving these choice-free *inside* Mathlib's `Ordinal` is not merely hard, it is -structurally impossible; a choice-free analogue has to be built on a notation carrier, which is -ZP-N's programme. -/ +**Consequence for the framework's ledger.** The recorded `[propext, Classical.choice, Quot.sound]` readings +on `epsilon0_ne_zero`, `epsilon0_ne_bot`, `epsilon0_eq_nfp_bot` and their kin measure the choice-carrying +constants their statements reach (the order instance and operations such as `Ordinal.omega0`), not those +proofs: **not evidence** that the ε₀ mathematics is non-constructive, in either direction. +`epsilon0_ne_zero`'s own argument is `ω^0 = 1 ≠ 0`, entirely constructive; its footprint is inherited +from the ε₀ term. As written these statements are STATEMENT-CARRIED (`ZeroParadox/Category/ChoiceCannotBe.md`), +so no proof inside Mathlib's `Ordinal` drops the choice; a choice-free analogue is restated on a notation +carrier, ZP-N's programme (`ZeroParadox/Ordinal/ConstructiveOrdinals.md` § Result). -/ /-! **The measurement is uninformative for `Ordinal`'s order.** The next two theorems are the demonstration, and they are deliberately stated **separately** rather than as one conjunction: a @@ -193,25 +194,30 @@ example (H : ∀ (α β : Type) (r : α → α → Prop) (s : β → β → Prop · exact Or.inl (Ordinal.type_le_iff.mpr h) · exact Or.inr (Ordinal.type_le_iff.mpr h) --- `Statement:` the same totality respelled over the bare `le` relation of `Ordinal.partialOrder` --- (no instance term) is, by `rfl`, the proposition `∀ a b : Ordinal.{0}, a ≤ b ∨ b ≤ a`. --- Reading: "written through that instance term" above is about the TERM AS WRITTEN; --- this respelling's own statement measures `[propext, Quot.sound]` (statement control, 2026-10-08). -example : let ordLe : Ordinal.{0} → Ordinal.{0} → Prop := fun a b => - (Quotient.liftOn₂ a b (fun ⟨_, r, _⟩ ⟨_, s, _⟩ => Nonempty (r ≼i s)) - fun _ _ _ _ ⟨f⟩ ⟨g⟩ => propext - ⟨fun ⟨h⟩ => ⟨f.symm.toInitialSeg.trans <| h.trans g.toInitialSeg⟩, fun ⟨h⟩ => - ⟨f.toInitialSeg.trans <| h.trans g.symm.toInitialSeg⟩⟩) - (∀ a b, ordLe a b ∨ ordLe b a) = (∀ a b : Ordinal.{0}, a ≤ b ∨ b ≤ a) := rfl +/-- `Statement:` totality of `≤` on `Ordinal.{0}` as Mathlib spells it; the statement control. -/ +def ordTotalAsWritten : Prop := ∀ a b : Ordinal.{0}, a ≤ b ∨ b ≤ a --- `Statement:` and that respelled totality implies excluded middle, by `em_of_wellOrder_comparable`. -example : let ordLe : Ordinal.{0} → Ordinal.{0} → Prop := fun a b => +/-- `Statement:` totality of `≤` on `Ordinal.{0}`, respelled over the bare `le` relation of +`Ordinal.partialOrder` (the `Quotient.liftOn₂` of `Nonempty (r ≼i s)`), with no instance term. +Named so that its own footprint can be printed: the purity block below measures this statement, +where an anonymous `example` has no name for `#print axioms` to take. -/ +def ordTotalRespelled : Prop := + let ordLe : Ordinal.{0} → Ordinal.{0} → Prop := fun a b => (Quotient.liftOn₂ a b (fun ⟨_, r, _⟩ ⟨_, s, _⟩ => Nonempty (r ≼i s)) fun _ _ _ _ ⟨f⟩ ⟨g⟩ => propext ⟨fun ⟨h⟩ => ⟨f.symm.toInitialSeg.trans <| h.trans g.toInitialSeg⟩, fun ⟨h⟩ => ⟨f.toInitialSeg.trans <| h.trans g.symm.toInitialSeg⟩⟩) - (∀ a b, ordLe a b ∨ ordLe b a) → ExcludedMiddle := - fun h => em_of_wellOrder_comparable fun _ _ r s _ _ => h (Ordinal.type r) (Ordinal.type s) + ∀ a b, ordLe a b ∨ ordLe b a + +-- `Statement:` the respelling is, by `rfl`, the proposition `∀ a b : Ordinal.{0}, a ≤ b ∨ b ≤ a`. +-- Reading: "written through that instance term" above is about the TERM AS WRITTEN; the two +-- spellings are one proposition, and only the first mentions the instance. +example : ordTotalRespelled = ordTotalAsWritten := rfl + +/-- `Statement:` the respelled totality implies excluded middle, by `em_of_wellOrder_comparable`. +Its footprint, and that of `ordTotalRespelled`, are printed in the purity block below. -/ +theorem em_of_ordTotalRespelled (h : ordTotalRespelled) : ExcludedMiddle := + em_of_wellOrder_comparable fun _ _ r s _ _ => h (Ordinal.type r) (Ordinal.type s) end ZeroParadox @@ -238,6 +244,12 @@ open ZeroParadox #print axioms order_footprint_eq #print axioms order_footprint_le +-- § III, the statement control: the same proposition in its two spellings, statements alone, then +-- the respelling's implication to excluded middle. +#print axioms ordTotalAsWritten +#print axioms ordTotalRespelled +#print axioms em_of_ordTotalRespelled + -- The § III trace, measured rather than asserted. -- FIRST: the type itself, which carries NO choice. This one line is the load-bearing measurement -- behind the whole correction of record — ZP-N v1.0 asserted the opposite ("choice-saturated") and @@ -248,7 +260,7 @@ open ZeroParadox #print axioms InitialSeg.eq_or_principal #print axioms InitialSeg.total --- Two of the operations built on that instance. `nfp`, `deriv` and `epsilon` are named alongside +-- Two of the choice-carrying operations. `nfp`, `deriv` and `epsilon` are named alongside -- these in ZP-N's prose but live in `Mathlib.SetTheory.Ordinal.FixedPoint` / `Veblen`, outside this -- file's deliberately minimal import closure; they are printed in -- `ZeroParadox/Ordinal/PricedInterface.lean`, which already imports Veblen. Between the two purity diff --git a/ZeroParadox/Ordinal/OrdinalChoiceEssential.md b/ZeroParadox/Ordinal/OrdinalChoiceEssential.md index e880d368..1f68910f 100644 --- a/ZeroParadox/Ordinal/OrdinalChoiceEssential.md +++ b/ZeroParadox/Ordinal/OrdinalChoiceEssential.md @@ -25,11 +25,10 @@ the second carries choice in its statement. The principle, comparability of well choice-free is the classification below. Mathlib's `Ordinal` order is built with choice, and the statement as written carries it, so `le_total` on `Ordinal.{0}`, as Mathlib -spells it, is STATEMENT-CARRIED (its bare-relation respelling is not; see the classification below): a -theorem that takes -`∀ a b : Ordinal.{0}, a ≤ b ∨ b ≤ a` as a hypothesis and proves `True` by `trivial` reports -`[propext, Classical.choice, Quot.sound]` (measured 2026-10-08; the instance-term trace is the Lean -file's § III). +spells it, is STATEMENT-CARRIED (its bare-relation respelling is not; see the classification below): +the statement alone, `ordTotalAsWritten`, carries `Classical.choice`, and its respelling +`ordTotalRespelled` does not (both printed in the Lean file's purity block; the instance-term trace is +the Lean file's § III). ## PRIOR ART — the mathematics here is KNOWN and is NOT claimed as new @@ -105,12 +104,14 @@ So the classification splits, and the split is the point: Mathlib spells it, through the order instance, it is STATEMENT-CARRIED (the Lean file's § III); its respelling over the bare `le` relation is, by `rfl`, the same proposition, its own statement is choice-free, and it implies excluded middle choice-free, so that respelling is ESSENTIAL on the same - premise (the last two `example`s of the Lean file's § III); + premise (`ordTotalRespelled` and `em_of_ordTotalRespelled`, the Lean file's § III, footprints in its + purity block); * **the ε₀ results — STATEMENT-CARRIED** (`ε₀ ≠ 0` as a hypothesis already reports the choice, - measured 2026-10-08). They inherit choice from Mathlib's `Ordinal` machinery: - `Ordinal.instLinearOrder`, `nfp`, `omega0` and `epsilon` (each measured with `Classical.choice`, - `ZeroParadox/Category/ChoiceCannotBe.lean` § III) and limit recursion (`SuccOrder.limitRecOn`), - measured 2026-10-08. + measured 2026-10-08). + They inherit choice from Mathlib's `Ordinal` machinery: + `Ordinal.instLinearOrder`, `nfp`, `omega0` and `epsilon` (each with `Classical.choice`, `#print + axioms` in the PurityCheck sections of this file's `.lean` and of `ZeroParadox/Ordinal/PricedInterface.lean`) + and limit recursion (`SuccOrder.limitRecOn`, measured 2026-10-08). ZP-N's `ONote` results (`exp_lt_term`, `omegaPow_no_fixedpoint`, `tower_strictMono`, each `[propext]`) are evidence that the ascent content does not need it, not a re-proof: they are statements on a different carrier. diff --git a/ZeroParadox/Ordinal/P8.lean b/ZeroParadox/Ordinal/P8.lean index cb834484..1f04cabe 100644 --- a/ZeroParadox/Ordinal/P8.lean +++ b/ZeroParadox/Ordinal/P8.lean @@ -3,7 +3,7 @@ import Mathlib.NumberTheory.Padics.PadicIntegers import Mathlib.Analysis.SpecificLimits.Normed /-! -# P8 re-attempt: ε₀ → 0 in ℤ₂ via a tower-rank 2-adic encoding +# P8 re-attempt: the ω-tower's encodings → 0 in ℤ₂ via a tower-rank 2-adic encoding The parked "ZP-B route" (zpl_cantor_zp2_bridge): encode ordinals < ε₀ into ℤ₂ so the ω-tower's encodings converge to ℤ_[2]'s 0, without Gentzen. ε₀ gets no encoding: the domain is `{α // α < ε₀}`. diff --git a/ZeroParadox/Ordinal/PricedInterface.lean b/ZeroParadox/Ordinal/PricedInterface.lean index 1f9a7bb5..2ea5abf3 100644 --- a/ZeroParadox/Ordinal/PricedInterface.lean +++ b/ZeroParadox/Ordinal/PricedInterface.lean @@ -33,10 +33,11 @@ open Ordinal /-! ### The carrier -`SynONote` with one point adjoined on top: the shape of Castéran's `ON_plus` (sum of notation systems) +`SynONote` with one point adjoined on top: the shape of hydra-battles' `ON_plus` (sum of notation systems) with a one-point right summand, not an instance of it, because `SynONote`'s order is not well-founded -(the `example` stating `¬ WellFoundedLT E0Note`). The order, lattice and decidability structure below is all -Mathlib's `WithTop` machinery, not built here. -/ +(the `example` stating `¬ WellFoundedLT E0Note`). The carrier and its `≤`/`<` are Mathlib's `WithTop` +(`WithTop.instLE`/`instLT`); the decidability of comparison is proved below by cases on that order's +constructors, and `e0Coe_lt_top` and `e0_le_top` are applications of them. -/ /-- **The carrier: ordinal notations with a single adjoined top.** @@ -50,22 +51,39 @@ abbrev E0Note : Type := WithTop SynONote /-- The notations, viewed inside the carrier. -/ def e0Coe (x : ONote) : E0Note := (toSyn x : SynONote) -/-- Comparison on the carrier is decidable — inherited from Mathlib's `WithTop.decidableLE` applied to -the comparator-derived order on `SynONote`. This is Castéran's `lt_eq_lt_dec` (decidability survives -adjunction) at instance level; nothing is proved here. -/ -@[reducible] def e0DecidableLE : DecidableLE E0Note := inferInstance +section +-- [ZP port] Lean 4.35: Mathlib proves `WithTop.le_def`/`lt_def` by `grind`, so `WithTop.instPreorder`, +-- `instOrderTop`, `coe_lt_top` and `decidableLE`/`decidableLT` carry `Classical.choice`; pin the bare +-- choice-free `WithTop.instLE`/`instLT` here and decide and prove from their constructors. +attribute [local instance high] WithTop.instLE WithTop.instLT + +/-- Comparison on the carrier is decidable — by cases on `WithTop.LE`'s constructors, deciding below +`⊤` with the comparator-derived order on `SynONote`. This is hydra-battles' `lt_eq_lt_dec` +(decidability survives adjunction), the move Mathlib's `WithTop.decidableLE` makes at instance level. -/ +@[reducible] def e0DecidableLE : DecidableLE E0Note + | _, ⊤ => isTrue (WithTop.LE.le_top _) + | ⊤, (_ : SynONote) => isFalse (fun h => by cases h) + | (a : SynONote), (b : SynONote) => + if h : a ≤ b then isTrue (WithTop.LE.coe_le_coe h) + else isFalse (fun h' => by cases h'; contradiction) /-- Strict comparison on the carrier is decidable. -/ -@[reducible] def e0DecidableLT : DecidableLT E0Note := inferInstance +@[reducible] def e0DecidableLT : DecidableLT E0Note + | ⊤, _ => isFalse (fun h => by cases h) + | (a : SynONote), ⊤ => isTrue (WithTop.LT.lt_top a) + | (a : SynONote), (b : SynONote) => + if h : a < b then isTrue (WithTop.LT.coe_lt_coe h) + else isFalse (fun h' => by cases h'; contradiction) /-- Equality on the carrier is decidable. -/ @[reducible] def e0DecidableEq : DecidableEq E0Note := inferInstance /-- Every notation sits strictly below the adjoined top. -/ -theorem e0Coe_lt_top (x : ONote) : e0Coe x < (⊤ : E0Note) := WithTop.coe_lt_top _ +theorem e0Coe_lt_top (x : ONote) : e0Coe x < (⊤ : E0Note) := WithTop.LT.lt_top _ /-- The adjoined top bounds the whole carrier. -/ -theorem e0_le_top (a : E0Note) : a ≤ (⊤ : E0Note) := le_top +theorem e0_le_top (a : E0Note) : a ≤ (⊤ : E0Note) := WithTop.LE.le_top _ +end /-! ### The tower operator, and the stipulated fixed point @@ -100,6 +118,17 @@ theorem e0OmegaPow_fixedpoint_iff (a : E0Note) : e0OmegaPow a = a ↔ a = ⊤ := exact absurd h' (omegaPow_ne_self (ofSyn x)) · rintro rfl; rfl +-- `Statement:` the constant-`⊤` map is a `Nucleus E0Note` whose closed points are exactly the fixed +-- points of `e0OmegaPow`. +example : ∃ n : Nucleus E0Note, ∀ a : E0Note, n a = a ↔ e0OmegaPow a = a := + ⟨{ toFun := fun _ => ⊤ + map_inf' := fun _ _ => by simp + idempotent' := fun _ => le_rfl + le_apply' := fun _ => le_top }, + fun a => by + rw [e0OmegaPow_fixedpoint_iff] + exact eq_comm⟩ + /-! ### The map into `Ordinal` — the crossing This is where the classical assumption is paid. `ONote.repr` is Mathlib's denotation map, and it is @@ -107,7 +136,7 @@ This is where the classical assumption is paid. `ONote.repr` is Mathlib's denota /-- **Every ordinal notation denotes strictly below ε₀.** -The first of `ON_correct`'s three fields (Castéran, `ON_Generic.v`), here for Mathlib's `ONote` and +The first of `ON_correct`'s three fields (hydra-battles, `ON_Generic.v`), here for Mathlib's `ONote` and Mathlib's ε₀. Structural induction: ε₀ is a fixed point of `ω ^ ·`, hence both additively and multiplicatively principal, which is exactly what closes the `oadd` case. @@ -181,7 +210,7 @@ example : typeLT NONote = ε₀ := by /-- **The crossing.** The carrier's denotation map into Mathlib's classical `Ordinal`: notations go by `ONote.repr`, and the adjoined top goes to ε₀. -It has the into and onto properties of Castéran's `ON_correct` (`Schutte/Correctness_E0.v` is the +It has the into and onto properties of hydra-battles' `ON_correct` (`Schutte/Correctness_E0.v` is the existing ε₀ instantiation), with Mathlib's constructed `Ordinal` as the classical target instead of Schütte's axiomatized `Ord`. It is not an instance: `ON_correct` is stated over an `ON`, which needs a well-founded order (the `example` stating `¬ WellFoundedLT E0Note`), and the comparator property fails. @@ -251,8 +280,9 @@ forms is the standard fix."* It characterizes exactly when injectivity is **rest `Reading:` (conjectural) the framework reads the fiber as an instance of the **shape** that statistics calls *identifiability* — the parameter-to-observable map failing to be injective. ⚠ **Do not write -"structural identifiability" for this.** Both sources on disk (Villaverde 2016; Castro & de Boer 2020, -`.claude-local/papers/`) scope that term to **parametrized dynamic models**, where "structural" +"structural identifiability" for this.** Both sources read (Villaverde, Barreiro and Papachristodoulou, +PLOS Comput. Biol. 2016, doi:10.1371/journal.pcbi.1005153; Castro and de Boer, PLOS Comput. Biol. 2020, +doi:10.1371/journal.pcbi.1008248) scope that term to **parametrized dynamic models**, where "structural" contrasts with *practical* identifiability limited by data. `e0Repr` has no data, no dynamics and no such contrast, so the modifier does no work here. `CLAIMS.md`'s use of the term (the Buckingham row) is scoped to **ZP-B's real-valued threshold** `2^k`, a different object, and that row states the @@ -267,8 +297,7 @@ pointer to the precedent, not a POV claim about `e0Repr`. `Reading:` (conjectural) the framework reads this as where statistics enters, under Tim's framing that **succession is a state of representation**: what is uncertain is *which representation*, never *what happened*. ⚠ **Nothing here posits that anything moved** — the no-traversal commitment is untouched, and -the distribution below is over notations, not over histories. Long form: -`.claude-local/notes/future-research/offset_from_the_origin_2026-08-05.md`. -/ +the distribution below is over notations, not over histories. -/ theorem e0Repr_not_injective : ¬ Function.Injective e0Repr := by intro hinj obtain ⟨x, y, hne, hrepr⟩ := mathlib_ONote_order_not_antisymm @@ -314,7 +343,7 @@ example : ¬ WellFoundedLT E0Note := by rintro k rfl exact ih _ (hlt k) (k + 1) rfl intro h - exact hacc _ (h.wf.apply _) 0 rfl + exact hacc _ (h.apply _) 0 rfl /-- **`Statement:` the fiber, exhibited.** Two distinct notations with one denotation — the unfolding of `e0Repr_not_injective`, with `1 + ω` and `ω` as the underlying witness. -/ @@ -442,7 +471,7 @@ end ZeroParadox /-! ## Axiom Purity Check — this block IS the deliverable The two sides of the interface, measured. Observed: the carrier side is choice-free, ranging from no -axioms at all up to `[propext, Quot.sound]`; the map side is uniformly +axioms at all up to `[propext]`; the map side is uniformly `[propext, Classical.choice, Quot.sound]`. **The per-declaration numbers live HERE and nowhere else** — `ZeroParadox/Ordinal/PricedInterface.md` states only the shape, deliberately, because an enumeration duplicated into prose goes stale. If this block ever prints something outside diff --git a/ZeroParadox/Ordinal/PricedInterface.md b/ZeroParadox/Ordinal/PricedInterface.md index 61b9e2fe..f7f66b31 100644 --- a/ZeroParadox/Ordinal/PricedInterface.md +++ b/ZeroParadox/Ordinal/PricedInterface.md @@ -5,7 +5,8 @@ Long form of `ZeroParadox/Ordinal/PricedInterface.lean`. ## What this file is A **measurement**, not a construction. The carrier and the map out of it, declared in `ZeroParadox/Ordinal/PricedInterface.lean`, both follow -constructions that already exist in the literature (see "Prior art" — they are Castéran's, and the +constructions that already exist in the literature (see "Prior art" — both come from *hydra-battles*, credited to the +hydra-battles authors as in `ZeroParadox/Ordinal/SnapNucleusConstructive.md` § Prior art, and the citation is not a courtesy). What is being contributed here is the *price tag*: the axiom footprint of each side of the constructive/classical boundary, exhibited on declarations that sit on either side of a single named map, in a setting where the classical target is a real library type (Mathlib's `Ordinal`) @@ -22,20 +23,24 @@ is no choice in the type. And the conclusion overreaches its evidence by one ste choice-free (`ZeroParadox/Ordinal/ConstructiveOrdinals.lean`) is a fact about the *ascent*, while ε₀ is past what the notation system can name (`tower_cofinal`, `ZeroParadox/Ordinal/SnapNucleusConstructive.lean`). What can be said instead: the ε₀ results, as stated, are -**STATEMENT-CARRIED** (statement control, measured 2026-10-08; `ZeroParadox/Category/ChoiceCannotBe.md`), +**STATEMENT-CARRIED** (the statement controls printed in `ZeroParadox/Ordinal/Epsilon0MinMax.lean`; +`ZeroParadox/Category/ChoiceCannotBe.md`), and a restatement on a choice-free carrier has two readings. The defined one is `E0Note`: a choice-free Lean restatement where uniqueness of the fixed point is proved and its existence is set by definition, on an order that is not well-founded (§ *The carrier, and what it actually is* and § *The closure at the top is STIPULATED, not -discovered* below). The derived one, a well-founded Lean carrier on which the fixed point is derived, -leastness included, was not located as of 2026-10-13 (`ZeroParadox/Ordinal/SnapNucleus.md` -§ "Axiom footprint"); and the crossing into `Ordinal`, `e0Repr`, carries choice (the purity block). +discovered* below). The derived one, a well-founded Lean carrier whose statements are choice-free and on +which the fixed point is derived, by a choice-free derivation, leastness included, was not located as of 2026-10-13 (`ZeroParadox/Ordinal/SnapNucleus.md` +§ "Axiom footprint"); and the crossing into `Ordinal`, `e0Repr`, carries choice (the purity block of `ZeroParadox/Ordinal/PricedInterface.lean`). Worse, the claim was **not measurable by the instrument used to support it.** `Classical.choice` sits in the `Ordinal.partialOrder` *instance term*, so every statement written through that instance inherits it, as written, however it is proved — `a ≤ a` carries choice while `a = a` does not (`order_footprint_le` and `order_footprint_eq`, `ZeroParadox/Ordinal/OrdinalChoiceEssential.lean`, stated as two theorems precisely so that file's purity block *prints* the contrast rather than asserting it). Axiom footprints -on ε₀ results measure the ambient instance, not the proofs. +on ε₀ results measure the choice-carrying constants their statements reach, the order instance and the +operations (`Ordinal.omega0`, `Ordinal.nfp`, printed in the purity blocks of +`ZeroParadox/Ordinal/OrdinalChoiceEssential.lean` and `ZeroParadox/Ordinal/PricedInterface.lean` +respectively), not the proofs. This file replaces the unanswerable question with a measurable one: not *is the choice real*, but *what does crossing cost*. @@ -49,8 +54,8 @@ declaration is added. **The block at the bottom of the `.lean` file is the regis not copy it.** What is stated here is only the shape it prints, which is the finding: * **Constructive side — choice-free, and not uniformly `[propext]`.** Footprints range from **no axioms - at all** (the carrier and its coercion) up through `[propext]` to `[propext, Quot.sound]`. No - declaration on this side carries `Classical.choice`. + at all** (the carrier and its coercion) up to `[propext]`. No declaration on this side carries + `Classical.choice`. * **The map — `Classical.choice`, uniformly.** Every declaration **in that block** whose statement mentions `Ordinal` reports `[propext, Classical.choice, Quot.sound]`, with no exceptions and no gradation among them. ⚠ **Scoped to this block on purpose.** It is not @@ -67,27 +72,30 @@ not copy it.** What is stated here is only the shape it prints, which is the fin it is `e0Repr_not_injective` plus `Function.not_injective_iff`. It is a **crossing** declaration, it belongs exactly where the block files it, and it prices the crossing like every other one. -**The `Quot.sound` on part of the constructive side** arrives through Mathlib's `WithTop` order -instances and lemmas (`WithTop.instPreorder`, `WithTop.decidableLE`, `WithTop.decidableLT`, -`WithTop.instOrderTop`, `WithTop.coe_lt_top`, each `[propext, Quot.sound]`), not through anything -about ordinals: `SynONote`'s own order, `instLinearOrderSynONote`, measures `[propext]`. It is *not* -`Classical.choice`, and no declaration on the constructive side carries choice. +**The constructive side avoids Mathlib's `WithTop` order instances.** At the pin those instances and +lemmas (`WithTop.instPreorder`, `WithTop.decidableLE`, `WithTop.decidableLT`, `WithTop.coe_lt_top`) +carry `Classical.choice`, as does `WithTop.le_def`, which Mathlib proves by `grind`; the bare +`WithTop.instLE`/`instLT` carry no axioms. The Lean file pins those two, proves decidability by cases +on their constructors, and proves `e0Coe_lt_top` and `e0_le_top` as applications of those constructors +(`WithTop.LT.lt_top`, `WithTop.LE.le_top`; the `[ZP port]` comment above them). +`SynONote`'s own order, `instLinearOrderSynONote`, measures `[propext]`. -So the boundary is *priced*: the notation side's declarations cost at most `[propext, Quot.sound]` and +So the boundary is *priced*: the notation side's declarations cost at most `[propext]` and never `Classical.choice`; crossing to `Ordinal` costs `Classical.choice` at every declaration; and the crossing is one named map rather than a diffuse correspondence. **What that measurement does and does not license.** It locates where the classical assumption is paid on this pair of carriers. It does **not** show that Mathlib's ε₀ results are eliminable: as stated they -are STATEMENT-CARRIED, so no proof of them can drop the choice, and the open question is a restatement -on a choice-free carrier, with the two readings of § *Why this file exists — a correction of record*: -the defined one on `E0Note`, and the derived one, not located in Lean. Its state is in `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". +are STATEMENT-CARRIED, so no proof of them can drop the choice. The remaining question is a restatement +on a carrier whose statements are choice-free, with the two readings of § *Why this file exists — a +correction of record*: the defined one, in Lean on `E0Note`, and the derived one, not located as of +2026-10-13. Both, with the search record, are in `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". This is the same limit `ZeroParadox/Ordinal/SyntacticCollapse.md` records. Scoped to what is measured: *the ascent below ε₀ borrows a tool far stronger than it needs*, because its counterpart on notations measures `[propext]`. Note also the standing caveat from `ZeroParadox/Ordinal/OrdinalChoiceEssential.lean` — `Classical.choice` sits in `Ordinal`'s order *instance term*, so a statement that reaches that instance carries the choice whatever its proof -(`order_footprint_le` against `order_footprint_eq`, as in § *The measured price* above). The purity block is a measurement of the +(`order_footprint_le`, as in § *The measured price* above). The purity block is a measurement of the interface, not a verdict on any particular proof's essential needs. ## The carrier, and what it actually is @@ -128,7 +136,7 @@ it is stated for. ## What is NOT proved here, and must not be inferred -`ON_correct` (Castéran, `ON_Generic.v`; see below) is a class stated over an `ON`, a type with a +`ON_correct` (*hydra-battles*, `ON_Generic.v`; see below) is a class stated over an `ON`, a type with a comparison whose order is well-founded (`Class ON`'s field `ON_wf`), together with a target ordinal and a denotation map. Its three fields ask that every notation denotes below the target ordinal, that the map is **onto** the segment below it, and that the syntactic comparator **agrees** with the @@ -198,9 +206,10 @@ points of one carrier. ## Triviality assessment -The carrier is an `abbrev`. The order, the decidability instances, and the lattice structure are all -inherited from Mathlib's `WithTop` instances applied to an order built in a sibling file — `PricedInterface.lean` -proves none of that and should get no credit for it. `e0OmegaPow_top` is `rfl`. `e0Repr_top` is `rfl`. +The carrier is an `abbrev`. Its `≤` and `<` are Mathlib's `WithTop` relations applied to an order built in +a sibling file, the decidability is a case split on their constructors, and the top bound is a +constructor application — +`PricedInterface.lean` should get no credit for any of that. `e0OmegaPow_top` is `rfl`. `e0Repr_top` is `rfl`. Not everything here is free. `repr_lt_epsilon0` — every raw notation denotes strictly below ε₀ — is a short structural induction, but it does need the right closure facts about ε₀ (additive and @@ -215,7 +224,8 @@ that it is *stated as a price* on a specific named map, rather than left as a ge ## Prior art — the construction is not ours -**Castéran and Contejean, *hydra-battles* (rocq-community/hydra-battles), is the source of both halves.** +***hydra-battles* (rocq-community/hydra-battles; credited to the hydra-battles authors, as in +`ZeroParadox/Ordinal/SnapNucleusConstructive.md` § Prior art) is the source of both halves.** * **The carrier.** `theories/ordinals/OrdinalNotations/ON_plus.v` builds the **sum of two ordinal notation systems** — `t := (A + B)`, everything in `A` below everything in `B`, with the comparator @@ -223,11 +233,11 @@ that it is *stated as a price* on a specific named map, rather than left as a ge `ON_plus`, and crucially `lt_eq_lt_dec` proving that **decidability of comparison is preserved, generically**. `E0Note` has that construction's shape with a one-point right summand, and is not an instance of it: `ON_plus` sums two `ON`s, and `SynONote` is not one, because its order is not well-founded (above), so - `lt_wf` does not transfer. The decidability-preservation idea is his and is what `WithTop` repeats. The + `lt_wf` does not transfer. The decidability-preservation idea is `ON_plus.v`'s and is what `WithTop` repeats. The abstraction `ON_plus` is stated over, `Class ON` (`ON_Generic.v`) — a well-founded ordered datatype with a comparison function — is published. Mathlib's `WithBot`/`WithTop` decidability and lattice instances - (`Mathlib/Order/WithBot.lean`) are the same move at instance level, and are what `PricedInterface.lean` actually - calls. + (`Mathlib/Order/WithBot.lean`) are the same move at instance level; `PricedInterface.lean` calls their + bare `WithTop.instLE`/`instLT` and constructors. * **The map.** The canonical name for "a notation system correctly denotes into a classical ordinal" is **`ON_correct`** (`ON_Generic.v`), with the three fields listed above. It is **already instantiated at ε₀**: `theories/ordinals/Schutte/Correctness_E0.v` builds `inject : T1 → Ord` with diff --git a/ZeroParadox/Ordinal/SnapMetaLattice.lean b/ZeroParadox/Ordinal/SnapMetaLattice.lean index 292e0065..fa86a584 100644 --- a/ZeroParadox/Ordinal/SnapMetaLattice.lean +++ b/ZeroParadox/Ordinal/SnapMetaLattice.lean @@ -1,4 +1,5 @@ import ZeroParadox.Ordinal.SnapNucleus +import ZeroParadox.Valuation.InfinitudeFloor import Mathlib.Order.Sublocale set_option maxHeartbeats 400000 @@ -18,14 +19,14 @@ and the **sublocales** (the systems they generate) form a `Coframe`: the *lattic **Why this is the boundary doing the work.** Bare `Ordinal` has no top (`IsEmpty (OrderTop Ordinal)`, `ZeroParadox/Category/DieNucleus.lean` § IV); the ceiling, ⊤ of `WithTop Ordinal`, unlocks the lattice. Reading it as -the infinite pole is a placement Reading (`ZeroParadox/Multihomed/BoundaryOrder.lean` § I): the pole chart's coincidence -witness `infinitude_forces_infinite_complexity` (`ZeroParadox/BottomCannotBe.lean` § INVERSION) takes an `InfinitudeFloor` -carrier, and every infinite carrier admits one (`infinitudeFloor_nonempty_iff_infinite`), so the class cannot single out -⊤ of `WithTop Ordinal`. The placement is a theorem: `phaseEquivWithTop` sends `Phase.floor` to the greatest element -(the `IsTop` half of `phaseEquivWithTop_floor_covers_nothing`, BoundaryOrder § I). Its NOVELTY, a NEXT bottom, is -the framework's commitment, not a theorem (`ZeroParadox/Order/SnapCannotBe.lean` § IV): `phaseFloorToTop`, defined as -`phaseEquivWithBot.symm.trans phaseEquivWithTop`, re-places one `Phase.floor`, sending ⊥ of `WithBot Ordinal` to ⊤ of -`WithTop Ordinal` (`phaseFloorToTop_apply.1`); in the 2-adic realization the arc reapproaches the same 0 (`snap_arc_z2_loop`). +the infinite pole is a placement Reading (`ZeroParadox/Multihomed/BoundaryOrder.lean` § I): the coincidence witness +`infinitude_forces_infinite_complexity` (`ZeroParadox/BottomCannotBe.lean` § INVERSION) takes an `InfinitudeFloor` +carrier, every infinite carrier admits one (`infinitudeFloor_nonempty_iff_infinite`), and any point of it can be the +`floor` (the `example` after `snapSublocale`), so the class cannot single out ⊤ of `WithTop Ordinal`. The map is a theorem: +`phaseEquivWithTop` sends `Phase.floor` to the greatest element (`phaseEquivWithTop_floor_covers_nothing`, `IsTop` +half). The NOVELTY of ⊤ of `WithTop Ordinal`, a NEXT bottom, is the framework's commitment, not a theorem +(`ZeroParadox/Order/SnapCannotBe.lean` § IV): `phaseFloorToTop` sends ⊥ of `WithBot Ordinal` to ⊤ of `WithTop Ordinal` +(`phaseFloorToTop_apply.1`); in the 2-adic realization the arc reapproaches the same 0 (`snap_arc_z2_loop`). **Honest scope.** The frame structure of `WithTop Ordinal` is Mathlib's, and that the nuclei on a frame form a frame is locale theory (Escardó, "Joins in the frame of nuclei", Applied Categorical Structures 11 (2003), § 1 of the author's @@ -76,9 +77,10 @@ noncomputable example (j : Nucleus (WithTop Ordinal)) : Sublocale (WithTop Ordin /-! ### § III. Contrast — the bare ordinals carry a modality but NOT the lattice `snapNucleus : Nucleus Ordinal` exists on the bare ordinals (a `Nucleus` needs only `SemilatticeInf`). But -`Ordinal` is not a frame, so `Order.Frame (Nucleus Ordinal)` and `Sublocale Ordinal` do NOT fire there — -the single modality lives one level below the lattice. Adjoining the top is what lifts it into a lattice of -systems. -/ +`Ordinal` is not a frame (it has no top), and the nuclei on it do not form a lattice: the `example` below +exhibits two with no common upper bound. `Sublocale X` takes `[Order.Frame X]` as an argument, so +`Sublocale Ordinal` does not typecheck — the single modality lives one level below the lattice. Adjoining the top +is what lifts it into a lattice of systems. -/ /-- The single modality on the bare ordinals (from `ZeroParadox/Ordinal/SnapNucleus.lean`). -/ noncomputable example : Nucleus Ordinal := snapNucleus @@ -91,9 +93,11 @@ noncomputable example : Nucleus Ordinal := snapNucleus `Motion.isLanding_ofNucleus_anti` with `Motion.isLanding_ofNucleus_iff`, `ZeroParadox/Category/DieNucleus.lean`, on a meet-semilattice; Mathlib's `Nucleus.range_subset_range` assumes a frame); so `m 0` is a successor `succ b`, and no `succ b` has `ω ^ succ b = succ b`. - `Reading:` adjacent prior art, for closure operations on a poset rather than nuclei: Elliott, - arXiv:1101.2462 (2011), § 4, p. 12 (`⋆₁ ≤ ⋆₂` iff the fixed set of `⋆₁` contains that of `⋆₂`), and - Lemma 4.2, p. 13 (on a bounded complete poset, joins of BOUNDED families of closure operations). -/ + `Reading:` adjacent prior art: Elliott, arXiv:1101.2462v1 (2011), § 4, p. 12 (closure operations on a + poset, `⋆₁ ≤ ⋆₂` iff the fixed set of `⋆₁` contains that of `⋆₂`), Lemma 4.2, p. 13 (on a bounded + complete poset, joins of BOUNDED families of closure operations), and Proposition 4.3, p. 13 (the same + for his nuclei on an ordered magma, when it is also near residuated). On the chain `Ordinal` a closure operation preserves binary meets, + so it is a `Nucleus`, and Lemma 4.2 bears directly: this pair is the unbounded case it excludes. -/ example : ∃ j k : Nucleus Ordinal, ∀ m : Nucleus Ordinal, ¬ (j ≤ m ∧ k ≤ m) := by classical let kf : Ordinal → Ordinal := fun x => if ∃ b, succ b = x then x else succ x @@ -194,6 +198,18 @@ theorem snapNucleusTop_coe_bot : the lattice. -/ noncomputable def snapSublocale : Sublocale (WithTop Ordinal) := snapNucleusTop.toSublocale +-- `Statement:` on an infinite carrier every point is the `floor` of some `InfinitudeFloor`: transport +-- an instance along `Equiv.swap` of its floor and the chosen point. +example {α : Type*} [Infinite α] (a : α) : ∃ I : InfinitudeFloor α, I.floor = a := by + classical + obtain ⟨I⟩ := (infinitudeFloor_nonempty_iff_infinite α).mpr ‹_› + refine ⟨{ floor := Equiv.swap I.floor a I.floor + cx := I.cx ∘ (Equiv.swap I.floor a).symm + member := Equiv.swap I.floor a ∘ I.member + cx_member_strictMono := by simpa [Function.comp_def] using I.cx_member_strictMono + cx_floor_eq_iSup := by simpa [Function.comp_def] using I.cx_floor_eq_iSup }, ?_⟩ + simp + end ZeroParadox /-! ## Axiom Purity Check -/ diff --git a/ZeroParadox/Ordinal/SnapNucleus.lean b/ZeroParadox/Ordinal/SnapNucleus.lean index 8e1533b8..51a1eee9 100644 --- a/ZeroParadox/Ordinal/SnapNucleus.lean +++ b/ZeroParadox/Ordinal/SnapNucleus.lean @@ -67,16 +67,27 @@ theorem snapNucleus_epsilon0 : snapNucleus epsilonZero = epsilonZero := theorem snapNucleus_bot_ne_bot : snapNucleus (⊥ : Ordinal) ≠ (⊥ : Ordinal) := by rw [snapNucleus_bot]; exact epsilon0_ne_bot +/-- `Statement:` a nucleus on `Ordinal.{0}` exists, as a bare proposition (statement control). -/ +def snapNucleusNonemptyStatement : Prop := Nonempty (Nucleus Ordinal.{0}) + +/-- `Statement:` `snapNucleus_bot_ne_bot`'s statement at universe 0, bare (statement control). -/ +def snapNucleusBotStatement : Prop := snapNucleus.{0} (⊥ : Ordinal.{0}) ≠ (⊥ : Ordinal.{0}) + +example : snapNucleusNonemptyStatement := ⟨snapNucleus⟩ +example : snapNucleusBotStatement := snapNucleus_bot_ne_bot + end ZeroParadox /-! ## Axiom Purity Check The results inherit `Classical.choice` from Mathlib's `Ordinal` fixed-point theory (`nfp`, `epsilon`). -**Status: STATEMENT-CARRIED** (`ZeroParadox/Category/ChoiceCannotBe.md`): each statement below, only -assumed, already reports the choice (statement control, measured 2026-10-08), so no proof of these -statements as written can drop it. The open question is a restatement on a notation carrier whose -statements are choice-free; where the choice enters, and that question's current state, are in -`ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". -/ +**Status: STATEMENT-CARRIED** (`ZeroParadox/Category/ChoiceCannotBe.md`): the statements, with no proof +attached, already carry the choice (the statement controls `snapNucleusNonemptyStatement` and +`snapNucleusBotStatement`, printed below), so no proof of these statements as written can drop it. The +remaining question is a restatement on a carrier whose statements are choice-free, with two readings: a +defined one, in Lean on `E0Note`, and a derived one, on a well-founded +carrier, not located as of 2026-10-13. Where the choice enters, both readings +and the search record are in `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint". -/ section PurityCheck open ZeroParadox @@ -84,4 +95,7 @@ open ZeroParadox #print axioms snapNucleus_bot #print axioms snapNucleus_epsilon0 #print axioms snapNucleus_bot_ne_bot +-- The statement controls: the statements alone. +#print axioms snapNucleusNonemptyStatement +#print axioms snapNucleusBotStatement end PurityCheck diff --git a/ZeroParadox/Ordinal/SnapNucleus.md b/ZeroParadox/Ordinal/SnapNucleus.md index 7d717470..11ff87ec 100644 --- a/ZeroParadox/Ordinal/SnapNucleus.md +++ b/ZeroParadox/Ordinal/SnapNucleus.md @@ -47,7 +47,9 @@ Completing the meta-lattice by that boundary is a separate construction, not att ## Axiom footprint `snapNucleus` and the results about it are STATEMENT-CARRIED (`ZeroParadox/Category/ChoiceCannotBe.md`): -each statement, only assumed, already reports `Classical.choice` (statement control, measured 2026-10-08). +each statement, only assumed, already reports `Classical.choice` (the statement controls +`snapNucleusNonemptyStatement` and `snapNucleusBotStatement`, `#print axioms` in the PurityCheck section of +`ZeroParadox/Ordinal/SnapNucleus.lean`). The choice is **not** in the `Ordinal` type — `#print axioms Ordinal` reports `[propext, Quot.sound]`. It enters through the *order instance and the operations*: `Ordinal.instLinearOrder`, `Ordinal.nfp`, `Ordinal.omega0` and `Ordinal.epsilon` each measure `[propext, Classical.choice, Quot.sound]`, and @@ -77,10 +79,33 @@ part (measured 2026-10-08): exponentiation at every base (Thm 18), and their cubical Agda development defines ε₀ as the limit of the ω-tower and proves ε₀ = ω^ε₀ (the development uses Agda's `{-# TERMINATING #-}` pragma to work around one known Agda bug and one termination-checker limitation, KNX p. 3, which does not say which - results use it); every Cantor normal form lies below it (Thm 22). A lemma that + results use it; the same paragraph adds that such recursive calls, when proving a proposition, are + justified by the eliminator presentation of Dijkstra's thesis (*Quotient Inductive-Inductive + Definitions*, Nottingham 2017, KNX's reference 21), "although it would be non-trivial to reduce our + mutual definitions to eliminators", and the page states just before that pen-and-paper proofs of + all their results are in the appendix); every Cantor normal form lies below it (Thm 22). A lemma that ε₀ is the *least* fixed point of `ω^·` was not located there as of 2026-10-08 (searched: the paper, and the Agda module `BrouwerTree.Arithmetic.Properties`, pinned to a commit in `ZeroParadox/Ordinal/ConstructiveOrdinals.md` § Prior art). + A second constructive carrier outside Lean is the Coq library *hydra-battles* (P. Castéran, with + contributions by É. Contejean, F. Hatat and P. Manoury, *Hydra Battles in Coq*, draft of + 4 November 2020). Its book states that, except for the `Schutte` library, the development is + axiom-free and respects the rules of intuitionistic logic, and that the `Equations` plug-in used + in Chap. 6 imports axioms (p. 9). Its notation `T2`, for the ordinals below Γ₀ (that the + notation system `Gamma0` built on it is a correct implementation of [0, Γ₀) is Project 8.7 of the + 2020 draft, p. 157), proves `epsilon0_fxp : epsilon0 = phi zero epsilon0` from `epsilon_fxp`, + which is closed by `reflexivity` (p. 155). Our reading of why reflexivity suffices: `epsilon b` is + defined as `[one, b]` (p. 148), and the `phi` definition on p. 155 returns `[b1, b2]` unchanged + when its first argument is below `b1`. Its order on Veblen-normal-form terms (the subtype `G0`) + is well-founded (`lt_wf`, p. 157). There the fixed-point equation holds by computation. A + leastness lemma was located there only in the classical `Schutte` library as of 2026-11-01 + (searched at `ed8e604`: `least_fixpoint` across the repository, `theories/ordinals/Gamma0/Gamma0.v` + and `theories/gaia/nfwfgaia.v`): `epsilon0_lfp : least_fixpoint lt phi0 epsilon0` in + `theories/ordinals/Schutte/AP.v`, which imports `Coq.Logic.Epsilon`. Outside `Schutte`, + `epsilon0_as_lub` in `theories/ordinals/Gamma0/Gamma0.v` is a least-strict-upper-bound statement over + the terms below ε₀: every normal-form strict upper bound of them is at least ε₀. It is not the + ω-tower-supremum statement, which this corpus states in Lean as `epsilonZero_eq_iSup` + (`ZeroParadox/Ordinal/Gentzen.lean`). * **The defined reading, in Lean: `E0Note`.** `ZeroParadox/Ordinal/PricedInterface.lean` adjoins one point ⊤ above the notations (`E0Note := WithTop SynONote`), and `e0Repr` sends ⊤, and only ⊤, to ε₀ (`e0Repr_eq_epsilon0_iff`). There the tower operator fixes ⊤ **by definition** @@ -90,8 +115,10 @@ part (measured 2026-10-08): uniqueness on `E0Note`, with existence set by definition rather than derived, on an order that is not well-founded (the `example` stating `¬ WellFoundedLT E0Note`). That file states no leastness declaration. Its crossing into `Ordinal`, `e0Repr`, carries `Classical.choice` (its purity block). -* **Open: the derived reading.** A well-founded Lean carrier whose statements are choice-free, on which ε₀'s fixed point is derived - rather than set by definition, leastness included, was not located as of 2026-10-13. Searched: this + On `E0Note` a snap nucleus exists trivially: the constant-⊤ map is a `Nucleus` whose closed points are + exactly the fixed points of `e0OmegaPow` (the `example` after `e0OmegaPow_fixedpoint_iff`). +* **Open: the derived reading.** A well-founded Lean carrier whose statements are choice-free, on which ε₀'s fixed point is derived, + by a choice-free derivation, rather than set by definition, leastness included, was not located as of 2026-10-13. Searched: this corpus, 2026-10-08 and again 2026-10-13 (`ZeroParadox/**/*.lean` for carriers built over ordinal notations; `E0Note` is the only one reaching ε₀); and on 2026-10-13, `theoremsearch` on "epsilon zero is the least fixed point of omega exponentiation on a well-founded ordinal notation system, constructive proof" (formal and @@ -102,7 +129,9 @@ part (measured 2026-10-08): fixed point well-founded without Classical.choice"; each returned Mathlib's `Ordinal` and `ONote` material (its well-foundedness `NONote.lt_wf` goes through `repr`), or work outside Lean. The crossing of any such result into Mathlib's `Ordinal` carries choice, because the target statements are STATEMENT-CARRIED - (above). + (above). A later check of the same item against two Lean carriers of MaxWellApexLab/OrdinalAnalysis + (commit `87baec7`, 2026-10-17) is recorded in `ZeroParadox/Ordinal/ConstructiveOrdinals.md`: on + both, the fixed point is set by a normal-form convention, so neither is the derived reading. ## Credit outward diff --git a/ZeroParadox/Ordinal/SnapNucleusConstructive.lean b/ZeroParadox/Ordinal/SnapNucleusConstructive.lean index bbf18d8f..6d9ae392 100644 --- a/ZeroParadox/Ordinal/SnapNucleusConstructive.lean +++ b/ZeroParadox/Ordinal/SnapNucleusConstructive.lean @@ -275,11 +275,13 @@ end ZeroParadox /-! ## Axiom Purity Check Target: `[propext]` or cleaner on everything, including the `LinearOrder`/`SemilatticeInf` structure. -Contrast the measured `[propext, Classical.choice, Quot.sound]` on `snapNucleus` in -`ZeroParadox/Ordinal/SnapNucleus.lean`. That footprint is STATEMENT-CARRIED (statement control, measured -2026-10-08; `ZeroParadox/Category/ChoiceCannotBe.md`), though the choice is not in the `Ordinal` type -(`[propext, Quot.sound]`): it enters via `Ordinal.instLinearOrder`, `nfp`, `omega0` and `epsilon`. The -open question is a restatement on a choice-free carrier; on this one it is blocked by naming (above). -/ +Contrast `snapNucleus` (`ZeroParadox/Ordinal/SnapNucleus.lean`), STATEMENT-CARRIED (the statement controls +in that file's purity block; `ZeroParadox/Category/ChoiceCannotBe.md`); the choice is not in the `Ordinal` +type but enters via `Ordinal.instLinearOrder`, `nfp`, `omega0` and `epsilon`. The remaining question is a +restatement on a carrier whose statements are choice-free, with two readings: a defined one, in Lean on +`E0Note`, and a derived one, on a well-founded carrier, not located as of 2026-10-13 (both, with the search +record: `ZeroParadox/Ordinal/SnapNucleus.md` § "Axiom footprint"); on this carrier, `ONote`, it is blocked +by naming (above). -/ section PurityCheck open ZeroParadox diff --git a/ZeroParadox/Ordinal/SnapNucleusConstructive.md b/ZeroParadox/Ordinal/SnapNucleusConstructive.md index 471eddc6..a0f9e668 100644 --- a/ZeroParadox/Ordinal/SnapNucleusConstructive.md +++ b/ZeroParadox/Ordinal/SnapNucleusConstructive.md @@ -171,7 +171,7 @@ structural induction on the notation, never through `repr`; Mathlib's `ONote.cmp reused because it requires the `NF` predicate, which is itself defined via `repr` and carries choice. The result is a `LinearOrder SynONote`, hence a `SemilatticeInf`, hence `Nucleus SynONote` typechecks — and every piece of it is `[propext]` or cleaner. That is what makes `no_snap_nucleus` a statement about -an actually-inhabitable type rather than a vacuous one. +an inhabited type, `Nucleus SynONote` (`idNucleus` inhabits it), rather than an uninhabited one. ## Triviality assessment @@ -201,10 +201,13 @@ on the syntactic substrate to avoid inherited choice is ZP-N's (point-free Lawvere-Tierney). That Cantor normal form names exactly the ordinals below ε₀ is classical proof theory, not a result proved in the Lean file. -**The closest specialist precedent, named.** Castéran and Contejean's *hydra-battles* development (Coq) -carries a CNF datatype `T1` for the ordinals **below** ε₀, constructive (axiom-free / intuitionistic -outside its Schütte module), with ε₀ as the notation system's **supremum** — and, per our own prior-art -survey of 2026-06-27, *not* phrased as a least fixed point and carrying no least-fixed-point theorem. +**The closest specialist precedent, named.** The *hydra-battles* development (Coq; credited here to +the hydra-battles authors, since its book names P. Castéran with contributions by É. Contejean, +F. Hatat and P. Manoury) carries a CNF datatype `T1` for the ordinals **below** ε₀, constructive +(axiom-free / intuitionistic outside its Schütte module), with ε₀ as the notation system's +**supremum**. Its `Epsilon0/T1.v` development, per our own prior-art survey of 2026-06-27, is *not* +phrased as a least fixed point and carries no least-fixed-point theorem; the library's classical +Schütte module does prove leastness (`epsilon0_lfp`, cited in ZP-N, `scripts/build_zpn.py`). That is the same carrier and the same supremum as here. Grimm's Gaia development (INRIA RR-8407) builds a comparable `T1 ≈ ε₀` and treats ε₀ as a fixed point of `ω^·`, but **explicitly uses excluded middle and choice** — the classical comparison point. @@ -222,7 +225,7 @@ layer carries a distinctive construction with its own separate prior art. **Two further hydra-battles constructions are cited here because a sibling file follows their shape.** `ZeroParadox/Ordinal/PricedInterface.lean` adjoins a top to `SynONote` and maps the result into -Mathlib's `Ordinal`. Both moves follow Castéran, and the credit above does not reach them: +Mathlib's `Ordinal`. Both moves follow hydra-battles, and the credit above does not reach them: `theories/ordinals/OrdinalNotations/ON_plus.v` builds the **sum of two ordinal notation systems** generically (`compare_plus`, `plus_comp`, `lt_wf`, `ON_plus`, and `lt_eq_lt_dec` proving that decidability of comparison survives the adjunction). "Notations plus one adjoined point" has that diff --git a/ZeroParadox/Ordinal/SnapSuccession.lean b/ZeroParadox/Ordinal/SnapSuccession.lean index f58fc88e..1dc9f43c 100644 --- a/ZeroParadox/Ordinal/SnapSuccession.lean +++ b/ZeroParadox/Ordinal/SnapSuccession.lean @@ -15,8 +15,12 @@ Bottom is not ever epsilon zero. Always next to, but never the same as. --- +`Reading:` the Take's "brand new instance of bottom" is the novelty commitment (C-DA2), not a theorem: proved is +the role half, that anything filling the bottom role is ⊥ of its semilattice (`t_iz_limit_is_new_null`); in the +2-adic realization the arc returns to the same 0 (`snap_arc_z2_loop`). + The snap re-seeds above where it landed and runs again; the ε-numbers are the targets it runs TO, -never ⊥ itself (`epsilon0_ne_bot`). The overview, the iterative-bottom vocabulary ruling and every +never ⊥ of `Ordinal` (`epsilon0_ne_bot`). The overview, the iterative-bottom vocabulary ruling and every fence live in the ride-along `SnapSuccession.md`; each result is stated again at its own declaration. -/ diff --git a/ZeroParadox/Ordinal/SnapSuccession.md b/ZeroParadox/Ordinal/SnapSuccession.md index 355a5e14..1c4ca6a1 100644 --- a/ZeroParadox/Ordinal/SnapSuccession.md +++ b/ZeroParadox/Ordinal/SnapSuccession.md @@ -6,12 +6,15 @@ Ride-along companion to `ZeroParadox/Ordinal/SnapSuccession.lean`. sending ⊥ to ε₀. The snap does not stop there: it re-seeds above where it landed and runs again. That file makes the succession precise. -## The rungs are targets, never ⊥ +## The rungs are targets, never ⊥ of `Ordinal` **Read this distinction before anything else; an earlier draft of the header got it wrong.** The ε-numbers are the ordinals the snap runs **to** — its successive closed points, the targets. They -are **not** ⊥. `ε₀ ≠ ⊥` is a bedrock invariant (`epsilon0_ne_bot`): ⊥ is the base fed in, ε₀ the -closure that comes out, and **the base is never its own closure**. +are **not** ⊥ of `Ordinal`. `ε₀ ≠ ⊥` in `Ordinal` is a bedrock invariant (`epsilon0_ne_bot`): ⊥ of +`Ordinal` is the seed fed in, ε₀ the closure that comes out, and **this seed is not its own +closure**, because ω^0 ≠ 0 (`bot_is_not_a_step`). A seed that is itself a fixed point of ω^· is its +own closure (`ZeroParadox/Ordinal/Epsilon0CannotBe.lean` § I-b), which is why each next rung is +seeded strictly above the last. **The standard term for a rung is an ITERATIVE BOTTOM** (ratified 2026-07-19). One carrier in which a rung IS a bottom is its up-set `Set.Ici rung`: the rung is ⊥ of `Set.Ici rung`, and never ⊥ of `Ordinal` @@ -27,7 +30,7 @@ collides with the locale vocabulary this file's neighbours use. This is the role/identity distinction, the same shape as the family-versus-instance reading: the rungs are all *of the same kind*, and they are *provably distinct* members (`succession_lt_succ`), so -no two of them — and none of them and ⊥ — may be identified. +no two of them — and none of them and ⊥ of `Ordinal` — may be identified. ## The other succession, and why the two readings must not merge @@ -53,8 +56,8 @@ So the succession of snap targets is the **ε-hierarchy** `ε₀ < ε₁ < ε₂ - it climbs **strictly** — each target is genuinely above the last (`succession_lt_succ`), never the same one; - its first rung is ε₀ (`succession_zero`) — the target of the snap seeded at ⊥, not the ordinals' - bottom (`ε₀ ≠ ⊥` in `Ordinal`, `epsilon0_ne_bot`): ⊥ = 0 is the base the tower is seeded at, and ε₀ - is its closure. + bottom (`ε₀ ≠ ⊥` in `Ordinal`, `epsilon0_ne_bot`): ⊥ = 0 of `Ordinal` is the seed of the tower, + and ε₀ is its closure. This is Tim's "when one instance ends, another begins" as a strictly increasing chain of closed points. diff --git a/ZeroParadox/Ordinal/SyntacticCollapse.md b/ZeroParadox/Ordinal/SyntacticCollapse.md index a38c357a..7e45f236 100644 --- a/ZeroParadox/Ordinal/SyntacticCollapse.md +++ b/ZeroParadox/Ordinal/SyntacticCollapse.md @@ -149,8 +149,9 @@ suffices for the tower (where the coefficient is pinned at 1) and nowhere else. `ONote` / `NONote` and `ONote.cmp` are Mathlib (`Mathlib.SetTheory.Ordinal.Notation`). The technique of working on the syntactic substrate to avoid the choice inherited from Mathlib's `Ordinal` is not new here either. ZP-N (`ZeroParadox/Ordinal/ConstructiveOrdinals.lean`) used it for the ordinal *ascent* -(`exp_lt_term`, `omegaPow_no_fixedpoint`, `tower_strictMono`), and outside this corpus Castéran and -Contejean's *hydra-battles* (Coq, `theories/ordinals/Epsilon0/T1.v`) works on the same raw-syntax -substrate, as `ZeroParadox/Ordinal/SnapNucleusConstructive.md` records. The Lean file +(`exp_lt_term`, `omegaPow_no_fixedpoint`, `tower_strictMono`), and outside this corpus the +Coq library *hydra-battles* (`theories/ordinals/Epsilon0/T1.v`; credited as in +`ZeroParadox/Ordinal/SnapNucleusConstructive.md`) works on the same raw-syntax +substrate. The Lean file extends that same technique to the valuation/metric side. The contribution is the instance, not the method. diff --git a/ZeroParadox/README.md b/ZeroParadox/README.md index f65bab3d..5c2fd358 100644 --- a/ZeroParadox/README.md +++ b/ZeroParadox/README.md @@ -26,11 +26,11 @@ Lint policy: `weak.linter.mathlibStandardSet` is on, so the build flags genuine |------|------------|------------| | `Lattice.lean` | `ZPSemilattice` typeclass (A1–A4); partial order (T1); ⊥ minimum (T2); monotonicity (T3) | — | | `Padic.lean` | `OntologicalStates` free inductive (AX-B1 — modelling commitment, not derived); ultrametric (T1); clopen balls (T2); topological irreversibility (C3) | Lattice | -| `Surprisal.lean` | `BinaryState` free inductive; `MachinePhase`; L-RUN (c₀ ≠ c₁, so the step from ⊥ of `MachinePhase` (c₀) to c₁ is a state change off it); TQ-IH (the same fact read from c₁); L-INF (unbounded surprisal at ⊥) | Lattice, Padic | +| `Surprisal.lean` | `BinaryState` free inductive; `MachinePhase`; L-RUN (c₀ ≠ c₁, so the step from ⊥ of `MachinePhase` (c₀) to c₁ is a state change off it); TQ-IH (the same fact read from c₁); L-INF in two charts: depth chart, `l_inf`: surprisal is unbounded in the depth n, and every value `surprisal n` is a finite real (its codomain is ℝ); point chart: at the point 0 of Q₂, which lies in every ball 2ⁿℤ₂, the complexity `cxQ2` of the instance `q2InfinitudeFloor` (`ZeroParadox/Valuation/InfinitudeFloor.lean`) is ⊤ (`infinitude_forces_infinite_complexity`) and equals the supremum of the members' climbing values (`infinite_complexity_is_infinitude_of_zeros`); the additive 2-adic valuation is likewise ⊤ at 0, as standard (`AddValuation.map_zero`; Mathlib's ℤ-valued `Padic.valuation` reads 0 there). That ⊥ of `MachinePhase` (c₀) corresponds to that point is a reading (a design identification), not a theorem and not an equation between carriers | Lattice, Padic | | `StateSpace.lean` | `TransitionMap`; transition operator T: Q₂ → ℂⁿ; orthogonal snap shift (T4); non-decreasing norms (T5) | Lattice, Padic | | `Snap.lean` | `MachinePhase` ZPSemilattice instance; **T-SNAP** (`join c₀ c₁ = c₁`); DA-2 (successor null); `da1_minimal_path` (axiom-free) | Lattice–StateSpace | -| `SetTheoryAFA.lean` | `AFAStructure` typeclass; **T-EXEC** (Quine atom = ⊥, axiom-free); `cc1_derived` (CC-1 as theorem); three-way equivalence: Quine atom = ⊥ = join-identity | Lattice | -| `Kleene.lean` | `KleeneStructure` typeclass (a commitment, not a derived bridge); `kleene_fixed_point_exists` (Kleene's second recursion theorem, via Mathlib `fixed_point₂`); `selfApply_partrec` (self-application is partial computable); T-COMP (three-way equivalence proved; the computational face enters as a class field, not a clause); **`da1_closed_concrete : IsQuineAtom(⊥ : MachinePhase)`** | Snap, SetTheoryAFA | +| `SetTheoryAFA.lean` | `AFAStructure` typeclass; **T-EXEC** (Quine atom = ⊥, axiom-free); `cc1_derived` (CC-1 as theorem); `t_exec_triple_iff`: Quine atom ↔ (= ⊥ ∧ join identity) | Lattice | +| `Kleene.lean` | `KleeneStructure` typeclass (a requirement, not a derived bridge; its identity reading is retired, and that ⊥ runs is the occurrence commitment); `kleene_fixed_point_exists` (Kleene's second recursion theorem, via Mathlib `fixed_point₂`); `selfApply_partrec` (self-application is partial computable); T-COMP (Quine atom ↔ (bottom ∧ join identity); with `da2_bottom_characterization` the three-way equivalence; the computational face enters as a class field, not a clause); **`da1_closed_concrete : IsQuineAtom(⊥ : MachinePhase)`** | Snap, SetTheoryAFA | | `SemilatticeInstance.lean` | **`t_iz_complete`** (all four T-IZ steps: Cauchy convergence + DA-2 + the Lean counterpart of DA-1's Path 1 in a KleeneStructure (`da1_computational`) + T-SNAP); `h_strict_from_r1_t3` (strict valuation growth derived, not assumed) | Lattice, Padic, Snap, Kleene | ### Categorical extension (self-contained; depends on Snap conceptually, not formally) @@ -54,6 +54,6 @@ The framework is explicit about what is and is not Lean-verified. Two boundaries **Category.lean T6-b/c** — The Lean proofs for T6-b (strict surprisal inequality) and T6-c (subadditivity along chains) verify only `Nat.zero_le _` (non-negativity by type). The K-specific content — strict inequality and subadditivity of Kolmogorov complexity — is outside Lean scope and explicitly noted as such in the file's inline scope note. Importantly, T6-b/c are **not load-bearing for any subsequent formal result**. The load-bearing singularity claim — that surprisal diverges along sequences approaching ⊥ — is separately proved in `t2_diverges` using Q₂'s specific structure, without K. -**Snap.lean / Surprisal.lean — DA-1 Path 2** — L-INF formally proves that surprisal is unbounded at ⊥. The step from unbounded surprisal to executing is not a consequence of L-INF and is not DA-1: it is a bridge principle of its own, which the framework does not adopt and which is not the occurrence commitment (ZP-E, DA-1 Path 2). Kleene.lean carries the Lean counterparts of DA-1's Paths 1 and 3 together (`da1_paths_unified`): ⊥ is the AFA Quine atom, and the class names a code satisfying `IsComputationalQuine`. That is a conjunction, not a proof that the two paths are one fact, and the computational side enters as a `KleeneStructure` requirement. DA-1 itself is closed given DP-2 (`da1_minimal_path`, Snap.lean); its precondition, that the configuration reaching P₀ is executing, is the occurrence commitment, which DA-1 consumes and does not supply. +**Snap.lean / Surprisal.lean — DA-1 Path 2** — L-INF formally proves that surprisal is unbounded in the depth n (`l_inf`), each value a finite real since the codomain is ℝ; the point chart is `infinitude_forces_infinite_complexity` at the instance `q2InfinitudeFloor`, where the complexity `cxQ2` at the point 0 of Q₂ is ⊤; that ⊥ of `MachinePhase` (c₀) corresponds to that point is a reading (a design identification), not a theorem. The step from unbounded surprisal to executing is not a consequence of L-INF and is not DA-1: it is a bridge principle of its own, which the framework does not adopt and which is not the occurrence commitment (ZP-E, DA-1 Path 2). Kleene.lean carries the Lean counterparts of DA-1's Paths 1 and 3 together (`da1_paths_unified`): ⊥ is the AFA Quine atom, and the class names a code satisfying `IsComputationalQuine`. That is a conjunction, not a proof that the two paths are one fact, and the computational side enters as a `KleeneStructure` requirement. DA-1 itself is closed given DP-2 (`da1_minimal_path`, Snap.lean); its precondition, that the configuration reaching P₀ is executing, is the occurrence commitment, which DA-1 consumes and does not supply. The inline scope notes in each file document what is and is not Lean-verified. diff --git a/ZeroParadox/Reals/ConnectedNoFirstStep.lean b/ZeroParadox/Reals/ConnectedNoFirstStep.lean new file mode 100644 index 00000000..a1ff51d9 --- /dev/null +++ b/ZeroParadox/Reals/ConnectedNoFirstStep.lean @@ -0,0 +1,118 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): connectedness and the first step on a linear order with its order topology. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Reals.OrderedField +import Mathlib.Topology.Order.IntermediateValue +import Mathlib.Topology.Instances.RatLemmas +import Mathlib.Topology.Instances.Discrete +import Mathlib.Topology.Instances.Real.Lemmas + +set_option maxHeartbeats 400000 + +/-! +# Connectedness and the first step on a linear order with its order topology + +A cover `a ⋖ b` (a first step, `HasFirstStep`) makes `Set.Iio b` and `Set.Ioi a` two disjoint open +sets covering the space, so a preconnected linear order has no first step anywhere. The converse +needs conditional completeness, and ℚ is the control. Standard form: a linearly ordered space is +connected iff it is a linear continuum, densely ordered and Dedekind complete (Steen–Seebach, +*Counterexamples in Topology*); connectedness also forces completeness, which this file does not use. + +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. +-/ + +namespace ZeroParadox + +/-- `Statement:` in a linear order carrying its order topology, preconnected, no point has a first + step. Mathlib's `denselyOrdered_of_preconnectedSpace` is the same fact in `DenselyOrdered` form + (the `example` below); this proof keeps the footprint free of `Classical.choice`. -/ +theorem no_firstStep_of_preconnected {α : Type*} [LinearOrder α] [TopologicalSpace α] + [OrderTopology α] [PreconnectedSpace α] (bot : α) : ¬ HasFirstStep bot := by + rintro ⟨b, h⟩ + obtain ⟨c, hcb, hac⟩ := nonempty_inter (isOpen_Iio' b) (isOpen_Ioi' bot) + (Set.Iio_union_Ioi_of_lt h.1) ⟨bot, h.1⟩ ⟨b, h.1⟩ + exact h.2 hac hcb + +-- `Statement:` Mathlib's route, through `axb1_fails_everywhere_iff_dense`, reaches the same conclusion. +example {α : Type*} [LinearOrder α] [TopologicalSpace α] [OrderTopology α] [PreconnectedSpace α] : + ∀ bot : α, ¬ HasFirstStep bot := + axb1_fails_everywhere_iff_dense.mp denselyOrdered_of_preconnectedSpace + +/-- `Statement:` the contrapositive: a first step at any point makes a linear order with its order + topology not preconnected. -/ +theorem not_preconnected_of_firstStep {α : Type*} [LinearOrder α] [TopologicalSpace α] + [OrderTopology α] {bot : α} (h : HasFirstStep bot) : ¬ PreconnectedSpace α := + fun _ => no_firstStep_of_preconnected bot h + +/-- `Statement:` on a conditionally complete linear order with its order topology, preconnected iff + no point has a first step. The backward direction is Mathlib's `ordered_connected_space`. -/ +theorem preconnected_iff_no_firstStep {α : Type*} [ConditionallyCompleteLinearOrder α] + [TopologicalSpace α] [OrderTopology α] : + PreconnectedSpace α ↔ ∀ bot : α, ¬ HasFirstStep bot := + ⟨fun _ => no_firstStep_of_preconnected, fun h => + haveI : DenselyOrdered α := axb1_fails_everywhere_iff_dense.mpr h + ordered_connected_space⟩ + +-- `Statement:` ℝ is preconnected, so no real has a first step; at `0` this is +-- `axb1_fails_in_ordered_field`, there by density. +example : ∀ x : ℝ, ¬ HasFirstStep x := no_firstStep_of_preconnected + +-- `Statement:` control, completeness carries the backward direction: ℚ has no first step anywhere +-- and is not preconnected (Mathlib's `TotallyDisconnectedSpace ℚ`). +example : (∀ q : ℚ, ¬ HasFirstStep q) ∧ ¬ PreconnectedSpace ℚ := + ⟨axb1_fails_everywhere_iff_dense.mp inferInstance, fun _ => + not_subsingleton ℚ subsingleton_of_preconnected_totallyDisconnected⟩ + +-- `Statement:` control, the discrete side: every integer has a first step, and `0 : Fin 2` has one; +-- neither carrier is preconnected in its order topology. +example : (∀ n : ℤ, HasFirstStep n) ∧ ¬ PreconnectedSpace ℤ := + ⟨fun n => ⟨n + 1, Int.lt_succ n, fun _ h1 h2 => by omega⟩, + not_preconnected_of_firstStep (bot := (0 : ℤ)) ⟨1, by decide, fun _ h1 h2 => by omega⟩⟩ +example : HasFirstStep (0 : Fin 2) ∧ ¬ PreconnectedSpace (Fin 2) := + ⟨⟨1, by decide, fun _ h1 h2 => by omega⟩, + not_preconnected_of_firstStep (bot := (0 : Fin 2)) ⟨1, by decide, fun _ h1 h2 => by omega⟩⟩ + +-- `Statement:` control, a first step at one point leaves the rest of the order dense: on +-- `{0} ∪ [1, 2] ⊆ ℝ`, `0` has a first step and `1` has none; with its order topology the carrier +-- is not preconnected. +example : letI : TopologicalSpace ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ) := Preorder.topology _ + HasFirstStep (⟨0, Or.inl rfl⟩ : ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ)) ∧ + ¬ HasFirstStep (⟨1, Or.inr ⟨le_rfl, by norm_num⟩⟩ : ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ)) ∧ + ¬ PreconnectedSpace ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ) := by + letI : TopologicalSpace ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ) := Preorder.topology _ + haveI : OrderTopology ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ) := ⟨rfl⟩ + have h0 : HasFirstStep (⟨0, Or.inl rfl⟩ : ({0} ∪ Set.Icc (1 : ℝ) 2 : Set ℝ)) := by + refine ⟨⟨1, Or.inr ⟨le_rfl, by norm_num⟩⟩, show (0 : ℝ) < 1 by norm_num, ?_⟩ + rintro ⟨c, hc | hc⟩ h1 h2 + · rw [Set.mem_singleton_iff] at hc; subst hc; exact lt_irrefl _ h1 + · exact absurd (show c < 1 from h2) (not_lt.2 hc.1) + refine ⟨h0, ?_, not_preconnected_of_firstStep h0⟩ + rintro ⟨⟨a, ha | ha⟩, h1, h2⟩ + · rw [Set.mem_singleton_iff] at ha; subst ha + exact absurd (show (1 : ℝ) < 0 from h1) (by norm_num) + · have h1' : (1 : ℝ) < a := h1 + exact h2 (c := ⟨(1 + a) / 2, Or.inr ⟨by linarith, by linarith [ha.2]⟩⟩) + (show (1 : ℝ) < (1 + a) / 2 by linarith) (show (1 + a) / 2 < a by linarith) + +-- `Reading:` the implication runs from topology to order on every linear order with its order +-- topology, and from order to topology only under completeness. On one such carrier a continuous +-- passage (preconnected) and the snap (a first step) exclude each other. This supplies no first step +-- anywhere: AX-B1 stays a commitment. +-- `Reading:` CARRIER. ℚ₂ carries no linear order (`LT ℚ_[2]` does not synthesize, the `#check_failure` in +-- `ZeroParadox/BottomCannotBe.lean` § ROLE), so these hypotheses are not met there; its no-path +-- fact is total disconnectedness (`disconnectedness_forbids_path`, +-- `ZeroParadox/Valuation/BranchingSnapChain.lean`), a different route. + +end ZeroParadox + +section PurityCheck +#print axioms ZeroParadox.no_firstStep_of_preconnected +#print axioms ZeroParadox.not_preconnected_of_firstStep +#print axioms ZeroParadox.preconnected_iff_no_firstStep +-- Mathlib's lemmas cited above: printed, not asserted. +#print axioms denselyOrdered_of_preconnectedSpace +#print axioms ordered_connected_space +end PurityCheck diff --git a/ZeroParadox/Reals/MarkovSpectralGap.lean b/ZeroParadox/Reals/MarkovSpectralGap.lean index 56258fb4..0c12c0f6 100644 --- a/ZeroParadox/Reals/MarkovSpectralGap.lean +++ b/ZeroParadox/Reals/MarkovSpectralGap.lean @@ -92,15 +92,19 @@ lemma tendsto_norm_iterate_zero (f : Fin n → PMF (Fin n)) {v : Fin n → ℝ} /-! ## § II — A concrete mixing chain with a maximal gap -/ +/-- `Statement:` the fair coin on `Fin 2`, the `PMF` giving each of the two outcomes probability `1/2`. -/ +noncomputable def fairCoinFin2 : PMF (Fin 2) := + PMF.ofFintype (fun _ => (2 : ENNReal)⁻¹) (by rw [Fin.sum_univ_two, ENNReal.inv_two_add_inv_two]) + /-- The fully-mixing 2-state kernel: every state maps to the uniform distribution. -/ -noncomputable def fullMix : Fin 2 → PMF (Fin 2) := fun _ => PMF.uniformOfFintype (Fin 2) +noncomputable def fullMix : Fin 2 → PMF (Fin 2) := fun _ => fairCoinFin2 /-- `fullMix` is doubly-stochastic. -/ theorem fullMix_doublyStochastic : DoublyStochastic fullMix := by intro k have hval : ∀ j : Fin 2, ((fullMix j) k).toReal = 1 / 2 := by intro j - simp only [fullMix, PMF.uniformOfFintype_apply, Fintype.card_fin] + simp only [fullMix, fairCoinFin2, PMF.ofFintype_apply, ENNReal.toReal_inv, ENNReal.toReal_ofNat] norm_num simp_rw [hval] norm_num @@ -117,7 +121,7 @@ theorem fullMix_eigen_zero : T fullMix v0 = (0 : ℝ) • v0 := by rw [T_apply, Pi.zero_apply, Fin.sum_univ_two] have hval : ∀ j : Fin 2, ((fullMix j) k).toReal = 1 / 2 := by intro j - simp only [fullMix, PMF.uniformOfFintype_apply, Fintype.card_fin] + simp only [fullMix, fairCoinFin2, PMF.ofFintype_apply, ENNReal.toReal_inv, ENNReal.toReal_ofNat] norm_num rw [hval 0, hval 1] simp [v0] @@ -162,6 +166,7 @@ open ZeroParadox #print axioms iterate_eigen #print axioms tendsto_norm_iterate_zero +#print axioms fairCoinFin2 #print axioms fullMix_doublyStochastic #print axioms fullMix_eigen_zero #print axioms v0_ne_zero diff --git a/ZeroParadox/Reals/OrderedField.lean b/ZeroParadox/Reals/OrderedField.lean index 4f01aebe..fdc44e71 100644 --- a/ZeroParadox/Reals/OrderedField.lean +++ b/ZeroParadox/Reals/OrderedField.lean @@ -74,7 +74,8 @@ section AxB1 **Honest transition note (2026-07-27).** This was first written (2026-07-26) as a bespoke predicate carrying a custom-registry tag that asserted Mathlib had no analog. **That was wrong.** `CovBy` already existed, is stated over the weaker `[LT α]` rather than - `[Preorder α]`, and carries `CovBy.unique_right`, `not_covBy`, and the biconditional below. + `[Preorder α]`, and carries `CovBy.unique_right`, `not_covBy_of_denselyOrdered`, and the + biconditional below. The framework had simply never identified its own one substantive modelling commitment with the standard notion. Recorded here rather than quietly corrected, so that the same unidentified-notion failure is easier to spot if it appears elsewhere. @@ -143,9 +144,8 @@ example {α : Type*} [PartialOrder α] [DecidableEq α] {a b : α} (h : a ⋖ b) example {α : Type*} [PartialOrder α] {a b : α} (h : a ⋖ b) : ∀ c, a ≤ c → c ≤ b → ¬ (c ≠ a ∧ c ≠ b) := fun _ hac hcb ⟨hca, hcb'⟩ => h.2 (lt_of_le_of_ne hac (Ne.symm hca)) (lt_of_le_of_ne hcb hcb') --- `Statement:` Mathlib's homes are `CovBy.Ioo_eq` (nothing strictly between), measured `[propext, --- Quot.sound]`, and `CovBy.Icc_eq` (`Icc a b = {a, b}`), measured `[propext, Classical.choice, --- Quot.sound]`: the second carries `Classical.choice` and the first does not. +-- `Statement:` Mathlib's homes are `CovBy.Ioo_eq` (nothing strictly between) and `CovBy.Icc_eq` +-- (`Icc a b = {a, b}`); their footprints are printed in this file's purity block. -- `Statement:` control, the truth values `Prop` ordered by implication: `False`, ⊥ of `Prop`, is -- covered by `True`, and "every `c` in `[False, True]` is `False` or `True`" is equivalent to excluded -- middle. Prior art: Bauer, "On fixed-point theorems in synthetic computability", Tbilisi Math. J. @@ -289,7 +289,7 @@ theorem f_snap_impossible : ¬∃ ε₀ : F, 0 < ε₀ ∧ ¬∃ δ : F, 0 < δ /-- **AX-B1 FAILS in every ordered field.** Ordered fields are densely ordered in Mathlib (`LinearOrderedSemiField.toDenselyOrdered`), and in a dense order nothing covers anything - (`not_covBy`). So the commitment is refuted pointwise against its own counterexample: what + (`not_covBy_of_denselyOrdered`). So the commitment is refuted pointwise against its own counterexample: what the framework commits to is exactly what the reals do not have. Proved through Mathlib rather than through `f_snap_impossible` — the halving argument above @@ -297,7 +297,7 @@ theorem f_snap_impossible : ¬∃ ε₀ : F, 0 < ε₀ ∧ ¬∃ δ : F, 0 < δ can check without the order-theory library. -/ theorem axb1_fails_in_ordered_field : ¬ HasFirstStep (0 : F) := by rintro ⟨a, hcov⟩ - exact not_covBy hcov + exact not_covBy_of_denselyOrdered hcov end General @@ -407,6 +407,9 @@ section PurityCheck #print axioms r_no_minimal_positive #print axioms r_snap_blocked #print axioms r_snap_impossible +-- Mathlib's covering lemmas cited by the `CovBy` statements above: printed, not asserted. +#print axioms CovBy.Ioo_eq +#print axioms CovBy.Icc_eq end PurityCheck end ZeroParadox diff --git a/ZeroParadox/Settheory/APG.lean b/ZeroParadox/Settheory/APG.lean index 9c19b1c3..e5298ed1 100644 --- a/ZeroParadox/Settheory/APG.lean +++ b/ZeroParadox/Settheory/APG.lean @@ -32,6 +32,8 @@ The hardness of the acyclic proof is that "infinite period" gives you nothing to cardinality is a finite proxy that encodes it as a strictly decreasing natural number. Proving it strictly decreases was where the formalization work lived. +It's the absorption and the pole that allow us to convert that endless descent into a single point. + ## The theorem For any finite APG, any two valid decorations into any DecorationUniverse are equal. @@ -46,7 +48,6 @@ x ∈ x. For a self-loop v → v, the decoration rule d(v) = {d(v)} requires d(v) ∈ d(v) — prohibited. The correct target is a DecorationUniverse: an abstract type with ValuationStructure (which provides scale, val, val_scale) and a collect operation that assembles a parent's value from its children's values. -See: .claude-local/notes/afa_apg_zfset_correction_2026-05-27.md ## Structure @@ -100,7 +101,7 @@ Root and accessibility make the graph an **apg**, a picture of a unique set unde /-- An Accessible Pointed Graph: a Quiver with a distinguished root vertex from which every vertex is reachable via directed paths. -/ --- [ZP-CUSTOM] extends: Mathlib.Combinatorics.Quiver.Basic | reason: Mathlib's Quiver is a bare directed graph (objects + edges) with no distinguished root. APG adds root : V and the accessibility proof (every vertex reachable from root), which is Mathlib's separate class Quiver.RootedConnected root (Mathlib/Combinatorics/Quiver/Arborescence.lean; the two examples below the structure), matching Aczel's definition of Accessible Pointed Graph (1988 p. 4). ⚠ These fields are NOT load-bearing for anything proved in this file, and no claim of necessity should be made for them in either direction: decoration_unique binds the structure as `_G` and never uses it, so what is actually proved holds for EVERY finite quiver, accessible or not — structurally Aczel's own AFA generality (p. 6). No APG value is constructed anywhere in the corpus as of 2026-08-09. +-- [ZP-CUSTOM] extends: Mathlib.Combinatorics.Quiver.Basic | reason: Mathlib's Quiver is a bare directed graph (objects + edges) with no distinguished root. APG adds root : V and the accessibility proof (every vertex reachable from root), which is Mathlib's separate class Quiver.RootedConnected root (Mathlib/Combinatorics/Quiver/Arborescence.lean; the two Quiver.RootedConnected examples below the structure, after its non-member example), matching Aczel's definition of Accessible Pointed Graph (1988 p. 4). ⚠ These fields are NOT load-bearing for anything proved in this file, and no claim of necessity should be made for them in either direction: decoration_unique binds the structure as `_G` and never uses it, so what is actually proved holds for EVERY finite quiver, accessible or not — structurally Aczel's own AFA generality (p. 6). The second Quiver.RootedConnected example constructs an APG from any root carrying Quiver.RootedConnected. structure APG (V : Type*) [Quiver V] where /-- Distinguished vertex. ⚠ Aczel's term for it is the **point**; he introduces *root* only for the special case where every path from it is unique, i.e. a tree (1988 p. 4). The field name is @@ -175,7 +176,7 @@ end APGBasics ZFSet is NOT a valid instance: Foundation forbids x ∈ x, which any cyclic APG requires. OntologicalStates (ZeroParadox/Settheory/OntBridge.lean) has AbstractSelfApp but not ValuationStructure, which this class takes as a binder. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib's ZFSet uses Foundation — x ∈ x is forbidden, making it invalid as a decoration target for any APG with a self-loop. DecorationUniverse is an abstract type with ValuationStructure + a collect operation and two axioms (collect_singleton, collect_val_ge), providing the structure the decoration-uniqueness proof consumes, without importing ZFSet or any axiomatic set theory. ⚠ NOT axiom-free, and every attribution here was isolated by changing ONE constituent: DecorationUniverse reaches Classical.choice by TWO INDEPENDENT routes — its OWN ℕ∞ numeral (the + 1 in collect_val_ge) and the inherited [ValuationStructure U], whose own route is the numeral in val_scale (pinned by the _VSlit/_VScast pair in ZeroParadox/Valuation/Scale.lean). Neither alone accounts for it: with [ValuationStructure U] DELETED and val/scale passed as plain data the class still reports [propext, Classical.choice, Quot.sound]; with [ValuationStructure U] also deleted, respelling its own numeral as ((1 : ℕ) : ℕ∞) makes it report no axioms; respelling only that numeral with the real binders kept leaves it tainted. decoration_unique carries the same three IN ITS STATEMENT — forall {U} [ZPSemilattice U] [ValuationStructure U], True already reports them while the same with [ZPSemilattice U] alone reports none — so the [ValuationStructure U] binder suffices by itself and the cost is NOT REMOVABLE BY ANY PROOF of that theorem. Its proof additionally CALLS Nonempty.some (fun h => Classical.choice h) and reaches choice via Set.ncard_pos and Set.ncard_lt_ncard, further routes to a cost the TYPE already incurred. Provenance and necessity are independent axes (ZeroParadox/AxiomProfile.lean § 0). ⚠ "Minimum" is unproved: the NO-GO gauge below shows this class is inhabited over EVERY ValuationStructure carrier. +-- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib's ZFSet carries Foundation (ZFSet.mem_wf) — x ∈ x is forbidden, making it invalid as a decoration target for any APG with a self-loop. DecorationUniverse is an abstract type with ValuationStructure + a collect operation and two axioms (collect_singleton, collect_val_ge), providing the structure the decoration-uniqueness proof consumes, without importing ZFSet or any axiomatic set theory. ⚠ The class and its [ValuationStructure U] binder measure no axioms (this file's PurityCheck; ZeroParadox/Valuation/Scale.lean's). decoration_unique measures [propext, Classical.choice, Quot.sound], and under the instances the pinned Mathlib supplies its STATEMENT carries them through the [Fintype V] binder: Fintype measures the three (PurityCheck below), and in statement controls measured 2026-11-07 the full statement reports them, the same statement with [Finite V] in place of [Fintype V] reports none, and forall {U} [ZPSemilattice U] [ValuationStructure U], True reports none. So no proof of decoration_unique as stated can drop them, and the bin is relative to those instances (ZeroParadox/Category/ChoiceCannotBe.lean § III, STATEMENT-CARRIED IS INSTANCE-RELATIVE). Its proof term also names Nonempty.some, Classical.propDecidable (the by_cases on HasSelfCycle u), Set.ncard_pos, Set.ncard_lt_ncard and cyclic_decoration_eq_bot, each measuring Classical.choice (2026-11-07). The [Finite V] restatement has a choice-free proof, decoration_unique_finite, from decoration_unique_of_val, which binds no finiteness at all (§ IX; footprints in PurityCheck below). Provenance and necessity are independent axes (ZeroParadox/AxiomProfile.lean § 0). ⚠ "Minimum" is unproved: the NO-GO gauge below shows this class is inhabited over EVERY ValuationStructure carrier. class DecorationUniverse (U : Type*) [ZPSemilattice U] [ValuationStructure U] where /-- A map `Set U → U`. ⚠ The two axioms below pin only the SINGLETON case and a lower bound; they do not require it to assemble a parent's value from its children's. -/ @@ -612,37 +613,42 @@ theorem acyclic_induction_step /-! ## § IX. Global Decoration Uniqueness - Proved directly by strong induction on |{w | Path u w}| (reachable set cardinality). - No SCC decomposition needed — the valuation argument handles cyclic vertices directly: - - - Cyclic u: d₁ u = ⊥ = d₂ u by cyclic_decoration_eq_bot - - Acyclic u: for each child w, reach w ⊊ reach u (since v ∉ reach w by acyclicity), - so IH gives d₁ w = d₂ w for all apg_children, and acyclic_induction_step closes the goal. + Two proofs, one per chart (the `Reading:` on `decoration_unique_of_val`): - Requires [Fintype V] to bound the reachable set cardinality. -/ + - `decoration_unique`, graph side, `[Fintype V]`: strong induction on |{w | Path u w}|. A cyclic + u goes to ⊥ of `U` (`cyclic_decoration_eq_bot`); for an acyclic u each child's reachable set + is strictly smaller, which `[Fintype V]` bounds, and `acyclic_induction_step` closes the goal. + - `decoration_unique_of_val`, value side, any quiver: strong induction on the finite valuation + of the TARGET value; valuation ⊤ is forced to ⊥ of `U` by `val_unique`. -/ /-! ### PRIOR ART — the uniqueness clause of a RECURSIVE COALGEBRA, for ONE SHAPE of algebra. A coalgebra is **recursive** when *every* algebra admits a unique coalgebra-to-algebra morphism (Adámek-Milius-Moss 2020, arXiv:1910.09401v2, Def 3.2 p. 11, crediting Osius for the definition). -`decoration_unique` gives that clause for algebras of the `DecorationUniverse.collect` shape, not -for every algebra, and existence not at all. `ZeroParadox/Category/WellFoundedCoalgebra.lean` has -the well-foundedness side. **The delta:** the standard route to such uniqueness is well-foundedness -(Taylor's General Recursion Theorem, AMM Thm 7.2 p. 27), unavailable here since these quivers may -carry cycles. It closes on two branches instead — cyclic vertices to ⊥ (`cyclic_decoration_eq_bot`), -acyclic ones by strict-subset descent on the reachable set, which is what `[Fintype V]` is for. -/ +`decoration_unique` gives that clause for algebras of the `DecorationUniverse.collect` shape only, +and existence not at all. Well-foundedness of the GRAPH (Taylor's General Recursion Theorem, AMM +Thm 7.2 p. 27; `ZeroParadox/Category/WellFoundedCoalgebra.lean`) is unavailable, as these quivers +may carry cycles. `decoration_unique_of_val` inducts on the TARGET's rank instead: the AFA2 half of +"the foundation axiom implies AFA2 and the negation of AFA1" (Aczel, *Non-Well-Founded Sets*, CSLI +1988, Ex. 2.1 p. 20; AFA1/AFA2 p. 19), with one rank-⊤ point, ⊥ of `U`, admitted via `val_unique`. -/ -- Statement: `IsDecoration d` is the coalgebra-to-algebra equation `d = collect ∘ (d '' ·) ∘ apg_children`. -- Reading: read from the TARGET, `decoration_unique` is then CRA-uniqueness for the algebra `collect` -- (Capretta-Uustalu-Vene, *Corecursive Algebras*, SBMF 2009, LNCS 5902, Def. 1 p. 86), from the --- coalgebras `apg_children` of finite APGs only. +-- coalgebras `apg_children` of finite APGs; the `example` after `decoration_unique` drops the `APG` +-- argument and gives the same uniqueness for every finite quiver, `decoration_unique_of_val` for +-- every quiver. Also near: Urabe, Hara and Hasuo, +-- *Categorical Liveness Checking by Corecursive Algebras* (arXiv:1704.04872), use a corecursive algebra +-- "as a classifier for (non-)well-foundedness" (abstract) in their ranking domains (Def. III.10, +-- p. 7), classically ranking functions into ℕ ∪ {∞} (p. 1); here a cyclic vertex gets valuation ⊤ +-- (`cyclic_decoration_eq_bot` with `ValuationStructure.val_bot`; the `example` directly after `cyclic_decoration_eq_bot` states both). example {V : Type*} [Quiver V] {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] (d : V → U) : IsDecoration d ↔ d = fun v => DecorationUniverse.collect (d '' apg_children v) := ⟨fun h => funext h, fun h v => congrFun h v⟩ --- `[Fintype V]` is not used in the *type* but is essential to the *proof*: it bounds the --- reachable-set cardinality so the strict-subset descent (`Set.ncard_lt_ncard`) terminates. +-- `[Fintype V]` is not used in the *type*; THIS proof spends it bounding the reachable-set +-- cardinality for `Set.ncard_lt_ncard`. Uniqueness needs no finiteness: `decoration_unique_of_val`. set_option linter.unusedFintypeInType false in /-- Global decoration uniqueness: any two valid decorations of a finite APG are equal. -/ theorem decoration_unique @@ -687,6 +693,113 @@ theorem decoration_unique have hlt := Set.ncard_lt_ncard hstrict omega +-- Statement: the same uniqueness holds for EVERY finite quiver, with no `APG` argument: the proof of +-- `decoration_unique`, which never reads its `APG`, run without one. +-- Reading: the uniqueness half (not existence) of a "finitary corecursive" algebra, unique solutions +-- for coalgebras on finitely presentable objects (Adámek, Haddadi and Milius, LMCS 10(3:19), 2014, +-- arXiv:1407.4425, Def. 8.1(a), p. 40). +example {V : Type*} [Quiver V] [Fintype V] + {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (d₁ d₂ : V → U) (hd₁ : IsDecoration d₁) (hd₂ : IsDecoration d₂) : d₁ = d₂ := by + funext v + suffices key : ∀ n : ℕ, ∀ u : V, + ({x : V | Nonempty (Quiver.Path u x)}).ncard ≤ n → d₁ u = d₂ u from key _ v le_rfl + intro n + induction n with + | zero => + intro u hcard + have hpos : 0 < ({x : V | Nonempty (Quiver.Path u x)}).ncard := by + rw [Set.ncard_pos]; exact ⟨u, ⟨Quiver.Path.nil⟩⟩ + omega + | succ n ih => + intro u hcard + by_cases hcyc : HasSelfCycle u + · rw [cyclic_decoration_eq_bot d₁ hd₁ u hcyc, cyclic_decoration_eq_bot d₂ hd₂ u hcyc] + · apply acyclic_induction_step d₁ d₂ hd₁ hd₂ u + intro w hw + simp only [apg_children, Set.mem_setOf_eq] at hw + apply ih w + have hv_in : u ∈ {x : V | Nonempty (Quiver.Path u x)} := ⟨Quiver.Path.nil⟩ + have hv_not : u ∉ {x : V | Nonempty (Quiver.Path w x)} := fun ⟨p⟩ => hcyc ⟨w, hw, ⟨p⟩⟩ + have hstrict : {x : V | Nonempty (Quiver.Path w x)} ⊂ {x : V | Nonempty (Quiver.Path u x)} := + ⟨fun _ ⟨p⟩ => ⟨(Quiver.Path.nil.cons hw.some).comp p⟩, fun hsub => hv_not (hsub hv_in)⟩ + have hlt := Set.ncard_lt_ncard hstrict + omega + +/-- `Statement:` in ℕ∞, `m ≥ x + 1` for a natural `m` gives a natural `k < m` with `x = k`. + By cases on Mathlib's inductive `WithTop.LE`, with no order lemma (`WithTop`'s order + instances: `ZeroParadox/Category/ChoiceCannotBe.lean` § III). -/ +theorem enat_lt_of_add_one_le {m : ℕ} {x : ℕ∞} (h : (m : ℕ∞) ≥ x + 1) : + ∃ k : ℕ, x = (k : ℕ∞) ∧ k < m := by + rcases x with _ | k + · have h' : WithTop.LE (none : WithTop ℕ) (some m) := h + cases h' + · have h' : WithTop.LE (some (k + 1) : WithTop ℕ) (some m) := h + cases h' with + | coe_le_coe hab => exact ⟨k, rfl, hab⟩ + +/-- `Statement:` two decorations of any quiver agree at every vertex where the first one's value + has a finite valuation `m`; strong induction on `m`, each child's valuation strictly smaller + by `collect_val_ge`. -/ +theorem decoration_agree_of_val_coe + {V : Type*} [Quiver V] + {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (d₁ d₂ : V → U) (hd₁ : IsDecoration d₁) (hd₂ : IsDecoration d₂) : + ∀ m : ℕ, ∀ u : V, ValuationStructure.val (d₁ u) = (m : ℕ∞) → d₁ u = d₂ u := by + intro m + induction m using Nat.strongRecOn with + | ind m ih => + intro u hu + apply acyclic_induction_step d₁ d₂ hd₁ hd₂ u + intro w hw + have hmem : d₁ w ∈ d₁ '' apg_children u := ⟨w, hw, rfl⟩ + have hge := DecorationUniverse.collect_val_ge (d₁ '' apg_children u) (d₁ w) hmem + rw [← hd₁ u, hu] at hge + obtain ⟨k, hk, hlt⟩ := enat_lt_of_add_one_le hge + exact ih k hlt w hk + +/-- `Statement:` on EVERY quiver, finite or not, any two decorations into a `DecorationUniverse` + are equal; no `APG` argument and no finiteness binder. + `Reading:` CARRIER, one uniqueness in two charts, neither of them the structure. The graph side splits + vertices acyclic/cyclic (`decoration_unique`); the value side, this proof, splits the valuation + finite/⊤, and `val_unique` sends ⊤ to ⊥ of `U`. `collect_val_ge` and `val_unique` relate them, + one way: a cyclic vertex's valuation is ⊤ (`cyclic_decoration_eq_bot`); no converse is claimed. -/ +theorem decoration_unique_of_val + {V : Type*} [Quiver V] + {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (d₁ d₂ : V → U) (hd₁ : IsDecoration d₁) (hd₂ : IsDecoration d₂) : + d₁ = d₂ := by + funext u + rcases h₁ : ValuationStructure.val (d₁ u) with _ | m + · rcases h₂ : ValuationStructure.val (d₂ u) with _ | n + · rw [ValuationStructure.val_unique _ h₁, ValuationStructure.val_unique _ h₂] + · exact (decoration_agree_of_val_coe d₂ d₁ hd₂ hd₁ n u h₂).symm + · exact decoration_agree_of_val_coe d₁ d₂ hd₁ hd₂ m u h₁ + +-- Statement: it applies on an infinite quiver: ℕ with one edge n ⟶ n + 1. +example {U : Type} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (d₁ d₂ : ℕ → U) (hd₁ : @IsDecoration ℕ ⟨fun a b => PLift (b = a + 1)⟩ U _ _ _ d₁) + (hd₂ : @IsDecoration ℕ ⟨fun a b => PLift (b = a + 1)⟩ U _ _ _ d₂) : d₁ = d₂ := + @decoration_unique_of_val ℕ ⟨fun a b => PLift (b = a + 1)⟩ U _ _ _ d₁ d₂ hd₁ hd₂ + +set_option linter.unusedFintypeInType false in +/-- `Statement:` `decoration_unique` with `[Finite V]` in place of `[Fintype V]`, the restatement + `ZeroParadox/Category/ChoiceCannotBe.md` asks of a STATEMENT-CARRIED theorem. -/ +theorem decoration_unique_finite + {V : Type*} [Quiver V] [Finite V] + {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (_G : APG V) (d₁ d₂ : V → U) (hd₁ : IsDecoration d₁) (hd₂ : IsDecoration d₂) : + d₁ = d₂ := + decoration_unique_of_val d₁ d₂ hd₁ hd₂ + +-- Statement: `decoration_unique`'s statement, `[Fintype V]` included, is a special case of +-- `decoration_unique_of_val`; its footprint stays the statement's (PurityCheck). +set_option linter.unusedFintypeInType false in +example {V : Type*} [Quiver V] [Fintype V] + {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U] + (_G : APG V) (d₁ d₂ : V → U) (hd₁ : IsDecoration d₁) (hd₂ : IsDecoration d₂) : d₁ = d₂ := + decoration_unique_of_val d₁ d₂ hd₁ hd₂ + end ZeroParadox /-! ## Axiom Purity Check -/ @@ -710,5 +823,12 @@ open ZeroParadox #print axioms cyclic_decoration_eq_bot #print axioms path_decoration_eq_bot #print axioms decoration_unique +#print axioms enat_lt_of_add_one_le +#print axioms decoration_agree_of_val_coe +#print axioms decoration_unique_of_val +#print axioms decoration_unique_finite +-- The class, and the `[Fintype V]` binder of `decoration_unique` (the custom-registry line above the class). +#print axioms DecorationUniverse +#print axioms Fintype end PurityCheck diff --git a/ZeroParadox/Settheory/Coalgebra.lean b/ZeroParadox/Settheory/Coalgebra.lean index 4de2463c..bc6411df 100644 --- a/ZeroParadox/Settheory/Coalgebra.lean +++ b/ZeroParadox/Settheory/Coalgebra.lean @@ -1,5 +1,6 @@ import Mathlib.Data.QPF.Univariate.Basic import ZeroParadox.Settheory.FixedPointFork +import ZeroParadox.Die /-! # ZP-P instance: the categorical parent (initial algebra vs final coalgebra) @@ -26,10 +27,16 @@ fork is exactly the self-referential element that ν admits and μ forbids — t ZFC+Foundation (no ⊥={⊥}) vs ZFC+AFA (⊥={⊥}) (set theory: ZP-J). **FENCE.** This is the genuine μ/ν instance of the schema (unlike the Ostrowski number-system instance, -which is theorem-backed but not a μ/ν instance). What is claimed here is exactly the two Lean theorems -below: `Fix` empty, `Cofix` inhabited, for this functor. The identification of this categorical contact -point with the diagonal fixed point of the other layers is the cross-instance identity — a modeling -commitment, not a theorem (ZP-P hard fence). +which is theorem-backed but not a μ/ν instance). For this functor the least fixed point is empty and the +greatest is inhabited (`categorical_fork_strict`), with exactly one point (`cofixSelf` for existence, +`cofix_subsingleton` for at most one). In die terms that point occupies the Quine-atom role, a point that +steps to itself and to nothing else (`Motion.SelfOnlyAt`, `cofix_quine_role_occupied`); because the chart +has a single point, that occupancy restates the fork and adds no further content. The same role is +unoccupied in the well-founded set chart (`zfset_quine_role_unoccupied`, +`ZeroParadox/Settheory/Wall.lean`). The diagonal fixed points of the other layers are each stated as +occupants of the role in their own chart (indexed in `ZeroParadox/DieCannotBe.lean` § XV); no equation +across charts is stated (one would be ill-typed) and none is committed to. What relates the charts is the +one role each chart is measured against, which is the die's definition, not an identity (ZP-P hard fence). ## Status @@ -39,14 +46,8 @@ M-type / corecursion machinery. **That choice sits in `QPF.Cofix` itself** (meas type reports `[propext, Classical.choice, Quot.sound]`), so it is not removable by any proof of this statement — but it IS attributable to the QPF quotient layer rather than to the mathematics, because `PFunctor.M`'s former and constructors are axiom-free (its DESTRUCTOR is not) and -`strict_cofix_nonempty` proves the same inhabitation over it with no -axioms. Ahrens et al. agree from the other side: for a polynomial -functor the final coalgebra is constructible choice-free (their construction needs -only function extensionality, which Lean has; only their uniqueness half uses univalence, see -`ZeroParadox/Computability/ChoicePurityInvariant.lean`. Veltri is CONTRAST, not support: for the -non-polynomial finite-powerset functor his results run the other way — certain constructions -there are obtained ASSUMING choice principles rather than shown to need them, and his own -preferred coinductive construction needs neither choice nor LLPO). See PurityCheck. +`strict_cofix_nonempty` proves the same inhabitation over it with no axioms. Prior art (Ahrens et al.; +Veltri as contrast): the PurityCheck note below and `ZeroParadox/Computability/ChoicePurityInvariant.md`. -/ namespace ZeroParadox @@ -87,6 +88,57 @@ theorem categorical_fork_strict : IsEmpty (Fix idPF_Coalgebra.Obj) ∧ Nonempty (Cofix idPF_Coalgebra.Obj) := ⟨fix_isEmpty, cofix_nonempty⟩ +/-! ### The Quine-atom role in the die +Beside the FENCE above: in the die (`ZeroParadox/Die.lean`) the Quine atom is a ROLE, `Motion.SelfOnlyAt` +(a point stepping to itself and to nothing else). `Reading:` CARRIER — of two charts, the one in this file +occupies it (`cofix_quine_role_occupied`) and `ZFSet`, whose chart is in `ZeroParadox/Settheory/Wall.lean`, +provably does not (`zfset_quine_role_unoccupied`). No equation is stated across them: an equation between a +`Cofix idPF_Coalgebra.Obj` point and a `ZFSet` is ill-typed. This chart has one point (`cofixSelf` exists, +and `cofix_subsingleton` allows at most one). Rutten's example is the identity functor on sets, whose final +system is a one-element set (TCS 249 (2000), Example 10.2(1), p. 44); `idPF_Coalgebra.Obj` is isomorphic +to that functor (`idPF_Coalgebra.Obj α ≅ α`). So this chart's occupancy is the one-node loop and carries no +contrast inside the chart; the contrast it carries is `categorical_fork_strict`. -/ + +/-- `Statement:` the element `cofix_nonempty` builds: the corecursion from the one-point coalgebra. -/ +noncomputable def cofixSelf : Cofix idPF_Coalgebra.Obj := + Cofix.corec (fun _ : PUnit => (⟨PUnit.unit, fun _ => PUnit.unit⟩ : idPF_Coalgebra.Obj PUnit)) PUnit.unit + +/-- `Statement:` `Cofix.dest cofixSelf` is the one-slot node whose only child is `cofixSelf`. -/ +theorem dest_cofixSelf : + Cofix.dest cofixSelf = (⟨PUnit.unit, fun _ => cofixSelf⟩ : idPF_Coalgebra.Obj _) := by + rw [cofixSelf, Cofix.dest_corec]; rfl + +/-- `Statement:` in the die motion on `Cofix idPF_Coalgebra.Obj` with UP the identity and OVER + `x ⟶ y` when `y` is a child of `x` under `Cofix.dest`, `cofixSelf` steps to itself and to nothing + else (`Motion.SelfOnlyAt`). -/ +theorem cofixSelf_selfOnlyAt : + (Motion.ofTotal (id : Cofix idPF_Coalgebra.Obj → _) (fun _ => rfl) + (fun x y => ∃ b, (Cofix.dest x).2 b = y)).SelfOnlyAt cofixSelf := by + refine ⟨⟨PUnit.unit, by rw [dest_cofixSelf]⟩, fun b ⟨i, hi⟩ => ?_⟩ + rw [dest_cofixSelf] at hi + exact hi.symm + +/-- `Statement:` so in that motion some point steps to itself and to nothing else. -/ +theorem cofix_quine_role_occupied : + ∃ x, (Motion.ofTotal (id : Cofix idPF_Coalgebra.Obj → _) (fun _ => rfl) + (fun x y => ∃ b, (Cofix.dest x).2 b = y)).SelfOnlyAt x := + ⟨cofixSelf, cofixSelf_selfOnlyAt⟩ + +/-- `Statement:` `Cofix idPF_Coalgebra.Obj` has at most one point (bisimulation by the + always-true relation). The same argument over `PFunctor.M idPF_Coalgebra` is the `heq` step of + the leaf-free M-type `example` in `ZeroParadox/DieCannotBe.lean` § XI. -/ +theorem cofix_subsingleton : ∀ x y : Cofix idPF_Coalgebra.Obj, x = y := by + intro x y + apply Cofix.bisim_rel (fun _ _ => True) _ x y trivial + intro a b _ + rcases ha : Cofix.dest a with ⟨u, f⟩ + rcases hb : Cofix.dest b with ⟨v, g⟩ + cases u; cases v + show (⟨PUnit.unit, Quot.mk _ ∘ f⟩ : idPF_Coalgebra.Obj _) = ⟨PUnit.unit, Quot.mk _ ∘ g⟩ + congr 1 + funext i + exact Quot.sound trivial + /-! ## Engineer's Take These files sit at the boundary of where choice lives within the framework. There is a distinct boundary @@ -135,7 +187,7 @@ section PurityCheck -- only at their uniqueness result; Lean has funext). For Lean's Axiom-K setting the closer -- citation is **Altenkirch–Ghani–Hancock–McBride–Morris, *Indexed Containers* (JFP 25, 2015)**, -- which ACS themselves point at (§1.1) and generalize "to the whole of HoTT". **The full --- three-way setting comparison is in `ZeroParadox/Computability/ChoicePurityInvariant.lean` — +-- three-way setting comparison is in `ZeroParadox/Computability/ChoicePurityInvariant.md` — -- read it there, not here.** In the finite-powerset case — the non-polynomial one — the literature -- pins each presentation: full AC for the set-quotient, countable choice together with LLPO for -- Worrell's limit. The CHOICE half is a fact about those constructions, not a necessity: two of @@ -146,6 +198,11 @@ section PurityCheck #print axioms fix_isEmpty #print axioms cofix_nonempty #print axioms categorical_fork_strict +#print axioms cofixSelf +#print axioms dest_cofixSelf +#print axioms cofixSelf_selfOnlyAt +#print axioms cofix_quine_role_occupied +#print axioms cofix_subsingleton /- **M3 metric — the fork choice discriminator (lake build, 2026-06-27).** The per-side footprint is a genuine SPLIT, and that split is the measured invariant of the fork: the μ (initial-algebra, diff --git a/ZeroParadox/Settheory/Curry.md b/ZeroParadox/Settheory/Curry.md index d7098373..e946d4e5 100644 --- a/ZeroParadox/Settheory/Curry.md +++ b/ZeroParadox/Settheory/Curry.md @@ -21,11 +21,21 @@ comprehension / a reflexive object is inconsistent (the type-level cousin is `re ## Placement Curry is a **wall / μ** face — self-reference that cannot be internalized — and the most violent form: -not "no truth value" but "every value at once". Its floor dual is again the Quine atom (ν), where -self-reference closes harmlessly instead of exploding. +not "no truth value" but "every value at once". Its floor dual (ν) is the Quine-atom role in the +die, `SelfOnlyAt`, a point stepping to itself and to nothing else: occupied in the coalgebra chart +(`cofix_quine_role_occupied`, `ZeroParadox/Settheory/Coalgebra.lean`; a one-point chart: `cofixSelf` +exists and `cofix_subsingleton` allows at most one), where self-reference closes without exploding, and unoccupied in `ZFSet` (`zfset_quine_role_unoccupied`, +`ZeroParadox/Settheory/Wall.lean`). ## Honest delta `curry_paradox` is a real generalization of the repo's engine (arbitrary conclusion `C`); -`curry_from_naming` routes it through the existing Lawvere naming. Attribution: Curry (1942); the -diagonal-family framing is Lawvere (1969), via Yanofsky (2003) § 1 p. 1. Axiom-free. +`curry_from_naming` routes it through the existing Lawvere naming. Attribution: conventionally credited to Curry (1942; not consulted here). In the +diagonal family, Yanofsky (2003, arXiv:math/0305282v1, p. 18) applies the diagonalization lemma to get, +for an arbitrary sentence A, a sentence C with ⊢ C ↔ (C ⇒ A); with his C read as `p` and his A as +`C`, that has the shape of `curry_paradox`'s hypothesis `p ↔ (p → C)`, and he derives A from it. He names it "Löb's Paradox" and remarks that it +"is related to Curry's paradox", the only mention of Curry in that copy (text search, 2026-11-01). +Lawvere (1969) treats Cantor, Russell, Tarski and an incompleteness theorem; Curry was not located in our +copy of his paper (text search of the TAC reprint, 2026-11-01). The four declarations of +`ZeroParadox/Settheory/Curry.lean` (`curry_paradox`, `liar_is_curry_at_false`, `curry_from_naming`, +`curry_no_bottom`) are axiom-free. diff --git a/ZeroParadox/Settheory/FixedPointFork.lean b/ZeroParadox/Settheory/FixedPointFork.lean index 09c49680..d2f0c7f9 100644 --- a/ZeroParadox/Settheory/FixedPointFork.lean +++ b/ZeroParadox/Settheory/FixedPointFork.lean @@ -33,15 +33,15 @@ qualification to live in **Set**; stated unqualified it is loose.) 2. **Instance catalog (other layers — referenced, not re-proved here):** set theory (ZP-J/K, AbstractSelfApp / Quine atom), number systems (ZP-B/F, ℝ vs ℚ₂ via Ostrowski), the categorical parent (W-types vs M-types, `QPF.Fix` vs `QPF.Cofix`). -3. **Unification (prose conjecture, FENCED — never a Lean claim):** that the contact points of all - instances are faces of *one* object (the diagonal fixed point). This is a type boundary, not a - missing proof: `x = y` across distinct categories is not a well-formed proposition. +3. **Unification (a role, never an identity):** the contact points share a ROLE defined in the die + (`ZeroParadox/Die.lean`; the Quine atom's is `Motion.SelfOnlyAt`), each chart occupied or provably + empty by theorem (`ZeroParadox/DieCannotBe.lean` § XV). `x = y` across categories is ill-formed. ## Fences -- **Hard fence (permanent):** cross-instance identity ("the contact points are one object") is not a - theorem and cannot be — it is a definitional/modeling commitment. Each framework forks at *its own* - contact point; that is all that is claimed formally. +- **Hard fence (permanent):** no equation across instances is stated or committed to (it is ill-typed); + the instances are measured against one die role, not an identity. Each framework forks at *its own* contact point; + that is all that is claimed formally. - **Soft fence (conjecture):** that *every* domain fork is an instance of this μ/ν schema. The schema is a theorem here and for canonical functors; "every fork is μ/ν" is the open generalization. (The Ostrowski / ℝ-vs-ℚ₂ instance, in particular, is theorem-backed on its own @@ -51,7 +51,7 @@ Per-instance forks are theorems and are not hedged. ## Status -PROVED. Four theorems, no `sorry`; choice-free (`[propext, Quot.sound]` only — see PurityCheck). +PROVED. Four theorems, no `sorry`; choice-free (at most `[propext, Quot.sound]` — see PurityCheck). -/ namespace ZeroParadox @@ -105,7 +105,7 @@ This file is the framework side of that boundary: the abstract fork over a compl -/ section PurityCheck --- All four report `[propext, Quot.sound]` only — NO `Classical.choice`. The fork schema spine is +-- Three report `[propext, Quot.sound]` and `unique_of_collapse` `[propext]` — NO `Classical.choice`. The fork schema spine is -- choice-free. (propext = propositional extensionality, Quot.sound = quotient soundness; both are -- Lean axioms used throughout Mathlib, not the Axiom of Choice.) Consistent with the choice-free core: -- see ZeroParadox/AxiomProfile.lean. diff --git a/ZeroParadox/Settheory/ForkFrameChange.lean b/ZeroParadox/Settheory/ForkFrameChange.lean index 6fcab197..23b7ce1d 100644 --- a/ZeroParadox/Settheory/ForkFrameChange.lean +++ b/ZeroParadox/Settheory/ForkFrameChange.lean @@ -48,8 +48,15 @@ theorem gfp_dual_eq_lfp : (OrderHom.dual f).gfp = f.lfp := rfl matches its statement: duality genuinely does exchange the fork's two ends. The other two overclaim and carry corrections in their own docstrings — `snap_is_frameflip` proves the tower limit's two chart-readings (**no snap appears in it**), and `catseam_is_frameflip` proves the seam is a **fixed - point** of the flip, not a flip. **What all three establish is the exchange of the two poles and the - point where they coincide. That the snap IS an instance of that exchange is ZP-Q's conjecture, not + point** of the flip, not a flip. **Taken together, the three establish the exchange of the two poles + and the point where they coincide; `catseam_is_frameflip` gives both, this theorem gives the + exchange and the condition under which the two closures coincide ((iii), `fork_collapse_iff`), and + `snap_is_frameflip` gives only the exchange.** `Statement:` **INVERSION** — the exchange: (i)-(ii) + here, `catseam_is_frameflip` (iii)-(iv) (`op` swaps initial and terminal), and `snap_is_frameflip`'s + `rInv` swap of `0` and `∞`. `Statement:` **COINCIDENCE** — the condition for it, (iii) here + (`fork_collapse_iff`), and a coincidence point in `catseam_is_frameflip` (i)-(ii), the + seam initial and terminal at once; on the valuation side the + coincidence witness is `infinitude_forces_infinite_complexity`. **That the snap IS an instance of that exchange is ZP-Q's conjecture, not established by these theorems.** The snap is one covering step off the zero face (`bot ⋖ a`, AX-B1), a separate object and a commitment. The cross-domain claim that the snap *is* the frame change remains this layer's open conjecture, as its file header states. diff --git a/ZeroParadox/Settheory/ForkFrameChange.md b/ZeroParadox/Settheory/ForkFrameChange.md index 02594254..60aac690 100644 --- a/ZeroParadox/Settheory/ForkFrameChange.md +++ b/ZeroParadox/Settheory/ForkFrameChange.md @@ -16,6 +16,8 @@ the diagonal fixed point. `Statement:` INVERSION and COINCIDENCE, bundled (`fork_is_frameflip`). `Reading:` INVERSION, conjectural: that the valuation and category frame-flips share its exchange; the category face also proves the COINCIDENCE (`catseam_is_frameflip`). +`Statement:` the category face proves the COINCIDENCE (`catseam_is_frameflip`: the seam is initial and terminal); the valuation +face's coincidence witness is `infinitude_forces_infinite_complexity`. "Its exchange" is `fork_is_frameflip`'s order-duality swap. `fork_is_frameflip` bundles both faces: the duality-swap (P2) with `fork_collapse_iff` (P1). This is the order-theoretic universal `fork_is_frameflip` — the domain-independent shape that the valuation (`snap_is_frameflip`) and category (`catseam_is_frameflip`) faces are read as sharing (conjectural; see the diff --git a/ZeroParadox/Settheory/GraphBisim.lean b/ZeroParadox/Settheory/GraphBisim.lean index 23707ff4..48b21531 100644 --- a/ZeroParadox/Settheory/GraphBisim.lean +++ b/ZeroParadox/Settheory/GraphBisim.lean @@ -114,10 +114,11 @@ Adámek–Milius–Moss 2020 (arXiv:1910.09401) Def 5.1 and Construction 5.2, p. power-set coalgebras (Ex 2.1(1), p. 4) and their next-time operator (Ex 4.2(1), p. 15). Theirs keeps a subcoalgebra of nodes; this keeps every node and drops arrows. Their Prop 5.5, p. 23 (coreflection) is the categorical neighbour of `wfPart_same`. No graph-level statement of -`wfPart_same` was located as of 2026-10-20 (Aczel 1988, AMM 2020, Barwise–Moss 1991, Taylor -*Well founded coalgebras and recursion*, Rutten *Universal coalgebra* 2000, Rutten–Turi *On the -Foundations of Final Semantics: Non-Standard Sets, Metric Spaces, Partial Orders* 1993; -theoremsearch, three phrasings). -/ +`wfPart_same` was located as of 2026-10-20 (Aczel 1988, AMM 2020, Barwise–Moss 1991, Taylor *Well +founded coalgebras and recursion*, Rutten *Universal coalgebra* 2000, Rutten–Turi *On the Foundations +of Final Semantics: Non-Standard Sets, Metric Spaces, Partial Orders* 1993; theoremsearch, three +phrasings), nor on 2026-11-03 in Barwise–Moss 1996 (*Vicious Circles*; its index and pp. 24, 348 +read: the well-founded part of a relation, p. 24, and Answer 9.7, p. 348, are neighbours only). -/ /-- `Statement:` the converse of a bisimulation is a bisimulation. -/ theorem isBisim_flip {A : MemGraph m} {B : MemGraph n} {R : Fin m → Fin n → Prop} diff --git a/ZeroParadox/Settheory/HypersetOrder.lean b/ZeroParadox/Settheory/HypersetOrder.lean index 79225030..9ee50b7b 100644 --- a/ZeroParadox/Settheory/HypersetOrder.lean +++ b/ZeroParadox/Settheory/HypersetOrder.lean @@ -617,9 +617,9 @@ theorem forcedTop_iff_reaches_cycle (G : MemGraph n) (a : Fin n) : rw [forcedTop_iff_not_acc, Motion.not_acc_iff_reaches_cycle] constructor · rintro ⟨c, h1, h2⟩ - exact ⟨c, Relation.ReflTransGen.swap h1, Relation.TransGen.swap h2⟩ + exact ⟨c, Relation.ReflTransGen.swap _ _ h1, Relation.TransGen.swap _ _ h2⟩ · rintro ⟨c, h1, h2⟩ - exact ⟨c, Relation.ReflTransGen.swap h1, Relation.TransGen.swap h2⟩ + exact ⟨c, Relation.ReflTransGen.swap _ _ h1, Relation.TransGen.swap _ _ h2⟩ /-- `Statement:` if a bisimulation relates `a` and `b`, `ForcedTop A a ↔ ForcedTop B b`. -/ theorem forcedTop_bisim {A : MemGraph m} {B : MemGraph n} {R : Fin m → Fin n → Prop} diff --git a/ZeroParadox/Settheory/LawvereBridge.lean b/ZeroParadox/Settheory/LawvereBridge.lean index 557812e2..4e67ff48 100644 --- a/ZeroParadox/Settheory/LawvereBridge.lean +++ b/ZeroParadox/Settheory/LawvereBridge.lean @@ -65,12 +65,13 @@ theorem existence_without_uniqueness [Nontrivial L] : obtain ⟨a, b, hab⟩ := exists_pair_ne L exact hab ((hx a rfl).trans (hx b rfl).symm) -/-! ## § IV. The wall regime — the engine's trigger is refuted in well-founded Set -/ +/-! ## § IV. The wall regime — the engine's trigger at `B = Prop` is refuted for every type -/ -/-- **The engine cannot fire in Set.** Lawvere's trigger — a reflexive point-surjection -`e : A → (A → Prop)` — does not exist (Cantor, `cantor_via_engine`). So the ν-regime fixed point the -framework assumes (`fixed_bot`) cannot be produced in well-founded Set; assuming it is the commitment to -the non-well-founded (AFA) regime — the `QuineAtomHost` requirement, one level down. -/ +/-- **The engine cannot fire at `B = Prop`.** Lawvere's trigger there — a point-surjection +`e : A → (A → Prop)` — does not exist, for every type `A` (Cantor, `cantor_via_engine`). Separately, on a +`ZPSemilattice` with a point other than ⊥, Lawvere's hypothesis at `B = L` fails too +(`nontrivial_lattice_no_witness`), so there Lawvere's route does not produce the ν-regime fixed point the +framework assumes, and `fixed_bot` assumes it instead — the `QuineAtomHost` requirement, one level down. -/ theorem lawvere_trigger_refuted {A : Type*} (e : A → (A → Prop)) : ¬ Function.Surjective e := cantor_via_engine e @@ -78,11 +79,12 @@ theorem lawvere_trigger_refuted {A : Type*} (e : A → (A → Prop)) : /-! ## § V. The μ/ν branches unified — the diagonal fixed point is the discriminator -/ /-- **The branch discriminator (the unification).** A self-reference relation cannot be both -well-founded (the **μ** branch — the wall: Foundation, Cantor, `wf_no_selfloop`) and carry a diagonal +well-founded (the **μ** branch — the wall: Foundation, `wf_no_selfloop`) and carry a diagonal fixed point / self-loop (the **ν** branch — the self-referential object: the Quine atom, `selfApp`'s `fixed_bot`). The diagonal fixed point is exactly what discriminates the two branches of the fork: it lands on ν and is refuted on μ. Together with `selfApp_pinnable` (ν: the fixed point exists, uniquely) -and `lawvere_trigger_refuted` (μ: the engine's trigger is Cantor-blocked), this is the μ/ν picture +and `lawvere_trigger_refuted` (regime-independent: the engine's trigger at `B = Prop` is Cantor-blocked +for every type), this is the μ/ν picture in Lawvere terms, discriminated by the self-loop; the ν fixed point is supplied by the class fields `fixed_bot` / `unique_fp`, not by the engine (§ II, § IV). (The fork's own μ↔ν duality is `fork_is_frameflip`; the concrete ν non-well-foundedness of `selfApp` is `floor_not_wellFounded`.) -/ @@ -189,7 +191,8 @@ example : (∀ b : Bool, (!b) ≠ b) ∧ ¬ Monotone (fun b : Bool => !b) := -- first conjunct is Knaster–Tarski, `OrderHom.lfp`), and no map from its two points onto its monotone -- self-maps is surjective. -- Reading: so in the monotone face the absence of a fixed-point-free monotone endomap does not suffice --- for a reflexive object. +-- for a reflexive object. Not new: credited in `ZeroParadox/Settheory/LawvereBridge.md`, § "The hard +-- bridge" (Soto-Andrade and Varela 1984, Trimble, Bergman). example : (∀ f : Bool →o Bool, ∃ b, f b = b) ∧ ¬ ∃ e : Bool → (Bool →o Bool), Function.Surjective e := by refine ⟨fun f => ⟨OrderHom.lfp f, OrderHom.map_lfp f⟩, ?_⟩ diff --git a/ZeroParadox/Settheory/LawvereBridge.md b/ZeroParadox/Settheory/LawvereBridge.md index 715fcc37..ec30a066 100644 --- a/ZeroParadox/Settheory/LawvereBridge.md +++ b/ZeroParadox/Settheory/LawvereBridge.md @@ -31,10 +31,14 @@ Lawvere's theorem is an implication: **if** a point-surjection `e : A → (A → existence result supplies (`existence_without_uniqueness`), and it is the fork collapse of `RequirementsGap` / `fork_collapse_iff`. - **The engine yields the WALL faces, by contrapositive.** Run at a fixed-point-*free* map (negation), - the implication refutes the point-surjection: Cantor / Russell / Turing (`cantor_via_engine`). Its - hypothesis, a reflexive point-surjection, is refuted in well-founded Set (`lawvere_trigger_refuted`). - So the ν fixed point the framework assumes is not produced in well-founded Set; `fixed_bot` is the - commitment to the non-well-founded (AFA) regime — the same `QuineAtomHost` commitment, one level down. + the implication refutes the point-surjection: Russell / Turing (`russell_via_engine`, `no_self_decider`; + `ZeroParadox/Settheory/Wall.lean`). Cantor is the same contrapositive at `B = Prop`, a corollary of + `lawvere_fixedpoint` at `Not`; the Lean proof (`cantor_via_engine`, same file) inlines that step, calling + the engine `negation_no_fixedpoint` directly. Lawvere's hypothesis at `B = Prop`, a point-surjection + `A → (A → Prop)`, is refuted for every type `A` (`lawvere_trigger_refuted`). Separately, on a + `ZPSemilattice` with a point other than ⊥, Lawvere's hypothesis at `B = L` fails too + (`nontrivial_lattice_no_witness`), so there Lawvere's route does not produce the ν fixed point the + framework assumes, and `fixed_bot` assumes it instead: the same `QuineAtomHost` commitment, one level down. - **In the computability chart the hypothesis holds.** The universal machine `eval` is point-surjective onto the partial computable functions (`eval_point_surjective`, `ZeroParadox/Computability/ComputableCrossing.lean`), and the recursion theorem gives a fixed point @@ -52,8 +56,9 @@ the translation key between the faces; ZP-R conjectures nothing global. What is proved: Lawvere's fixed point has the shape of a self-application (`lawvere_fixedpoint_selfApp`); the framework's self-application fixed point is `∃!` by its class fields (`selfApp_pinnable`); existence -does not force uniqueness (`existence_without_uniqueness`); the engine's hypothesis is refuted in Set -(`lawvere_trigger_refuted`) and on every nontrivial `ZPSemilattice` (`nontrivial_lattice_no_witness`). +does not force uniqueness (`existence_without_uniqueness`); the engine's hypothesis is refuted at `B = Prop` +for every type (`lawvere_trigger_refuted`), and at `B = L` on every nontrivial `ZPSemilattice` +(`nontrivial_lattice_no_witness`). `AbstractSelfApp.fixed_bot` / `unique_fp` remain assumed class fields, not derived from a reflexive object. @@ -80,8 +85,8 @@ endomap does not suffice for one: the two-element chain is the witness (the last in `ZeroParadox/Settheory/LawvereBridge.lean`). That example is not new: it is the first finite stage of Soto-Andrade and Varela's two-element example ("Self-reference and fixed points", Acta Applicandae Mathematicae 2(1), 1984, §2.5, pp. 15–16), the case Y = 2 of Trimble's "Cantor's theorem for posets" -(nLab personal web, ncatlab.org/toddtrimble), and the case P = 2 of Bergman 2008, Corollary 7 (Tbilisi -Math. J. 1, 89–103; arXiv:0801.0751). Trimble and Bergman state it for order-preserving maps; the Lean +(nLab personal web, ncatlab.org/toddtrimble), and the case P = 2 of Bergman's Corollary 7 of arXiv:0801.0751 +(Corollary 3.2 in the journal version, Tbilisi Math. J. 1 (2008), 89–103). Trimble and Bergman state it for order-preserving maps; the Lean example allows any map, by counting two points against three monotone self-maps. On uniqueness, `monotone_regime_derives_pinned` takes the fork collapse `lfp f = gfp f` as a hypothesis, which by `fork_collapse_iff` is equivalent to `∃! x, f x = x`: uniqueness is restated, not derived, and `id` on a diff --git a/ZeroParadox/Settheory/Loeb.lean b/ZeroParadox/Settheory/Loeb.lean index 533c5e1c..b0d3d870 100644 --- a/ZeroParadox/Settheory/Loeb.lean +++ b/ZeroParadox/Settheory/Loeb.lean @@ -27,10 +27,9 @@ namespace ZeroParadox /-- **An abstract provability logic.** Sentences `S` with implication `imp`, provability modality `box`, and a "provable" predicate `Thm`, satisfying: the implicational Hilbert base (`ax_K`, `ax_S`) closed under modus ponens (`mp`); and the three Hilbert–Bernays–Löb derivability conditions - (`nec` = D1 necessitation, `ax_D2` = distribution of `box` over `imp`, `ax_D3`). This is exactly the - apparatus Löb's theorem needs, and no more. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: no modal or provability logic was located in the pinned Mathlib as of 2026-08-30, searched on three axes (Löb/GL; Kripke and modal logic; --- derivability conditions, or modal-logic Kripke apparatus). Minimal typeclass carrying just the + (`nec` = D1 necessitation, `ax_D2` = distribution of `box` over `imp`, `ax_D3`). -/ +-- [ZP-CUSTOM] no Mathlib analog | reason: no modal or provability logic was located in the pinned Mathlib as of 2026-08-30, searched on three axes (Löb / GL; Kripke and modal logic; +-- provability / derivability), as recorded in `LEAN_CUSTOM_REGISTRY.md`. A typeclass carrying the -- Hilbert–Bernays–Löb apparatus so Löb's theorem is a face of the diagonal family. class ProvabilityLogic (S : Type*) where imp : S → S → S @@ -104,18 +103,163 @@ theorem loeb {A : S} (psi : S) have hbA : Thm (box A) := mp hd (nec hpsi) exact mp hLob hbA -/-! ## § IV. Gödel's second incompleteness — the `A = ⊥` corollary -/ +/-- **Löb's principle at `A` makes `□A → A` a Löb diagonal for `A`.** + `Statement:` if `⊢ □(□A → A) → □A`, then `ψ := □A → A` satisfies both hypotheses of `loeb`, + `⊢ ψ → (□ψ → A)` and `⊢ (□ψ → A) → ψ`; one way. The second conjunct does not use `hL` (`example` + below); the first does, and without `hL` it is false in the class (§ IV, the `example` after the + one-point control). Its converse is `loeb_axiom_of_loeb_diagonal` (§ VI): some Löb diagonal for `A` + exists iff Löb's principle holds at `A` (the `example` after it). This is not the converse of `loeb`, + which concludes Löb's RULE at `A`; that converse is false in the class (§ IV, the last `example`). + `Reading:` it trades one input of `loeb` for another; it constructs no arithmetic diagonal. -/ +theorem loeb_diagonal_of_loeb_axiom (A : S) + (hL : Thm (imp (box (imp (box A) A)) (box A))) : + Thm (imp (imp (box A) A) (imp (box (imp (box A) A)) A)) ∧ + Thm (imp (imp (box (imp (box A) A)) A) (imp (box A) A)) := by + -- `hB x y : ⊢ (y → A) → ((x → y) → (x → A))`, from `ax_S` and `ax_K` + have hB : ∀ x y : S, Thm (imp (imp y A) (imp (imp x y) (imp x A))) := fun x y => + contract (mp (ax_K _ _) (ax_S x y A)) (ax_K (imp y A) x) + -- `⊢ □A → □(□A → A)`: necessitate `ax_K`, distribute with D2 + have hbox : Thm (imp (box A) (box (imp (box A) A))) := + mp (ax_D2 A (imp (box A) A)) (nec (ax_K A (box A))) + exact ⟨contract (hB _ _) (mp (ax_K _ _) hL), contract (hB _ _) (mp (ax_K _ _) hbox)⟩ + +-- Statement: the second conjunct of `loeb_diagonal_of_loeb_axiom` holds with no Löb hypothesis. +example (A : S) : Thm (imp (imp (box (imp (box A) A)) A) (imp (box A) A)) := + contract (contract (mp (ax_K _ _) (ax_S _ _ A)) (ax_K _ _)) + (mp (ax_K _ _) (mp (ax_D2 A (imp (box A) A)) (nec (ax_K A (box A))))) + +/-! ## § IV. Gödel's second incompleteness — the `A = falsum` corollary -/ /-- **Gödel's second incompleteness, via Löb.** If the system is consistent (`⊬ falsum`) and has a Löb - diagonal for falsum (`hfix1`, `hfix2`), it cannot prove `□falsum → falsum` — the internal statement of its own consistency. Immediate from Löb at `A = falsum`: - a proof of `□falsum → falsum` would yield `⊢ falsum`, contradicting consistency. So Löb subsumes - Gödel's second theorem; the wall on the provability axis is the unprovability of consistency. -/ + diagonal for falsum (`hfix1`, `hfix2`), it cannot prove `□falsum → falsum`, the internal statement of + its own consistency. Immediate from Löb at `A = falsum`: a proof of `□falsum → falsum` would yield + `⊢ falsum`. So Löb subsumes Gödel's second; the provability axis's wall is unprovable consistency. + `Statement:` it holds for every unprovable `falsum` with a Löb diagonal (bound universally; § I has no + falsum constant); the first `example` below is one that does not imply every sentence (no ex-falso). + `Reading:` when the class is instantiated at a theory of arithmetic and `falsum` is its falsum, + the diagonal lemma supplying `hfix1`, `hfix2`, this is Gödel's second theorem; the floor reading + beside this wall one is in `ZeroParadox/Settheory/Loeb.md`. -/ theorem godel_two {falsum : S} (psi : S) (hfix1 : Thm (imp psi (imp (box psi) falsum))) (hfix2 : Thm (imp (imp (box psi) falsum) psi)) (hcon : ¬ Thm falsum) : ¬ Thm (imp (box falsum) falsum) := fun h => hcon (loeb psi hfix1 hfix2 h) +-- Reading: the propositions of the Kripke frame on the two-element strict chain, the frame of a finite +-- GL-model (Saitou & Noguchi, arXiv:2609.13780, Def. 3.4). Statement: with `box (a, b) = (b, true)`, +-- `F = (false, true)` is unprovable, is its own Löb diagonal, and `⊢ F → (false, false)` fails; Löb's +-- principle `⊢ □(□p → p) → □p` holds for every `p`; and `godel_two` applies at `F`, giving `⊬ □F → F`. +example : + let _ : ProvabilityLogic (Bool × Bool) := + { imp := fun a b => (!a.1 || b.1, !a.2 || b.2) + box := fun a => (a.2, true) + Thm := fun a => a = (true, true) + mp := by intro a b; revert a b; decide + ax_K := by decide + ax_S := by decide + nec := by intro a; revert a; decide + ax_D2 := by decide + ax_D3 := by decide } + ¬ Thm ((false, true) : Bool × Bool) ∧ + Thm (imp ((false, true) : Bool × Bool) (imp (box (false, true)) (false, true))) ∧ + Thm (imp (imp (box ((false, true) : Bool × Bool)) (false, true)) (false, true)) ∧ + ¬ Thm (imp ((false, true) : Bool × Bool) (false, false)) ∧ + (∀ p : Bool × Bool, Thm (imp (box (imp (box p) p)) (box p))) ∧ + ¬ Thm (imp (box ((false, true) : Bool × Bool)) (false, true)) := by + intro _ + exact ⟨fun h => Bool.false_ne_true (congrArg Prod.fst h), rfl, rfl, + fun h => Bool.false_ne_true (congrArg Prod.snd h), + fun ⟨a, b⟩ => by cases a <;> cases b <;> rfl, + godel_two (falsum := ((false, true) : Bool × Bool)) (false, true) rfl rfl + (fun h => Bool.false_ne_true (congrArg Prod.fst h))⟩ + +-- Reading: the one-point reflexive frame. +-- Statement: CONTROL, with `box = id` on `Bool`: `⊬ false` and `⊢ □false → false`, so `godel_two`'s +-- conclusion fails; `⊢ □p → p` for every `p`; Löb's principle fails at `false`; and no sentence is a +-- Löb diagonal for `false`. +example : + letI : ProvabilityLogic Bool := + { imp := fun a b => !a || b + box := id + Thm := fun a => a = true + mp := by intro a b; revert a b; decide + ax_K := by decide + ax_S := by decide + nec := by intro a; revert a; decide + ax_D2 := by decide + ax_D3 := by decide } + ¬ Thm false ∧ Thm (imp (box false) false) ∧ (∀ p : Bool, Thm (imp (box p) p)) ∧ + ¬ Thm (imp (box (imp (box false) false)) (box false)) ∧ + ¬ ∃ psi : Bool, Thm (imp psi (imp (box psi) false)) ∧ Thm (imp (imp (box psi) false) psi) := + ⟨Bool.false_ne_true, rfl, fun p => by cases p <;> rfl, Bool.false_ne_true, + fun ⟨psi, h1, h2⟩ => by + cases psi + · exact Bool.false_ne_true h2 + · exact Bool.false_ne_true h1⟩ + +-- Statement: `loeb_diagonal_of_loeb_axiom` needs `hL`: without it its first conjunct is false in the +-- class, failing in the one-point control above at `A = false`. +example : ¬ ∀ (S : Type) [ProvabilityLogic S] (A : S), + Thm (imp (imp (box A) A) (imp (box (imp (box A) A)) A)) := fun h => + Bool.false_ne_true <| @h Bool + { imp := fun a b => !a || b + box := id + Thm := fun a => a = true + mp := by intro a b; revert a b; decide + ax_K := by decide + ax_S := by decide + nec := by intro a; revert a; decide + ax_D2 := by decide + ax_D3 := by decide } false + +-- Reading: one reflexive world and one dead-end world. Statement: CONTROL, with `box (a, b) = (a, true)` +-- and `A = (false, false)`: Löb's rule at `A` holds (`⊢ □A → A` implies `⊢ A`, vacuously) and no +-- sentence is a Löb diagonal for `A`. +example : + let _ : ProvabilityLogic (Bool × Bool) := + { imp := fun a b => (!a.1 || b.1, !a.2 || b.2) + box := fun a => (a.1, true) + Thm := fun a => a = (true, true) + mp := by intro a b; revert a b; decide + ax_K := by decide + ax_S := by decide + nec := by intro a; revert a; decide + ax_D2 := by decide + ax_D3 := by decide } + (Thm (imp (box ((false, false) : Bool × Bool)) (false, false)) → Thm ((false, false) : Bool × Bool)) ∧ + ¬ ∃ psi : Bool × Bool, Thm (imp psi (imp (box psi) (false, false))) ∧ + Thm (imp (imp (box psi) (false, false)) psi) := by + intro _ + refine ⟨fun h => ?_, ?_⟩ + · exact absurd (congrArg Prod.snd h) Bool.false_ne_true + · rintro ⟨⟨a, b⟩, h1, h2⟩ + cases a <;> cases b <;> + first + | exact Bool.false_ne_true (congrArg Prod.fst h1) + | exact Bool.false_ne_true (congrArg Prod.snd h1) + | exact Bool.false_ne_true (congrArg Prod.fst h2) + +-- Statement: the converse of `loeb` at one `A` (Löb's rule at `A` gives a Löb diagonal for `A`) is false +-- in the class, failing in the control above at `A = (false, false)`. +example : ¬ ∀ (S : Type) [ProvabilityLogic S] (A : S), (Thm (imp (box A) A) → Thm A) → + ∃ psi : S, Thm (imp psi (imp (box psi) A)) ∧ Thm (imp (imp (box psi) A) psi) := fun h => by + obtain ⟨⟨a, b⟩, h1, h2⟩ := @h (Bool × Bool) + { imp := fun a b => (!a.1 || b.1, !a.2 || b.2) + box := fun a => (a.1, true) + Thm := fun a => a = (true, true) + mp := by intro a b; revert a b; decide + ax_K := by decide + ax_S := by decide + nec := by intro a; revert a; decide + ax_D2 := by decide + ax_D3 := by decide } (false, false) + (fun h => absurd (congrArg Prod.snd h) Bool.false_ne_true) + cases a <;> cases b <;> + first + | exact Bool.false_ne_true (congrArg Prod.fst h1) + | exact Bool.false_ne_true (congrArg Prod.snd h1) + | exact Bool.false_ne_true (congrArg Prod.fst h2) + /-! ## § V. The bottom-element relationship: an assumed Löb sentence is a provability fixed point -/ /-- **Given a Löb sentence `ψ` (the hypotheses `hfix1`, `hfix2`), `ψ` is a fixed point, up to @@ -158,6 +302,23 @@ theorem imp_antitone {x y : S} (A : S) (h : Thm (imp x y)) : Thm (imp (imp y A) have s2 : Thm (imp (imp y A) (imp (imp x y) (imp x A))) := contract s1 (ax_K (imp y A) x) exact contract s2 (mp (ax_K (imp x y) (imp y A)) h) +/-- `Statement:` if `ψ` is a Löb diagonal for `A` (`hfix1`, `hfix2`), then Löb's principle holds at `A`: + `⊢ □(□A → A) → □A`; one way. Converse of `loeb_diagonal_of_loeb_axiom` (§ III). -/ +theorem loeb_axiom_of_loeb_diagonal {A : S} (psi : S) + (hfix1 : Thm (imp psi (imp (box psi) A))) + (hfix2 : Thm (imp (imp (box psi) A) psi)) : + Thm (imp (box (imp (box A) A)) (box A)) := by + have hd : Thm (imp (box psi) (box A)) := + contract (hs (box_mono hfix1) (ax_D2 (box psi) A)) (ax_D3 psi) + exact hs (box_mono (hs (imp_antitone A hd) hfix2)) hd + +-- Statement: some sentence is a Löb diagonal for `A` iff Löb's principle holds at `A`; both directions. +example (A : S) : + (∃ psi : S, Thm (imp psi (imp (box psi) A)) ∧ Thm (imp (imp (box psi) A) psi)) ↔ + Thm (imp (box (imp (box A) A)) (box A)) := + ⟨fun ⟨psi, h1, h2⟩ => loeb_axiom_of_loeb_diagonal psi h1 h2, + fun hL => ⟨_, (loeb_diagonal_of_loeb_axiom A hL).1, (loeb_diagonal_of_loeb_axiom A hL).2⟩⟩ + /-- `Statement:` the Löb map `p ↦ (□p → A)` respects provable equivalence. -/ theorem loebMap_respects (A : S) {a b : S} (h : ProvEquiv a b) : ProvEquiv (imp (box a) A) (imp (box b) A) := @@ -177,6 +338,13 @@ theorem selfOnlyAt_loebMapQuot_iff (A psi : S) : exact ⟨h'.2, h'.1⟩ · exact Quotient.sound (show ProvEquiv (imp (box psi) A) psi from ⟨h.2, h.1⟩) +-- Statement: on the Lindenbaum quotient the Löb diagonal is a literal fixed point: `⟦ψ⟧` is fixed by +-- `loebMapQuot A` iff `hfix1` and `hfix2` hold; both directions. +example (A psi : S) : + loebMapQuot A ⟦psi⟧ = ⟦psi⟧ ↔ + Thm (imp psi (imp (box psi) A)) ∧ Thm (imp (imp (box psi) A) psi) := + (Motion.selfOnlyAt_ofFun_iff _ _).symm.trans (selfOnlyAt_loebMapQuot_iff A psi) + /-- `Statement:` if the class of `ψ` steps to itself only in `Motion.ofFun (loebMapQuot A)` and `⊢ □A → A`, then `⊢ A`; one way (`loeb`). -/ theorem loeb_of_selfOnlyAt {A : S} (psi : S) @@ -196,6 +364,7 @@ open ZeroParadox ZeroParadox.ProvabilityLogic #print axioms contract #print axioms hs #print axioms loeb +#print axioms loeb_diagonal_of_loeb_axiom #print axioms godel_two #print axioms loeb_sentence_is_fixedpoint #print axioms ProvEquiv @@ -203,6 +372,7 @@ open ZeroParadox ZeroParadox.ProvabilityLogic #print axioms Lindenbaum #print axioms box_mono #print axioms imp_antitone +#print axioms loeb_axiom_of_loeb_diagonal #print axioms loebMap_respects #print axioms loebMapQuot #print axioms selfOnlyAt_loebMapQuot_iff diff --git a/ZeroParadox/Settheory/Loeb.md b/ZeroParadox/Settheory/Loeb.md index 3d11c434..66bbdac5 100644 --- a/ZeroParadox/Settheory/Loeb.md +++ b/ZeroParadox/Settheory/Loeb.md @@ -6,9 +6,11 @@ declarations, the Engineer's Take and the per-declaration glosses. ## The face Löb (1955): in a system with a provability predicate `□` satisfying the Hilbert–Bernays–Löb derivability -conditions and given a Löb diagonal ψ (hypotheses hfix1, hfix2), `⊢ (□A → A)` implies `⊢ A`. This is the diagonal family's **provability-modal face** — the -self-referential fixed point of the map `p ↦ (□p → A)` (the Löb sentence). It is the ONLY sibling of the -four with no Mathlib support located as of 2026-08-17, so it is built from scratch as an abstract +conditions and given a Löb diagonal ψ (hypotheses hfix1, hfix2), `⊢ (□A → A)` implies `⊢ A`. In +arithmetic, Löb's setting, the diagonal lemma supplies ψ with `⊢ ψ ↔ (□ψ → A)`; hfix1 and hfix2 are +the two halves of that equivalence, which this file takes as hypotheses. This is the diagonal +family's **provability-modal face** — the self-referential fixed point of the map `p ↦ (□p → A)` +(the Löb sentence). It is the ONLY sibling of the four with no Mathlib support located as of 2026-08-17, so it is built from scratch as an abstract provability logic. Searched as follows: `Löb`, `GL`, `provability`, `□`/`box` as a modality, and `derivability` across the pinned Mathlib; `#check` on the names those would carry. No modal or provability logic found. @@ -17,22 +19,76 @@ provability logic found. Tarski is the TRUTH face (undefinable — the wall), Gödel/Löb the PROVABILITY face (definable but self-constrained). Löb subsumes **Gödel's second incompleteness**: at `A = falsum`, given a Löb diagonal for -falsum, a consistent system cannot prove `□falsum → falsum` — its own consistency (`godel_two`). The Löb sentence `ψ ↔ (□ψ → A)` is a genuine -diagonal fixed point (ν: in arithmetic, by the diagonal lemma; here the hypotheses hfix1, hfix2), and Löb is what it forces. +falsum, a consistent system cannot prove `□falsum → falsum` — its own consistency (`godel_two`). That reading is +Gödel's second theorem when the class is instantiated at a theory of arithmetic and falsum is its falsum. In +the class, `godel_two` binds falsum as an arbitrary sentence (`ProvabilityLogic` has no falsum +constant and no ex-falso), so it covers any unprovable sentence with a Löb diagonal, including one +that does not imply every sentence, and without a Löb diagonal its conclusion can fail (the two +`example`s directly after `godel_two` in `ZeroParadox/Settheory/Loeb.lean`). The Löb sentence +`ψ ↔ (□ψ → A)` is a diagonal fixed point up to provability (`ProvabilityLogic.loeb_sentence_is_fixedpoint`) +(ν: in arithmetic, by the diagonal lemma; here the hypotheses hfix1, hfix2), and Löb is what it forces +(`ProvabilityLogic.loeb`). On the Lindenbaum quotient its class is a literal fixed point of the induced map +(`ProvabilityLogic.selfOnlyAt_loebMapQuot_iff` and the `example` after it). The family's table files the face as a +floor (ν) because that diagonal closes; `godel_two`'s docstring calls the unprovability of consistency the wall on the +provability axis. That wall is a limitation, not one of the μ wall faces. ## Design `ProvabilityLogic` is a typeclass carrying sentences `S`, connective `imp`, modality `box`, and a -provability predicate `Thm`, with the minimal axioms Löb needs — the implicational Hilbert base (`ax_K`, +provability predicate `Thm`, with the axioms the derivation of `loeb` uses — the implicational Hilbert base (`ax_K`, `ax_S`) with modus ponens (`mp`), and the three derivability conditions (`nec` = D1, `ax_D2` = distribution, `ax_D3` = D3). The diagonal lemma is taken as a hypothesis (`hfix1`/`hfix2`), the standard separation of concerns: Löb from the derivability conditions plus a diagonal. +Diagonal and principle: `ProvabilityLogic.loeb_diagonal_of_loeb_axiom` takes Löb's principle +`⊢ □(□A → A) → □A` at `A` as an explicit hypothesis and gives `□A → A` as a Löb diagonal for `A`; +`ProvabilityLogic.loeb_axiom_of_loeb_diagonal` is its converse, so in the class some Löb diagonal for `A` exists +iff Löb's principle holds at `A`. That pair is not `loeb` and its converse: `loeb` concludes Löb's RULE at `A`, +and a control after `godel_two` has the rule at one `A` with no Löb diagonal for it, so the converse of +`loeb` at one `A` is false in the class (the last `example` of § IV of the Lean file). +`loeb_diagonal_of_loeb_axiom` trades one input of `loeb` for another and constructs no arithmetic diagonal. +Its hypothesis is needed: without it, its first conjunct is false in the class, failing at `A = false` in the +one-point reflexive control after `godel_two` (the `example` after that control). +`loeb_axiom_of_loeb_diagonal` is the formalized Löb theorem, `⊢ □(□A → A) → □A` (Saitou and Noguchi, +arXiv:2609.13780, Prop 2.9), at one `A` and from a diagonal taken as a hypothesis; +FormalizedFormalLogic/Foundation proves it uniformly in `σ` as +`FFL.FirstOrder.ProvabilityAbstraction.formalized_löb_theorem` +(`Foundation/FirstOrder/Incompleteness/ProvabilityAbstraction/Basic.lean` at commit c3eb37ae, retrieved +2026-11-01), for a provability predicate `𝔅` of a theory `T` in a theory `T₀`, under `[𝔅.HBL]`, `[T₀ ⪯ T]` +and `[L.DecidableEq]`, with its Löb diagonal, the Kreisel sentence `kreisel`, taken from a +`Diagonalization T₀` instance. In arithmetic the diagonal lemma is formalized in Lean 4 as `diagonal` in +FormalizedFormalLogic/Foundation (`Foundation/FirstOrder/Arithmetic/Bootstrapping/FixedPoint.lean` at commit +c3eb37ae, retrieved 2026-11-01). + ## Honest delta -No Mathlib modal/provability logic, and nothing like it in the repo. -Attribution: Löb (1955); Hilbert–Bernays–Löb derivability conditions; diagonal-family framing Lawvere -(1969), via Yanofsky (2003) § 1 p. 1. The classical Löb derivation is standard. -Prior art: Popescu & Traytel, CADE-27 (2019) and AFP Goedel_Incompleteness (abstract HBL conditions, Gödel 2 +No modal or provability logic was located in the pinned Mathlib as of 2026-08-17, searched as in § The face +(re-run on three axes 2026-08-30, as recorded in `LEAN_CUSTOM_REGISTRY.md`). +Attribution: Löb (1955); Hilbert–Bernays–Löb derivability conditions; diagonal-family framing: +Yanofsky (2003, arXiv:math/0305282v1, p. 18), who treats Löb's paradox in that family, extending +Lawvere (1969), whose paper does not name Löb (TAC reprint text searched for "Löb", 2026-11-05; it +treats Gödel's incompleteness and Tarski, § 3). The classical Löb derivation is standard. +Prior art: Popescu & Traytel, CADE-27 (2019) and AFP Goedel_Incompleteness (abstract Hilbert–Bernays–Löb (HBL) derivability conditions, Gödel 2 and Löb in Isabelle); Saitou & Noguchi, arXiv:2609.13780 (Lean 4 Foundation: abstract Provability and Diagonalization -classes). +classes; more exactly, `Provability` is a structure with the derivability conditions as classes over it (`HBL2`, +`HBL3`) and `Diagonalization` a class, § 2.4, with abstract Gödel 2 and Löb as Propositions 2.8 and 2.9). On diagonal and principle: the Stanford Encyclopedia of Philosophy entry "Provability Logic", § 2.2, +states that in GL fixed points of formulas modalized in `p` exist and are unique up to GL-equivalence (de Jongh and +Sambin, 1975); Litak and Visser (arXiv:1905.09450, § 1) credit uniqueness also to Bernardi (1976). In Lean 4 that +theorem for GL is `FFL.ProvabilityLogic.Logic.GL.fixpoint_theorem` in FormalizedFormalLogic/Foundation +(`Foundation/ProvabilityLogic/GL/Fixedpoint.lean` at commit c3eb37ae), giving existence and uniqueness, not an +explicit fixed point. Litak and Visser § 1 state that GL is the smallest extension of K4 in which guarded +fixpoints are definable, which follows because, by Löb's argument, Löb's principle is entailed by the presence of +guarded fixed points in combination with the de Jongh–Sambin result. That is a statement about logics, with +fixed points for every guarded formula; `loeb_axiom_of_loeb_diagonal` uses one diagonal, for the one map +`p ↦ (□p → A)`, and gives the principle at that one `A`, with D3 as its K4 ingredient and no use of the +de Jongh–Sambin theorem; `loeb_diagonal_of_loeb_axiom` gives a diagonal back from the principle at that `A`. +Compare Kumasaka and Kurahashi (arXiv:2608.29914, Thm 7.14, Prop 7.17): in a meet abstract provability +structure satisfying (C3*), the parametrized fixed-point condition (FP), that for every `x` some `p` has +`p = ⊠(p ∧ x)`, gives their (Löb), the abstract counterpart of Löb's rule; and there is a consistent meet APS +with (C3*) and (Löb) in which no one-variable term of odd degree has a fixed point. The hypothesis of +`loeb_diagonal_of_loeb_axiom` is the internal principle, not the rule. A source stating that `□A → A` solves +`p ↔ (□p → A)` was not located as of 2026-11-01, searched as follows: that SEP section (whose one worked example +is the falsum instance `¬□⊥`), Litak and Visser § 1, Kumasaka and Kurahashi, Fitting's GL fixed-point program +note (the retrieved copy is dated October 4, 1995), and theoremsearch, ten phrasings over three +prior-art review rounds of 2026-11-01 (four, four and two). Not retrieved: Boolos (1993) ch. 8, Smoryński (1985), +Lindström (2006, J. Phil. Logic 35). The Lean theorem is the check. diff --git a/ZeroParadox/Settheory/Model.lean b/ZeroParadox/Settheory/Model.lean index 7ecb05a6..07cdea3e 100644 --- a/ZeroParadox/Settheory/Model.lean +++ b/ZeroParadox/Settheory/Model.lean @@ -88,19 +88,19 @@ noncomputable instance instNatInfVal : ValuationStructure ℕ∞ where val_scale := fun _x _hx => rfl -- Reading: CARRIER, this model only (not abstract `collect`). Its join, ⊥ and scale are the min-plus --- semiring's addition, zero and multiplication by `trop 1` in Mathlib's `Tropical ℕ∞` --- (`Tropical.trop_top`, `Tropical.untrop_add`, `Tropical.untrop_mul`), so `scale_bot` is `zero_mul`: +-- semiring's addition, zero and multiplication by `trop 1` in Mathlib's `MinTropical ℕ∞` +-- (`MinTropical.trop_top`, `MinTropical.untrop_add`, `MinTropical.untrop_mul`), so `scale_bot` is `zero_mul`: -- "∞ is the zero of this semiring" (Pin, "Tropical Semirings", in *Idempotency* (Cambridge UP 1998); -- author's preprint p. 3). -- Statement: `trop` sends this model's join to tropical `+`, ⊥ to tropical `0` and scale to `* trop 1`, -- so `scale_bot` is `zero_mul`. -example : (∀ x y : ℕ∞, Tropical.trop (join x y) = Tropical.trop x + Tropical.trop y) ∧ - Tropical.trop (bot : ℕ∞) = 0 ∧ - (∀ x : ℕ∞, Tropical.trop (ValuationStructure.scale x) = - Tropical.trop x * Tropical.trop (1 : ℕ∞)) ∧ - Tropical.trop (ValuationStructure.scale (bot : ℕ∞)) = 0 := - ⟨fun _ _ => rfl, rfl, fun _ => rfl, zero_mul (Tropical.trop (1 : ℕ∞))⟩ +example : (∀ x y : ℕ∞, MinTropical.trop (join x y) = MinTropical.trop x + MinTropical.trop y) ∧ + MinTropical.trop (bot : ℕ∞) = 0 ∧ + (∀ x : ℕ∞, MinTropical.trop (ValuationStructure.scale x) = + MinTropical.trop x * MinTropical.trop (1 : ℕ∞)) ∧ + MinTropical.trop (ValuationStructure.scale (bot : ℕ∞)) = 0 := + ⟨fun _ _ => rfl, rfl, fun _ => rfl, zero_mul (MinTropical.trop (1 : ℕ∞))⟩ -- Statement: scale is deflationary in the ZP order and not inflationary, join is inflationary, and -- `scale_bot` follows from deflationarity alone (the arrow beside `t_snap_irreversible`). diff --git a/ZeroParadox/Settheory/QuineDichotomy.lean b/ZeroParadox/Settheory/QuineDichotomy.lean index a2e72d7f..cdbb52c1 100644 --- a/ZeroParadox/Settheory/QuineDichotomy.lean +++ b/ZeroParadox/Settheory/QuineDichotomy.lean @@ -1,6 +1,7 @@ import ZeroParadox.Settheory.Coalgebra import ZeroParadox.Computability.SelfApp import ZeroParadox.Category.Lawvere +import ZeroParadox.Settheory.QuineHost /-! # ZPJ — the Quine-atom dichotomy @@ -28,17 +29,17 @@ Assembled from pieces already proved across the ZPJ family + ZP-P's coalgebra: ## FENCE (crucial — unlike the snap dichotomy) The snap's classifier (Ostrowski) is a theorem INSIDE one foundation, so "snap ⟺ non-Archimedean" is fully -machine-checkable. The Quine atom's classifier (Foundation vs AFA) is a choice of METATHEORY, which Lean's -well-founded kernel cannot adjudicate from inside (it cannot host `x = {x}`; that is the Cantor wall above). +machine-checkable. The Quine atom's classifier (Foundation vs AFA) is a choice of METATHEORY, which Lean cannot +adjudicate from inside. `Statement:` **CARRIER** — no `ZFSet` is its own member (`no_quine_atom`) and no `T ≃ Set T` exists (Cantor, above), while the coalgebra chart hosts a self-unfolding element (`Cofix`, the existence fork above). So what is PROVED here is the STRUCTURAL dichotomy (the self-referential fixed point exists on the ν side, -not the μ side, and where it exists it is the unique bottom). The SET-THEORETIC reading — "the Quine atom -exists ⟺ AFA" — stays a metatheoretic commitment (the FMC / CC-2, fenced in ZP-E R-AFA). This file makes NO -claim that AFA is machine-checked. +not the μ side, and where it exists it is the unique bottom). The Quine atom (CC-2) is the die role `Motion.SelfOnlyAt`, whose occupancy +is settled chart by chart (`selfApp_quine_role_iff`, `quineAtomHost_quine_role_iff`, `zfset_quine_role_unoccupied`), no cross-chart equation. +"Quine atom ⟺ AFA" concerns the set chart's host: Foundation-freeness is forced (`quineAtomHost_not_wellFounded`), adopting AFA stays the FMC / CC-2 (ZP-E R-AFA); AFA is not machine-checked here. ## Symbol map (component → existing lemma) - existence fork → `ZeroParadox.categorical_fork_strict` (`idPF_Coalgebra`, `Fix`, `Cofix` from ZP-P) - self-members = {⊥} → `ZeroParadox.selfMem_eq_singleton_bot` (`selfMemDerived`, `bot`) -- no literal (Cantor) → `ZeroParadox.nontrivial_lattice_no_witness` (lattice face, `HasLawvereWitness`); `ZeroParadox.cantor_via_engine` (`T ≃ Set T`, `ZeroParadox/Settheory/Wall.lean`, not imported) +- no literal (Cantor) → `ZeroParadox.nontrivial_lattice_no_witness` (lattice face, `HasLawvereWitness`); `ZeroParadox.cantor_via_engine` (no surjection `A → (A → Prop)`, which excludes `T ≃ Set T`; `ZeroParadox/Settheory/Wall.lean`, not imported) STATUS: PROVED, sorry-free. Pure assembly of ZP-P coalgebra (`categorical_fork_strict`) + ZeroParadox/Computability/SelfApp.lean (`selfMem_eq_singleton_bot`) + ZeroParadox/Category/Lawvere.lean (`nontrivial_lattice_no_witness`); Cantor is cited from ZeroParadox/Settheory/Wall.lean (`cantor_via_engine`). @@ -68,6 +69,71 @@ theorem quine_self_members_eq_bot {L : Type*} [ZPSemilattice L] [AbstractSelfApp theorem quine_no_literal {L : Type*} [ZPSemilattice L] (a : L) (ha : a ≠ bot) : ¬ HasLawvereWitness L := nontrivial_lattice_no_witness a ha +/-- `Statement:` in a `ZPSemilattice` with `AbstractSelfApp`, with OVER the self-application map + (`Motion.ofFun selfApp`), `y` steps to itself and to nothing else iff `y` is ⊥ of `L`; both + directions, from the class fields `fixed_bot` and `unique_fp`. -/ +theorem selfApp_quine_role_iff {L : Type*} [ZPSemilattice L] [AbstractSelfApp L] (y : L) : + (Motion.ofFun (AbstractSelfApp.selfApp (L := L))).SelfOnlyAt y ↔ y = bot := + (Motion.selfOnlyAt_ofFun_iff _ y).trans + ⟨AbstractSelfApp.unique_fp y, fun h => h ▸ AbstractSelfApp.fixed_bot⟩ + +/-- `Statement:` in a `QuineAtomHost`, with OVER `a ⟶ b` when `b` is a member of `a`, `y` steps to + itself and to nothing else iff `y` is the host's `bot`; both directions, from (Y') `bot_mem_iff` + and (Z') `reflexive_unique`. -/ +theorem quineAtomHost_quine_role_iff {L : Type*} [QuineAtomHost L] (y : L) : + (Motion.ofTotal (id : L → L) (fun _ => rfl) + (fun a b => QuineAtomHost.mem b a)).SelfOnlyAt y ↔ y = QuineAtomHost.bot := by + constructor + · rintro ⟨hy, hu⟩ + exact QuineAtomHost.reflexive_unique y fun z => ⟨hu z, fun h => h ▸ hy⟩ + · rintro rfl + exact ⟨(QuineAtomHost.bot_mem_iff _).2 rfl, fun b hb => (QuineAtomHost.bot_mem_iff b).1 hb⟩ + +-- Statement: for any `QuineAtomHost` on a `ZPSemilattice` `L`, ⊥ of `L` occupies the membership +-- chart iff the host's `bot` is ⊥ of `L`; both directions, from `quineAtomHost_quine_role_iff`. +example (L : Type) [ZPSemilattice L] (S : QuineAtomHost L) : + (Motion.ofTotal (id : L → L) (fun _ => rfl) (fun a b => S.mem b a)).SelfOnlyAt bot ↔ + S.bot = bot := + (@quineAtomHost_quine_role_iff L S bot).trans eq_comm + +-- Statement: the host built from an `AFAStructure` on `L` has ⊥ of `L` as its `bot`, and for a point +-- `a ≠ ⊥` of `L` the host `trivialQuineAtomHost a` does not. +example (L : Type) [ZPSemilattice L] [AFAStructure L] : + (afaStructure_isQuineAtomHost L).bot = bot := rfl +example (L : Type) [ZPSemilattice L] (a : L) (ha : a ≠ bot) : + (trivialQuineAtomHost a).bot ≠ bot := ha + +-- Statement: with the AFA-built host's membership as the step, occupying the role is being a Quine atom +-- in the `IsQuineAtom` sense, so by `t_exec_iff` its only occupant is ⊥ of `L`; both directions. +-- Reading: that host's membership relates no element to any other (the example after +-- `afaStructure_isQuineAtomHost` in `ZeroParadox/Settheory/QuineHost.lean`), so "and to nothing else" +-- is automatic here; uniqueness comes from `quine_unique`. +example (L : Type) [ZPSemilattice L] [AFAStructure L] (y : L) : + (Motion.ofTotal (id : L → L) (fun _ => rfl) + (fun a b => (afaStructure_isQuineAtomHost L).mem b a)).SelfOnlyAt y ↔ IsQuineAtom y := + (@quineAtomHost_quine_role_iff L (afaStructure_isQuineAtomHost L) y).trans (t_exec_iff y).symm + +-- Statement: under any well-founded membership relation no point occupies the membership chart, since +-- an occupant steps to itself (`wf_no_selfloop`); `zfset_quine_role_unoccupied` is the `ZFSet` case. The +-- example after `Antitone (fun q : Prop => q → P)` in `ZeroParadox/DieCannotBe.lean` assumes the STEP +-- relation well-founded instead; here it is membership, the step's converse, and neither implies the other. +example {C : Type*} (mem : C → C → Prop) (h : WellFounded mem) (y : C) : + ¬ (Motion.ofTotal (id : C → C) (fun _ => rfl) (fun a b => mem b a)).SelfOnlyAt y := + fun hy => wf_no_selfloop h y hy.1 + +-- Statement: `ZFSet` has no Lawvere witness, since ∅ ≠ {∅} (`no_witness_of_nontrivial`). +example : ¬ HasLawvereWitness ZFSet := + no_witness_of_nontrivial (b₀ := (∅ : ZFSet)) (b₁ := ({∅} : ZFSet)) fun h => by + have : (∅ : ZFSet) ∈ ({∅} : ZFSet) := ZFSet.mem_singleton.2 rfl + rw [← h] at this + exact ZFSet.notMem_empty _ this + +-- Statement: CONTROL: under `trivialSelfApp`, the constant map to ⊥, the same occupancy holds; the +-- class fields alone give it, whatever the map is. +example {L : Type*} [ZPSemilattice L] (y : L) : + (Motion.ofFun (@AbstractSelfApp.selfApp L _ (trivialSelfApp L))).SelfOnlyAt y ↔ y = bot := + @selfApp_quine_role_iff L _ (trivialSelfApp L) y + end ZeroParadox section PurityCheck @@ -75,4 +141,6 @@ open ZeroParadox #print axioms quine_dichotomy #print axioms quine_self_members_eq_bot #print axioms quine_no_literal +#print axioms selfApp_quine_role_iff +#print axioms quineAtomHost_quine_role_iff end PurityCheck diff --git a/ZeroParadox/Settheory/QuineHost.lean b/ZeroParadox/Settheory/QuineHost.lean index d2d823cb..84de5e1f 100644 --- a/ZeroParadox/Settheory/QuineHost.lean +++ b/ZeroParadox/Settheory/QuineHost.lean @@ -19,14 +19,14 @@ slipping in. ## Formal Overview (AI-assisted) -The framework's set-theoretic commitment (CC-2) is a fragment of what a host theory supplies, -not the full Anti-Foundation Axiom (AFA, "every graph has a unique decoration"): a Quine atom +The framework's set-theoretic commitment (CC-2) is adopting the Anti-Foundation Axiom (AFA, +"every graph has a unique decoration"); what the Lean uses of it is a fragment: a Quine atom ⊥ = {⊥}, ⊥'s only member being ⊥, that is the only reflexive element (x = {x}). That is AFA's own profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19), while a* = {a, a*} is self-membered for every a (Examples 1.5–1.6, pp. 7–8; 0* = {∅, 0*}). Two typeclasses, which are incomparable (§ VII): -- `QuineAtomHost` — the commitment: (Y') `bot_mem_iff`, ⊥ = {⊥}; (Z') `reflexive_unique`. +- `QuineAtomHost` — the commitment's Lean abstraction: (Y') `bot_mem_iff`, ⊥ = {⊥}; (Z') `reflexive_unique`. - `QuineHost` — ⊥ ∈ ⊥ and the only self-membered element is ⊥. AFA's membership fails its (Z), since 0* ∈ 0*; the § VI encoding, whose membership relates no element to any other, meets it. @@ -36,8 +36,9 @@ are incomparable (§ VII): Prop. 5.1, p. 57), so fails (Z'); toy model `boffa_fails_reflexive_unique`. AFA's pattern, as a three-element toy with real ∈, meets `QuineAtomHost` and no `QuineHost` (§ VII); a model of the pattern, not of AFA. Both classes are met on every inhabited carrier (NO-GO gauges, § I, § VII), so -realizability alone is uninformative. What remains a *modeling commitment*: that (Y') and (Z') -are the right requirements; AFA is a theory meeting them, not the commitment. (Where +realizability alone is uninformative. Adopting AFA is CC-2's commitment; the host requirements +(`QuineAtomHost`) 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 in `ZeroParadox/Settheory/APG.lean`, it is proved on its own terms.) diff --git a/ZeroParadox/Settheory/RequirementsGap.lean b/ZeroParadox/Settheory/RequirementsGap.lean index 23c299f5..c99fd17f 100644 --- a/ZeroParadox/Settheory/RequirementsGap.lean +++ b/ZeroParadox/Settheory/RequirementsGap.lean @@ -106,7 +106,7 @@ theorem id_gfp_top : (OrderHom.id : α →o α).gfp = ⊤ := by /-- **The maximal gap.** In any nontrivial complete lattice the identity's fork is flung fully open: `lfp = ⊥ ≠ ⊤ = gfp`. Every element is a fixed point, so *every object is a witness* and the -requirement is vacuous — no instance is pinnable. This is the fork image of "self-membership without +requirement is satisfied by every element (uninformative as a condition) — no instance is pinnable. This is the fork image of "self-membership without a uniqueness clause admits everything" (the Boffa shape: `boffa_fails_unique`). -/ theorem id_fork_open [Nontrivial α] : (OrderHom.id : α →o α).lfp ≠ (OrderHom.id : α →o α).gfp := by @@ -161,7 +161,7 @@ self-referential object is *characterized, not constructed*, known only by how i final-coalgebra / coinductive picture of Aczel (*Non-Well-Founded Sets*, 1988) and Barwise-Moss (*Vicious Circles*, 1996). All of that machinery is standard and owned by those sources; the only part original here is the *reading* that ties it to the apophatic-⊥ / 0↔∞ keystone, which stays a -conjecture. See `.claude-local/notes/instance_vs_requirements_gap_2026-07-15.md`. +conjecture. ## Axiom Purity Check -/ section PurityCheck diff --git a/ZeroParadox/Settheory/SetTheoryAFA.lean b/ZeroParadox/Settheory/SetTheoryAFA.lean index 0165fb43..b5d143e1 100644 --- a/ZeroParadox/Settheory/SetTheoryAFA.lean +++ b/ZeroParadox/Settheory/SetTheoryAFA.lean @@ -22,7 +22,9 @@ such bottom elements across instantiations is addressed in ZPI. `Statement:` in a ZP-A lattice with `AFAStructure`, any Quine atom (self-containing, and the only such) is ⊥ (`t_exec`, from `bot_self_mem`; no axioms), and CC-1 is restated: `cc1_derived` with `t_exec_iff` makes a Quine-atom start and a ⊥ start one condition. On a carrier with a second point it is not forced (`ZeroParadox/Settheory/OntBridge.lean`). -`Reading:` the role encodes the ZF+AFA set Q = {Q}; that ⊥ is that set is CC-2's commitment. (NO-GO gauge below.) +`Reading:` the role encodes the ZF+AFA set Q = {Q}; no equation of ⊥ with that set is stated (it would be ill-typed). +In the die the Quine atom (CC-2) is the role `Motion.SelfOnlyAt`, whose occupancy is settled chart by chart +(`ZeroParadox/Settheory/QuineDichotomy.lean`). (NO-GO gauge below.) -/ namespace ZeroParadox @@ -39,7 +41,7 @@ open ZeroParadox Field (2) places ⊥ in the Quine-atom role (the lattice encoding of the ZF+AFA set Q = {Q}). T-EXEC follows from field (2) and its own hypothesis; field (1) is used by the converse. -/ --- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib's ZFSet uses the Axiom of Foundation, which forbids x ∈ x (ZFSet.mem_irrefl). No ZFSet element can satisfy x ∈ x, so a Quine atom is not directly available as a ZFSet; AFA content is still MODELLABLE over a well-founded universe, as Aczel does via decorations of accessible pointed graphs. AFAStructure is the lattice-level encoding of what ZF+AFA provides set-theoretically, with selfMem/quine_unique/bot_self_mem as the three minimal class fields. +-- [ZP-CUSTOM] no Mathlib analog | reason: Mathlib's ZFSet carries Foundation (ZFSet.mem_wf, a theorem about ZFSet, not an assumed axiom), which forbids x ∈ x (ZFSet.mem_irrefl). No ZFSet element can satisfy x ∈ x, so a Quine atom is not directly available as a ZFSet; AFA content is still MODELLABLE over a well-founded universe, as Aczel does via decorations of accessible pointed graphs. AFAStructure is the lattice-level encoding of what ZF+AFA provides set-theoretically, with selfMem/quine_unique/bot_self_mem as the three minimal class fields. class AFAStructure (L : Type*) [ZPSemilattice L] where /-- x plays the self-containment role; read in ZF+AFA, x = {x} (its own sole member). Not bare x ∈ x: under AFA, 0* = {∅, 0*} is self-membered and is not Ω (Aczel 1988, Example 1.5), diff --git a/ZeroParadox/Settheory/Wall.lean b/ZeroParadox/Settheory/Wall.lean index 7b1bf2a8..9c5c76e5 100644 --- a/ZeroParadox/Settheory/Wall.lean +++ b/ZeroParadox/Settheory/Wall.lean @@ -1,4 +1,5 @@ import Mathlib.SetTheory.ZFC.Basic +import ZeroParadox.Die /-! # Zero as a Wall — the self-loop refutation and the diagonal engine (formal object) @@ -81,8 +82,9 @@ theorem no_self_decider {A : Type*} (g : A → (A → Bool)) : ¬ Function.Surje exact bool_not_no_fixedpoint b hb /-- **THE WALL (general).** A well-founded relation admits no self-loop: no `x` with `r x x`. This is the - object-level core the metatheoretic boundary reduces to — the literal self-referential fixed point - (`x ∈ x`) cannot exist where the relation is well-founded. -/ + object-level core the metatheoretic boundary reduces to — no self-loop (`x ∈ x`) exists where the + relation is well-founded, and the literal self-referential fixed point `x = {x}` implies `x ∈ x`, so + it cannot exist there either. The implication cited runs from `x = {x}` to `x ∈ x`. -/ theorem wf_no_selfloop {α : Type*} {r : α → α → Prop} (h : WellFounded r) (x : α) : ¬ r x x := by have key : ∀ a, Acc r a → ¬ r a a := by intro a acc @@ -90,12 +92,50 @@ theorem wf_no_selfloop {α : Type*} {r : α → α → Prop} (h : WellFounded r) | intro y _ ih => exact fun hy => ih y hy hy exact key x (h.apply x) -/-- **Set-theoretic face.** Under Foundation (`∈` well-founded on `ZFSet`), no set is self-membered: the - literal Quine atom `⊥ = {⊥}` (`x ∈ x`) is refuted in-kernel. The structural shadow of the same object - IS realizable choice-free (`AbstractSelfApp`); only the literal membership self-loop is walled off. -/ +/-- **Set-theoretic face.** Under Foundation (`∈` well-founded on `ZFSet`), no set is self-membered + (`x ∉ x`). The literal Quine atom `⊥ = {⊥}` (`x = {x}`) would be self-membered, so it is refuted + in-kernel too (the `example` below); the implication runs from `x = {x}` to `x ∈ x`; for the converse + see `ZeroParadox/Settheory/Wall.md`. The structural shadow of the same object IS realizable choice-free (`AbstractSelfApp`); + only the literal membership self-loop is walled off. -/ theorem no_quine_atom (x : ZFSet) : x ∉ x := wf_no_selfloop ZFSet.mem_wf x +-- Statement: no `ZFSet` is its own singleton, from `no_quine_atom`. +example (x : ZFSet) : x ≠ {x} := by + intro h + have hx : x ∈ ({x} : ZFSet) := ZFSet.mem_singleton.2 rfl + rw [← h] at hx + exact no_quine_atom x hx + +/-- `Statement:` in the die motion on `ZFSet` with UP the identity and OVER `a ⟶ b` when `b ∈ a` + (a set steps to its members), `x` steps to itself and to nothing else (`Motion.SelfOnlyAt`) iff + `x = {x}`; both directions, the forward one by extensionality. `Reading:` the Quine-atom role + stated in the die. -/ +theorem zfset_selfOnlyAt_mem_iff (x : ZFSet) : + (Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => b ∈ a)).SelfOnlyAt x ↔ x = {x} := by + refine ⟨fun ⟨hx, hu⟩ => ZFSet.ext fun z => ?_, fun h => ⟨?_, fun b hb => ?_⟩⟩ + · rw [ZFSet.mem_singleton]; exact ⟨hu z, fun h => h ▸ hx⟩ + · have hs : x ∈ ({x} : ZFSet) := ZFSet.mem_singleton.2 rfl + rw [← h] at hs; exact hs + · rw [h] at hb; exact ZFSet.mem_singleton.1 hb + +/-- `Statement:` in that motion no `ZFSet` steps to itself and to nothing else, since none steps to + itself (`no_quine_atom`). -/ +theorem zfset_quine_role_unoccupied : + ¬ ∃ x : ZFSet, (Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => b ∈ a)).SelfOnlyAt x := + fun ⟨x, h⟩ => no_quine_atom x h.1 + +-- Statement: with OVER reversed (`a ⟶ b` when `a ∈ b`), `SelfOnlyAt x` unfolds, by definition, to +-- `x ∈ x` and `x` belonging to no other set. Reading: a different formula from `x = {x}`. +example (x : ZFSet) : + (Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => a ∈ b)).SelfOnlyAt x ↔ + (x ∈ x ∧ ∀ b, x ∈ b → b = x) := Iff.rfl +-- Statement: and no `ZFSet` occupies it, since none is its own member (`no_quine_atom`); so on +-- `ZFSet` this orientation does not separate the two formulas. +example (x : ZFSet) : + ¬ (Motion.ofTotal id (fun _ => rfl) (fun a b : ZFSet => a ∈ b)).SelfOnlyAt x := + fun h => no_quine_atom x h.1 + /-- **The wall, full strength.** A well-founded relation has no cycle of ANY length: no `x` is reachable from itself by one-or-more `r`-steps (`Relation.TransGen r x x`). `wf_no_selfloop` is the n=1 case; this also rules out 2-cycles, n-cycles — every cyclic self-reference. Proof: the transitive closure of @@ -121,6 +161,8 @@ open ZeroParadox #print axioms no_self_decider #print axioms wf_no_selfloop #print axioms no_quine_atom +#print axioms zfset_selfOnlyAt_mem_iff +#print axioms zfset_quine_role_unoccupied #print axioms wf_no_cycle #print axioms no_membership_cycle end PurityCheck diff --git a/ZeroParadox/Settheory/Wall.md b/ZeroParadox/Settheory/Wall.md index a11270d4..a2e03409 100644 --- a/ZeroParadox/Settheory/Wall.md +++ b/ZeroParadox/Settheory/Wall.md @@ -11,9 +11,25 @@ internalized.* ("Wall" is a flagged metaphor-nickname per the project idiom rule gloss.) Across five separate pushes (fork unification, the Quine atom CC-2, MC-1, "realization is the choice", -the faithfulness criterion) the framework keeps landing on the SAME boundary: a structural shadow Lean's -well-founded kernel CAN host, plus a metatheoretic residue it CANNOT. The Lean file represents that -boundary as an **object-level theorem**, the honest in-kernel face of it. +the faithfulness criterion) the framework keeps landing on the SAME boundary: a structural shadow (a +function fixed point, below) that Lean hosts, plus a metatheoretic residue, a statement about the system +rather than a Lean proposition (see the fences). The literal is refuted in the well-founded `ZFSet` +chart (`no_quine_atom` and the `x ≠ {x}` `example` after it in the Lean file). The die +(`ZeroParadox/Die.lean`) defines the predicate `SelfOnlyAt`, a point that steps to itself and to nothing +else; the corpus reads the Quine atom as that ROLE, and which charts occupy it are the theorems below. In +Aczel's terms it is the one-node graph with a single self-loop, which under AFA pictures Ω = {Ω} +(Aczel 1988, Ex. 1.3, p. 6); a set stepping to its members is his system V (p. 13), whose sets are those +of his own set theory, not Mathlib's well-founded `ZFSet`. The graph chart places it too +(`ZeroParadox/Settheory/HypersetOrder.lean` § VII: `omegaLoop_selfOnlyAt`, and, up to bisimulation, +`wrapMotion_omegaLoop_selfOnlyAt`, an instance of `wrapMotion_quot_selfOnlyAt_iff`). `Reading:` CARRIER — +of the two charts below, one occupies the role and one provably does not. In `ZFSet`, where a +set steps to its members, a set occupies it iff x = {x} (`zfset_selfOnlyAt_mem_iff`) and none does +(`zfset_quine_role_unoccupied`); in the coalgebra chart `Cofix idPF_Coalgebra.Obj`, where a point steps +to its children, `cofixSelf` occupies it (`cofix_quine_role_occupied`, +`ZeroParadox/Settheory/Coalgebra.lean`). That chart has one point (`cofixSelf` exists, and +`cofix_subsingleton` allows at most one), so its occupancy is the one-node loop; the contrast it carries +is `categorical_fork_strict`. No equation across the two carriers is stated. The Lean file represents that boundary as an **object-level theorem**, the +honest in-kernel face of it. ## What the wall reduces to (the provable core) @@ -21,13 +37,22 @@ The keystone (the diagonal fixed point) has two encodings: - **The SHADOW** — `selfApp x = x`: a FUNCTION fixed point. Compatible with well-foundedness, hostable in Lean, proved choice-free (`AbstractSelfApp` / `selfMem_eq_singleton_bot`, [propext, Quot.sound]). -- **The LITERAL** — `x ∈ x` (= `r x x`): a RELATION self-loop. **Forbidden by well-foundedness.** This is - the Quine atom ⊥={⊥}; it cannot live in a well-founded foundation. +- **The LITERAL** — the Quine atom ⊥={⊥}, which implies the RELATION self-loop `x ∈ x` (= `r x x`) + (x = {x} implies x ∈ x; the converse fails under AFA: Aczel 1988 Example 1.5 gives a witness, the + set x = {∅, x}, with x ∈ x and x ≠ {x}). **The self-loop is + forbidden by well-foundedness**, so the Quine atom cannot live in a well-founded foundation. So the wall is exactly: **a well-founded relation admits no self-loop.** That one theorem explains why the -shadow is hostable/choice-free and the literal is not — and why Lean's kernel (well-founded by -construction) can only ever realize the shadow. The set-theoretic instance is "no self-membered set under -Foundation," the in-kernel refutation of the literal Quine atom. +shadow is hostable and choice-free, and the literal is not hostable in a well-founded carrier. + +`Statement:` **CARRIER** — scope, in two charts: in Mathlib's `ZFSet`, whose membership is well-founded +(`ZFSet.mem_wf`), no set is a member of itself (`no_quine_atom`); but Lean does build a +non-well-founded fixed point in the coalgebra chart, where the final coalgebra `Cofix` is inhabited +while the initial algebra is empty (`categorical_fork_strict`, `ZeroParadox/Settheory/Coalgebra.lean`). +The set-theoretic instance is "no self-membered set under Foundation," the in-kernel refutation of the +literal Quine atom in `ZFSet`. Separately, at the level of types, Cantor is `cantor_via_engine` +(`ZeroParadox/Settheory/Wall.lean`), whose `#check` reads +`∀ {A : Type u_1} (g : A → A → Prop), ¬Function.Surjective g`. ## Honest fences (do not overclaim) @@ -46,11 +71,16 @@ Foundation," the in-kernel refutation of the literal Quine atom. ## Prior art and library overlap (cite, do not reinvent) -- The diagonal-family unification — Cantor / Russell / Gödel / Turing / Tarski as one diagonal argument via - a single fixed-point theorem — is **Lawvere (1969)**, "Diagonal Arguments and Cartesian Closed Categories" - (LNM 92, pp. 134–145; TAC Reprint 15, 2006), and **Yanofsky (2003)**, "A Universal Approach to - Self-Referential Paradoxes, Incompleteness and Fixed Points" (Bull. Symbolic Logic 9(3):362–386; - arXiv:math/0305282). The unification is THEIRS; the Lean file formalizes it and links it to ⊥. +- The diagonal-family unification — Cantor, Russell, Gödel, Turing and Tarski's arguments as one diagonal + argument via a single fixed-point theorem — is two authors' work, and the cases are credited + separately. **Lawvere (1969)**, "Diagonal Arguments and Cartesian Closed Categories" (LNM 92, + pp. 134–145; TAC Reprint 15, 2006), treats Cantor, Russell, Tarski's undefinability of truth and an + abstract "incompleteness theorem" (his quotation marks, reprint p. 11); his introduction + (reprint p. 3) names Cantor, Russell, Gödel and Tarski, and Turing and the halting problem were not + located in our copy of the reprint (text search, 2026-11-01). **Yanofsky (2003)**, "A Universal Approach + to Self-Referential Paradoxes, Incompleteness and Fixed Points" (Bull. Symbolic Logic 9(3):362–386; + arXiv:math/0305282), adds Turing's halting problem (arXiv v1 pp. 11–12), the recursion theorem (p. 18) + and Rice's theorem (p. 19). The unification is THEIRS; the Lean file formalizes it and links it to ⊥. - The point-surjective theorem is already in **Mathlib**: `Function.exists_fixed_point_of_surjective` (its own docstring calls it an instance of Lawvere's fixed-point theorem), with `Function.cantor_surjective` for Cantor. `lawvere_fixedpoint` and `cantor_via_engine` are independent axiom-free re-derivations, @@ -90,8 +120,10 @@ what makes the following free: given point. ⚠ Its *extract-a-chain* direction builds the sequence with `.choose_spec` and so carries `Classical.choice`. **⚠ The natural inference — "supply the witness yourself and use only the other direction to stay choice-free" — is FALSE, and was MEASURED false**: `#print axioms` - follows the STATEMENT, so citing the biconditional at all pulls in the choice used by the direction - you did not take. Measured on `bot_not_acc` (`ZeroParadox/Multihomed/Boundary.lean`): the one-line + follows the statement AND the proof term of every constant cited, and a biconditional is one constant + whose proof term carries both directions, so citing it at all pulls in the choice used by the + direction you did not take. (The statement half is real too, but it is not the mechanism here; the + same split is stated at `ZeroParadox/Multihomed/Boundary.md`, § "The descent route".) Measured on `bot_not_acc` (`ZeroParadox/Multihomed/Boundary.lean`): the one-line `not_acc_iff_exists_descending_chain.mpr` route came back `[propext, Classical.choice, Quot.sound]`, and only the HAND proof from `fixed_bot` came back axiom-free. (Verified at source 2026-07-29. Line numbers deliberately omitted: a line number is a copy of a location and drifts — the lemma name is the stable anchor and is `#check`-able.) @@ -144,8 +176,11 @@ The involutive-fork witnesses — `InvolutiveFork`, `collapsed_iff_fixed`, `whee `fixed_pole_forces_collapse` and `collapsed_iff_fixed` depend on no axioms; the two wheel-of-fractions instances are `[propext, Quot.sound]`. -`lawvere_fixedpoint` (axiom-free) is the GENERAL theorem unifying the **diagonal family** — Cantor and -Russell are its corollaries, triggered by the engine (`Not` is fixed-point-free). Within the diagonal family +`lawvere_fixedpoint` (axiom-free) is the GENERAL theorem unifying the **diagonal family** — Russell +(`russell_via_engine`) and the decider diagonal (`no_self_decider`) are proved through it, triggered by the +engine (`Not`, resp. Boolean negation, is fixed-point-free); Cantor is the same contrapositive at +`B = Prop`, a corollary of it at `Not`, and the Lean proof (`cantor_via_engine`) inlines that step, +calling the engine `negation_no_fixedpoint` directly. Within the diagonal family this is a real unification *theorem*, not the grand conjecture; the well-founded family is proved by a different mechanism (induction), and whether it folds in too is the open one-root-or-two question. @@ -191,8 +226,10 @@ by accessibility, not by the engine (`selfloop_permitted` / `engine_is_wf_free` The failure SIGNATURE changes with the conditions — distinct ways the one self-reference resists internalization, not one failure repeated. The formal/metatheoretic frontier is itself part of the map: -`x∉x`, ε₀∉ONote, no-self-loop are in-kernel; the cross-category identity (MC-1's identity half) and the -literal AFA universe are metatheoretic-only. +`x∉x`, ε₀∉ONote, no-self-loop are in-kernel; the cross-category identity (MC-1's identity half) is +retired as ill-typed, and what relates the charts is stated instead as one die role, which a point of +each chart occupies or provably none does +(the Quine-atom role above); the literal AFA universe is metatheoretic-only. **The computability row is the pivot (2026-06-27).** It is the ONLY framework where the fixed point is NOT refuted/unreachable but provably EXISTS — `infinite_quine_family` gives infinitely many. ⚠ **Carry diff --git a/ZeroParadox/State/ThreeCarrierLeaf.lean b/ZeroParadox/State/ThreeCarrierLeaf.lean index ea6ea60e..00ab7dc0 100644 --- a/ZeroParadox/State/ThreeCarrierLeaf.lean +++ b/ZeroParadox/State/ThreeCarrierLeaf.lean @@ -125,7 +125,7 @@ noncomputable instance padic_floor_unique_ThreeCarrierLeaf : Unique padicFloor_T /-- #2 carrier is a one-element space: `stdSimplex ℝ (Fin 1) = {fun _ ↦ 1}`. -/ noncomputable instance simplex_point_unique_ThreeCarrierLeaf : Unique simplexPoint_ThreeCarrierLeaf := by have h : stdSimplex ℝ (Fin 1) = {fun _ ↦ (1 : ℝ)} := stdSimplex_unique ℝ (Fin 1) - have e : simplexPoint_ThreeCarrierLeaf ≃ ↥({fun _ ↦ (1 : ℝ)} : Set (Fin 1 → ℝ)) := Equiv.setCongr h + have e : simplexPoint_ThreeCarrierLeaf ≃ ↥({fun _ ↦ (1 : ℝ)} : Set (Fin 1 → ℝ)) := Set.equivOfEq h exact e.unique /-- #5 carrier is a one-element space: `EuclideanSpace ℂ (Fin 0)` has only `0`. -/ diff --git a/ZeroParadox/Valuation/BallLine.lean b/ZeroParadox/Valuation/BallLine.lean new file mode 100644 index 00000000..310eb663 --- /dev/null +++ b/ZeroParadox/Valuation/BallLine.lean @@ -0,0 +1,371 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the line of closed balls about 0 of `ℚ_[2]`, indexed by `ℤ`, its covers, its two ends, and the radius chart. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Valuation.PoleCornersBridge +import ZeroParadox.Valuation.TopFunctor +import ZeroParadox.Valuation.InversionValuation +import ZeroParadox.Reals.OrderedField +import Mathlib.Data.Int.Log +import Mathlib.Data.ENNReal.Inv +import Mathlib.Topology.Path +import Mathlib.Topology.DerivedSet +import Mathlib.Tactic + +set_option maxHeartbeats 400000 + +/-! +# The line of closed balls about 0 of `ℚ_[2]`: a cover at every vertex, none at either end + +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. + +--- + +## Formal Overview (AI-assisted) +`ballLine n`, the closed ball of radius `2^(-n)` about 0 of `ℚ_[2]`, `n : ℤ`. § I: membership is the +valuation. § II: shells, the arc, inversion. § III: covers at vertices, none at the ends. § IV: radii +in `ℝ≥0∞`, a path with no cover, read back onto vertices. § V: radii isolated, accumulating at 0, ⊤. +-/ + +namespace ZeroParadox + +/-! ### § I. The line: one closed ball per integer, membership read off the valuation + +Standard object, not built here: the vertices correspond to those of the apartment between the ends +0 and ∞ of the Bruhat–Tits tree of ℚ₂ (Serre, *Trees*, II.1; Casselman, *The Bruhat–Tits tree of +SL(2)*, §7; the rooted tree of balls of ℤ₂ is `ZeroParadox/Valuation/PadicTree.lean`). -/ + +/-- `Statement:` vertex `n`: the closed ball of radius `2 ^ (-n)` about 0 of `ℚ_[2]`. -/ +noncomputable def ballLine (n : ℤ) : Set ℚ_[2] := Metric.closedBall (0 : ℚ_[2]) ((2 : ℝ) ^ (-n)) + +-- Statement: at `n : ℕ` it is the ball tower `q2Ball n` (`ZeroParadox/Valuation/TopFunctor.lean`). +example (n : ℕ) : ballLine n = q2Ball n := rfl + +/-- `Statement:` a nonzero `x` lies in `ballLine n` iff `n ≤ x.valuation`. The `ℕ`-indexed sibling on + `ℤ_[2]` is Mathlib's `PadicInt.norm_le_pow_iff_le_valuation`. -/ +theorem mem_ballLine_iff_le_valuation {x : ℚ_[2]} (hx : x ≠ 0) (n : ℤ) : + x ∈ ballLine n ↔ n ≤ x.valuation := by + rw [ballLine, Metric.mem_closedBall, dist_zero_right, Padic.norm_eq_zpow_neg_valuation hx] + push_cast + rw [zpow_le_zpow_iff_right₀ (by norm_num : (1 : ℝ) < 2)] + omega + +/-- `Statement:` `ballLine` is strictly antitone: a larger index gives a strictly smaller ball. -/ +theorem ballLine_strictAnti : StrictAnti ballLine := by + intro a b hab + have h2 : ∀ k : ℤ, (2 : ℚ_[2]) ^ k ≠ 0 := fun k => zpow_ne_zero _ two_ne_zero + have hv : ∀ k : ℤ, ((2 : ℚ_[2]) ^ k).valuation = k := fun k => by + rw [Padic.valuation_zpow, (by simp : (2 : ℚ_[2]).valuation = 1), mul_one] + refine ⟨Metric.closedBall_subset_closedBall + (zpow_le_zpow_right₀ (by norm_num : (1 : ℝ) ≤ 2) (by omega)), fun h => ?_⟩ + have := (mem_ballLine_iff_le_valuation (h2 a) b).1 + (h ((mem_ballLine_iff_le_valuation (h2 a) a).2 (hv a).ge)) + rw [hv] at this + omega + +-- Statement: the balls meet in `{0}`, by `fB_bottom_is_limit` on the `ℕ` half. +example : (⋂ n : ℤ, ballLine n) = {0} := by + refine Set.Subset.antisymm (fun x hx => ?_) ?_ + · rw [← fB_bottom_is_limit] + exact Set.mem_iInter.2 fun n : ℕ => Set.mem_iInter.1 hx (n : ℤ) + · rintro x rfl + exact Set.mem_iInter.2 fun n => Metric.mem_closedBall_self (by positivity) + +/-- `Statement:` the balls cover `ℚ_[2]`. -/ +theorem iUnion_ballLine : (⋃ n : ℤ, ballLine n) = Set.univ := by + refine Set.eq_univ_of_forall fun x => Set.mem_iUnion.2 ?_ + by_cases hx : x = 0 + · exact ⟨0, hx ▸ Metric.mem_closedBall_self (by positivity)⟩ + · exact ⟨x.valuation, (mem_ballLine_iff_le_valuation hx _).2 le_rfl⟩ + +/-! ### § II. Shells, the arc's stages, and inversion -/ + +/-- `Statement:` the shell `ballLine n \ ballLine (n + 1)` is the set of nonzero points of valuation + `n`. -/ +theorem mem_ballLine_shell_iff (x : ℚ_[2]) (n : ℤ) : + x ∈ ballLine n \ ballLine (n + 1) ↔ x ≠ 0 ∧ x.valuation = n := by + by_cases hx : x = 0 + · subst hx + simp only [Set.mem_diff, ne_eq, not_true_eq_false, false_and, iff_false, not_and, not_not] + exact fun _ => Metric.mem_closedBall_self (by positivity) + · rw [Set.mem_diff, mem_ballLine_iff_le_valuation hx, mem_ballLine_iff_le_valuation hx] + constructor + · rintro ⟨h1, h2⟩; exact ⟨hx, by omega⟩ + · rintro ⟨-, h⟩; omega + +/-- `Statement:` the `cnfToZp2` image of `towerNONote (n + 1)`, read in `ℚ_[2]`, lies in the shell at + vertex `n + 1`. -/ +theorem arc_walks_ballLine (n : ℕ) : + ((cnfToZp2 (towerNONote (n + 1)) : ℤ_[2]) : ℚ_[2]) ∈ + ballLine ((n : ℤ) + 1) \ ballLine ((n : ℤ) + 1 + 1) := by + have hstage : cnfToZp2 (towerNONote (n + 1)) = (2 : ℤ_[2]) ^ (n + 1) := by + rw [towerNONote_succ_eq, cnfToZp2_omegaPowNote, towerImageStep, cnfToZp2_tower_valuation] + have hc : (((2 : ℤ_[2]) ^ (n + 1) : ℤ_[2]) : ℚ_[2]) = (2 : ℚ_[2]) ^ ((n : ℤ) + 1) := by + rw [PadicInt.coe_pow]; norm_cast + rw [hstage, hc, mem_ballLine_shell_iff] + exact ⟨zpow_ne_zero _ two_ne_zero, + by rw [Padic.valuation_zpow, (by simp : (2 : ℚ_[2]).valuation = 1), mul_one]⟩ + +-- Statement: stage 0 is 0 of `ℚ_[2]` (`snap_arc_z2_loop`), which lies in every vertex. +example (n : ℤ) : ((cnfToZp2 (towerNONote 0) : ℤ_[2]) : ℚ_[2]) ∈ ballLine n := by + rw [snap_arc_z2_loop.1, PadicInt.coe_zero] + exact Metric.mem_closedBall_self (by positivity) + +/-- `Statement:` `x ↦ x⁻¹` maps the shell at `n` onto the shell at `-n`. The sublevel form is + `inversion_reverses_filtration`. -/ +theorem ballLine_inv_shell (n : ℤ) : + (fun x : ℚ_[2] => x⁻¹) '' (ballLine n \ ballLine (n + 1)) = + ballLine (-n) \ ballLine (-n + 1) := by + ext y + simp only [Set.mem_image] + constructor + · rintro ⟨x, hx, rfl⟩ + rw [mem_ballLine_shell_iff] at hx ⊢ + exact ⟨inv_ne_zero hx.1, by rw [Padic.valuation_inv, hx.2]⟩ + · intro hy + rw [mem_ballLine_shell_iff] at hy + refine ⟨y⁻¹, ?_, inv_inv y⟩ + rw [mem_ballLine_shell_iff] + exact ⟨inv_ne_zero hy.1, by rw [Padic.valuation_inv, hy.2, neg_neg]⟩ + +-- Statement: in `ℚ_[2]` inversion fixes 0 (`inv_zero`). +example : (0 : ℚ_[2])⁻¹ = 0 := inv_zero + +-- Statement: `n ↦ -n` reverses inclusion of vertices. +example (a b : ℤ) : ballLine a ⊆ ballLine b ↔ ballLine (-b) ⊆ ballLine (-a) := by + change ballLine a ≤ ballLine b ↔ ballLine (-b) ≤ ballLine (-a) + rw [ballLine_strictAnti.le_iff_ge, ballLine_strictAnti.le_iff_ge]; omega + +/-! ### § III. Covers at every vertex; none leaving either end -/ + +/-- `Statement:` in the vertex set `Set.range ballLine` under inclusion, `ballLine (n + 1)` is covered + by `ballLine n`. -/ +theorem ballLine_covBy (n : ℤ) : + (⟨ballLine (n + 1), n + 1, rfl⟩ : Set.range ballLine) ⋖ ⟨ballLine n, n, rfl⟩ := by + refine ⟨Subtype.mk_lt_mk.2 (ballLine_strictAnti (by omega)), ?_⟩ + rintro ⟨_, m, rfl⟩ h1 h2 + have h1' : ballLine (n + 1) < ballLine m := h1 + have h2' : ballLine m < ballLine n := h2 + rw [ballLine_strictAnti.lt_iff_gt] at h1' h2' + omega + +-- Statement: so every vertex has a first step (`HasFirstStep`). +example (n : ℤ) : HasFirstStep (⟨ballLine n, n, rfl⟩ : Set.range ballLine) := + ⟨_, by simpa using ballLine_covBy (n - 1)⟩ + +-- Statement: the vertex set is order-isomorphic to `ℤᵒᵈ` (Mathlib's `StrictMono.orderIso`). +noncomputable example : ℤᵒᵈ ≃o Set.range (ballLine ∘ OrderDual.ofDual) := + StrictMono.orderIso _ ballLine_strictAnti.dual_left + +/-- `Statement:` in `WithBot (WithTop ℤ)`, the line with both ends adjoined, ⊥ has no first step. -/ +theorem end_bot_no_first_step : ¬ HasFirstStep (⊥ : WithBot (WithTop ℤ)) := by + rintro ⟨a, ha⟩ + induction a using WithBot.recBotCoe with + | bot => exact lt_irrefl _ ha.1 + | coe b => exact not_isMin b (WithBot.bot_covBy_coe.1 ha) + +/-- `Statement:` in `WithBot (WithTop ℤ)`, nothing is covered by ⊤. -/ +theorem end_top_covers_nothing : ¬ ∃ b : WithBot (WithTop ℤ), b ⋖ ⊤ := by + rintro ⟨b, hb⟩ + induction b using WithBot.recBotCoe with + | bot => exact end_bot_no_first_step ⟨_, hb⟩ + | coe b => + induction b using WithTop.recTopCoe with + | top => exact lt_irrefl _ hb.1 + | coe k => exact not_isMax k (WithTop.coe_covBy_top.1 (WithBot.coe_covBy_coe.1 hb)) + +/-! ### § IV. The radius chart: a path between the ends, no cover, collapse onto the vertices + +Standard object, not built here: the radius order is the union of Baker–Rumely's lines of discs +about 0 (arXiv:math/0407433, §1 p. 8 for [r, 1], §2 p. 21 for general radii), with the end ∞ the +point ∞ of the Berkovich projective line. -/ + +/-- `Statement:` for `r > 0`, `closedBall 0 r = ballLine (-(Int.log 2 r))` in `ℚ_[2]`. -/ +theorem closedBall_eq_ballLine {r : ℝ} (hr : 0 < r) : + Metric.closedBall (0 : ℚ_[2]) r = ballLine (-(Int.log 2 r)) := by + ext x + rw [ballLine, Metric.mem_closedBall, Metric.mem_closedBall, dist_zero_right, neg_neg] + have hlo : (2 : ℝ) ^ (Int.log 2 r) ≤ r := by + have := Int.zpow_log_le_self (R := ℝ) (b := 2) (by norm_num) hr; exact_mod_cast this + have hhi : r < (2 : ℝ) ^ (Int.log 2 r + 1) := by + have := Int.lt_zpow_succ_log_self (R := ℝ) (b := 2) (by norm_num) r; exact_mod_cast this + by_cases hx : x = 0 + · subst hx; simp only [norm_zero]; exact ⟨fun _ => by positivity, fun _ => hr.le⟩ + · rw [Padic.norm_eq_zpow_neg_valuation hx]; push_cast + constructor + · intro h + have hv : -x.valuation ≤ Int.log 2 r := by + by_contra hc + have := zpow_le_zpow_right₀ (by norm_num : (1 : ℝ) ≤ 2) (by omega : Int.log 2 r + 1 ≤ -x.valuation) + linarith + exact zpow_le_zpow_right₀ (by norm_num : (1 : ℝ) ≤ 2) hv + · exact fun h => le_trans h hlo + +-- Statement: radius 0 gives `{0}`. +example : Metric.closedBall (0 : ℚ_[2]) 0 = {0} := Metric.closedBall_zero + +/-- `Statement:` a path in `ℝ≥0∞` from 0 to ⊤, through `ENNReal.orderIsoUnitIntervalBirational`. -/ +noncomputable def radiusPath : Path (0 : ENNReal) ⊤ where + toFun t := ENNReal.orderIsoUnitIntervalBirational.symm t + continuous_toFun := ENNReal.orderIsoUnitIntervalBirational.symm.toHomeomorph.continuous + source' := ENNReal.orderIsoUnitIntervalBirational.symm.map_bot + target' := ENNReal.orderIsoUnitIntervalBirational.symm.map_top + +-- Statement: control, `ℝ≥0∞` is densely ordered, so 0 has no first step there +-- (`axb1_fails_everywhere_iff_dense`). +example : ¬ HasFirstStep (0 : ENNReal) := axb1_fails_everywhere_iff_dense.1 inferInstance 0 + +-- Statement: the two orders side by side. In `WithBot (WithTop ℤ)` every `n : ℤ` has a first step, ⊥ +-- has none, ⊤ covers nothing and ⊥ ≠ ⊤; in `ℝ≥0∞` a path runs from 0 to ⊤ and 0 has no first step. +example : (∀ n : ℤ, HasFirstStep ((n : WithTop ℤ) : WithBot (WithTop ℤ))) ∧ + ¬ HasFirstStep (⊥ : WithBot (WithTop ℤ)) ∧ (¬ ∃ b : WithBot (WithTop ℤ), b ⋖ ⊤) ∧ + (⊥ : WithBot (WithTop ℤ)) ≠ ⊤ ∧ + Nonempty (Path (0 : ENNReal) ⊤) ∧ ¬ HasFirstStep (0 : ENNReal) := + ⟨fun n => ⟨_, WithBot.coe_covBy_coe.2 (WithTop.coe_covBy_coe.2 (Order.covBy_succ n))⟩, + end_bot_no_first_step, end_top_covers_nothing, bot_ne_top, ⟨radiusPath⟩, + axb1_fails_everywhere_iff_dense.1 inferInstance 0⟩ +-- Reading: CARRIER. Indexed as `ballLine`'s `n`, ⊤ of `WithBot (WithTop ℤ)` stands at the `{0}` end and +-- ⊥ at the `ℚ_[2]` end; the two ends are distinct and neither is reached from a vertex by a cover. Of +-- the two orders here, the first has a cover at every vertex and none at either end, the second joins +-- its ends by a path and has no cover at 0; read back as balls, a positive radius lands on a vertex +-- (`closedBall_eq_ballLine`). Neither of the two has both a passage between its ends and a first step. + +/-! ### § V. The radii in `ℝ≥0∞`: isolated points, accumulating only at 0 and ⊤ -/ + +section RungRadii +open Filter Topology + +/-- `Statement:` in a linear order with its order topology, a strictly monotone `g : ℤ → X` has no + accumulation point at any `x` with `g k ≤ x < g (k + 1)`. -/ +theorem not_accPt_range_of_strictMono {X : Type*} [LinearOrder X] [TopologicalSpace X] + [OrderTopology X] {g : ℤ → X} (hg : StrictMono g) {x : X} {k : ℤ} + (hlo : g k ≤ x) (hhi : x < g (k + 1)) : ¬ AccPt x (𝓟 (Set.range g)) := by + rw [accPt_iff_frequently, not_frequently] + have hU : ∀ᶠ z in 𝓝 x, z ∈ Set.Ioo (g (k - 1)) (g (k + 1)) := + isOpen_Ioo.mem_nhds ⟨lt_of_lt_of_le (hg (by omega)) hlo, hhi⟩ + have hR : ∀ z ∈ Set.Ioo (g (k - 1)) (g (k + 1)), z ∈ Set.range g → z = g k := by + rintro _ ⟨h1, h2⟩ ⟨m, rfl⟩ + rw [hg.lt_iff_lt] at h1 h2 + rw [show m = k by omega] + by_cases hx : x = g k + · filter_upwards [hU] with z hz h + exact h.1 (hx ▸ hR z hz h.2) + · filter_upwards [hU, eventually_ne_nhds hx] with z hz hzk h + exact hzk (hR z hz h.2) + +/-- `Statement:` the radii of the vertices, `{2 ^ (-n) | n : ℤ}` in `ℝ≥0∞`. -/ +def ballRadii : Set ENNReal := Set.range fun n : ℤ => (2 : ENNReal) ^ (-n) + +/-- `Statement:` the accumulation points of `ballRadii` in `ℝ≥0∞` are exactly 0 and ⊤ of `ℝ≥0∞`. -/ +theorem accPt_ballRadii_iff (x : ENNReal) : AccPt x (𝓟 ballRadii) ↔ x = 0 ∨ x = ⊤ := by + have hc : ∀ k : ℤ, (((2 : NNReal) ^ k : NNReal) : ENNReal) = (2 : ENNReal) ^ k := fun k => by + rw [ENNReal.coe_zpow two_ne_zero]; rfl + have hmono : StrictMono fun k : ℤ => (((2 : NNReal) ^ k : NNReal) : ENNReal) := fun a b h => + ENNReal.coe_lt_coe.2 (zpow_lt_zpow_right₀ (by norm_num : (1 : NNReal) < 2) h) + have hR : ballRadii = Set.range fun k : ℤ => (((2 : NNReal) ^ k : NNReal) : ENNReal) := by + ext y; constructor + · rintro ⟨n, rfl⟩; exact ⟨-n, hc _⟩ + · rintro ⟨k, rfl⟩ + exact ⟨-k, show (2 : ENNReal) ^ (-(-k)) = _ by rw [neg_neg]; exact (hc k).symm⟩ + have hne0 : ∀ k : ℤ, (2 : ENNReal) ^ k ≠ 0 := fun k => by + rw [← hc]; exact ENNReal.coe_ne_zero.2 (zpow_ne_zero _ two_ne_zero) + have hneT : ∀ k : ℤ, (2 : ENNReal) ^ k ≠ ⊤ := fun k => by rw [← hc]; exact ENNReal.coe_ne_top + have ht0 : Tendsto (fun n : ℕ => (2 : ENNReal) ^ (-(n : ℤ))) atTop (𝓝 0) := by + refine (ENNReal.tendsto_pow_atTop_nhds_zero_of_lt_one (r := (2 : ENNReal)⁻¹) + (by norm_num)).congr fun n => ?_ + rw [ENNReal.zpow_neg, zpow_natCast, ENNReal.inv_pow] + refine ⟨fun h => ?_, ?_⟩ + · by_contra hx + push Not at hx + rw [hR] at h + have hy : ((x.toNNReal : NNReal) : ENNReal) = x := ENNReal.coe_toNNReal hx.2 + have hy0 : 0 < x.toNNReal := ENNReal.toNNReal_pos hx.1 hx.2 + refine not_accPt_range_of_strictMono hmono (k := Int.log 2 x.toNNReal) ?_ ?_ h + · rw [← hy]; exact ENNReal.coe_le_coe.2 (Int.zpow_log_le_self (by norm_num) hy0) + · rw [← hy]; exact ENNReal.coe_lt_coe.2 (Int.lt_zpow_succ_log_self (by norm_num) _) + · rw [accPt_iff_frequently] + rintro (rfl | rfl) + · exact ht0.frequently (Frequently.of_forall fun n => ⟨hne0 _, n, rfl⟩) + · have ht : Tendsto (fun n : ℕ => ((2 : ENNReal) ^ (-(n : ℤ)))⁻¹) atTop (𝓝 ⊤) := by + rw [← ENNReal.inv_zero]; exact tendsto_inv_iff.2 ht0 + refine ht.frequently (Frequently.of_forall fun n => ⟨?_, -n, ?_⟩) + · rw [← ENNReal.zpow_neg]; exact hneT _ + · simp only [neg_neg]; rw [ENNReal.zpow_neg, inv_inv] + +/-- `Statement:` every point of `ballRadii` is isolated in it: `ballRadii` is a discrete subspace. -/ +theorem ballRadii_discrete : DiscreteTopology ballRadii := by + rw [discreteTopology_subtype_iff] + rintro x ⟨n, rfl⟩ + have h : ¬ AccPt ((2 : ENNReal) ^ (-n)) (𝓟 ballRadii) := by + rw [accPt_ballRadii_iff] + rintro (h | h) + · exact absurd h (ENNReal.zpow_pos two_ne_zero ENNReal.ofNat_ne_top _).ne' + · exact absurd h (ENNReal.zpow_lt_top two_ne_zero ENNReal.ofNat_ne_top _).ne + rwa [AccPt, not_neBot] at h + +-- Statement: so the derived set of `ballRadii` is `{0, ⊤}`, and its closure adds exactly those two. +example : derivedSet ballRadii = {0, ⊤} := by + ext x; simp [derivedSet, accPt_ballRadii_iff] +example : closure ballRadii = ballRadii ∪ {0, ⊤} := by + rw [closure_eq_self_union_derivedSet] + congr 1; ext x; simp [derivedSet, accPt_ballRadii_iff] + +-- Statement: inversion of `ℝ≥0∞` maps `ballRadii` into itself (`n ↦ -n`) and exchanges 0 and ⊤. +example : (∀ r ∈ ballRadii, r⁻¹ ∈ ballRadii) ∧ (0 : ENNReal)⁻¹ = ⊤ ∧ (⊤ : ENNReal)⁻¹ = 0 := + ⟨by rintro _ ⟨n, rfl⟩; exact ⟨-n, ENNReal.zpow_neg 2 (-n)⟩, ENNReal.inv_zero, ENNReal.inv_top⟩ + +-- Statement: the radius `2 ^ (-n)` of `ballRadii`, read in `ℝ`, is the radius of `ballLine n`. +example (n : ℤ) : Metric.closedBall (0 : ℚ_[2]) ((2 : ENNReal) ^ (-n)).toReal = ballLine n := by + have h : (2 : ENNReal) ^ (-n) = (((2 : NNReal) ^ (-n) : NNReal) : ENNReal) := by + rw [ENNReal.coe_zpow two_ne_zero]; rfl + rw [ballLine, h, ENNReal.coe_toReal, NNReal.coe_zpow, NNReal.coe_ofNat] + +-- Statement: control, `ℤ` in `ℝ` has no accumulation point at all. +example (x : ℝ) : ¬ AccPt x (𝓟 (Set.range ((↑) : ℤ → ℝ))) := + not_accPt_range_of_strictMono Int.cast_strictMono (k := ⌊x⌋) (Int.floor_le x) + (by push_cast; exact Int.lt_floor_add_one x) +-- Statement: control, every point of `ℝ≥0∞` is an accumulation point of `ℝ≥0∞`. +example (x : ENNReal) : AccPt x (𝓟 Set.univ) := by + rw [AccPt, principal_univ, inf_top_eq]; infer_instance + +-- Statement: side by side: `ballRadii` accumulates exactly at 0 and ⊤ of `ℝ≥0∞`; in +-- `WithBot (WithTop ℤ)` ⊥ has no first step and ⊤ covers nothing; every positive real radius is a +-- vertex. +example : (∀ x : ENNReal, AccPt x (𝓟 ballRadii) ↔ x = 0 ∨ x = ⊤) ∧ + ¬ HasFirstStep (⊥ : WithBot (WithTop ℤ)) ∧ (¬ ∃ b : WithBot (WithTop ℤ), b ⋖ ⊤) ∧ + ∀ r : ℝ, 0 < r → Metric.closedBall (0 : ℚ_[2]) r = ballLine (-(Int.log 2 r)) := + ⟨accPt_ballRadii_iff, end_bot_no_first_step, end_top_covers_nothing, + fun _ hr => closedBall_eq_ballLine hr⟩ +-- Reading: CARRIER. The radius `2 ^ (-n)` sends the `ℚ_[2]` end, ⊥ of `WithBot (WithTop ℤ)`, toward ⊤ +-- of `ℝ≥0∞`, and the `{0}` end, ⊤ there, toward 0 of `ℝ≥0∞`. The rungs are discrete away from the two +-- ends and accumulate only at them, and those two ends are where the index order has no cover; `ℤ` in +-- `ℝ` accumulates nowhere because `ℝ` has no ends; `ENNReal.logHomeomorph` carries `ballRadii` to a +-- copy of `ℤ` in `EReal`, so the two accumulation points are the two adjoined ends. 0 and ⊤ of `ℝ≥0∞` are distinct (`zero_ne_top`); inversion exchanges them. No first step is +-- supplied. + +end RungRadii + +end ZeroParadox + +/-! ## Axiom Purity Check -/ +section PurityCheck +open ZeroParadox +#print axioms ballLine +#print axioms mem_ballLine_iff_le_valuation +#print axioms ballLine_strictAnti +#print axioms iUnion_ballLine +#print axioms mem_ballLine_shell_iff +#print axioms arc_walks_ballLine +#print axioms ballLine_inv_shell +#print axioms ballLine_covBy +#print axioms end_bot_no_first_step +#print axioms end_top_covers_nothing +#print axioms closedBall_eq_ballLine +#print axioms radiusPath +#print axioms not_accPt_range_of_strictMono +#print axioms ballRadii +#print axioms accPt_ballRadii_iff +#print axioms ballRadii_discrete +end PurityCheck diff --git a/ZeroParadox/Valuation/BottomInvariant.lean b/ZeroParadox/Valuation/BottomInvariant.lean index 4f89d32d..304bae64 100644 --- a/ZeroParadox/Valuation/BottomInvariant.lean +++ b/ZeroParadox/Valuation/BottomInvariant.lean @@ -146,7 +146,7 @@ theorem attractor_sameShape : SameShapeFromAnywhere (fun x : Q₂ => 2 * x) := b intro N have htend : Tendsto (fun n : ℕ => (fun y : Q₂ => 2 * y)^[N + n] x) atTop (𝓝 0) := by have h := (doubling_orbit_tendsto_zero x).comp (tendsto_add_atTop_nat N) - simpa [hiter, Function.comp, add_comm] using h + simpa [hiter, Function.comp_def, add_comm] using h exact mem_closure_of_tendsto htend (Filter.Eventually.of_forall fun _ => Set.mem_range_self _) · -- uniqueness: y in every N-tail closure ⇒ ‖y‖ ≤ ‖2‖^N‖x‖ ∀N ⇒ y = 0 intro y hy @@ -184,19 +184,19 @@ structure BottomInvariantKernel (X : Type*) [Fintype X] where /-- one Markov step leaves `μ` invariant -/ stationary : μ.bind κ = μ -/-- The **stochastic (Markov) face**: the full-mixing doubly-stochastic kernel on `Fin 2` - (`MarkovSpectralGap.fullMix`: every state ↦ the uniform distribution) with the uniform - distribution as its stationary law. A non-p-adic instance of the invariant-structure universal, - in a third domain (finite stochastic dynamics). -/ +/-- The **stochastic (Markov) face**: the full-mixing doubly-stochastic kernel on `Fin 2` (`fullMix`, + `ZeroParadox/Reals/MarkovSpectralGap.lean`: every state ↦ the uniform distribution) with the + uniform distribution as its stationary law. A non-p-adic instance of the invariant-structure + universal, in a third domain (finite stochastic dynamics). -/ noncomputable def markovBIK : BottomInvariantKernel (Fin 2) where κ := fullMix - μ := PMF.uniformOfFintype (Fin 2) + μ := fairCoinFin2 stationary := by unfold fullMix; exact PMF.bind_const _ _ /-- **Stochastic same shape from anywhere.** From *every* starting distribution, one step of the full-mixing kernel reaches the uniform stationary law — the stochastic form of "start anywhere, get the same shape." -/ -theorem markov_sameShape (μ : PMF (Fin 2)) : μ.bind fullMix = PMF.uniformOfFintype (Fin 2) := by +theorem markov_sameShape (μ : PMF (Fin 2)) : μ.bind fullMix = fairCoinFin2 := by unfold fullMix; exact PMF.bind_const _ _ /-- **`Statement:` `Fin 0` carries no `BottomInvariantKernel`** — no `PMF` on the empty type. One of @@ -283,14 +283,14 @@ noncomputable def attractorIMK : InvariantMarkovKernel Q₂ where distribution as its stationary law. A genuine Markov kernel in the *same* structure as the two deterministic p-adic faces. -/ noncomputable def markovIMK : InvariantMarkovKernel (Fin 2) where - κ := Kernel.const (Fin 2) ((PMF.uniformOfFintype (Fin 2)).toMeasure) + κ := Kernel.const (Fin 2) (fairCoinFin2.toMeasure) markov := inferInstance - μ := (PMF.uniformOfFintype (Fin 2)).toMeasure + μ := fairCoinFin2.toMeasure isProb := inferInstance invariant := by - show ((PMF.uniformOfFintype (Fin 2)).toMeasure).bind - (Kernel.const (Fin 2) ((PMF.uniformOfFintype (Fin 2)).toMeasure)) - = (PMF.uniformOfFintype (Fin 2)).toMeasure + show (fairCoinFin2.toMeasure).bind + (Kernel.const (Fin 2) (fairCoinFin2.toMeasure)) + = fairCoinFin2.toMeasure rw [Measure.const_comp, measure_univ, one_smul] /-! ## § VII — Attracting kernels: convergence to the invariant law (the #2 ↔ #3 bridge) @@ -346,7 +346,7 @@ theorem attracting_attractor : AttractingKernel attractorIMK := by Measure.map_map measurable_doubling_map (measurable_doubling_map.iterate k), ← Function.iterate_succ'] -- weak convergence, tested against bounded continuous functions - rw [ProbabilityMeasure.tendsto_iff_forall_integral_tendsto] + refine ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mpr ?_ intro f show Tendsto (fun n => ∫ x, f x ∂((step attractorIMK)^[n] ν : Measure Q₂)) atTop (𝓝 (∫ x, f x ∂(Measure.dirac (0 : Q₂)))) @@ -386,8 +386,8 @@ theorem attracting_markov : AttractingKernel markovIMK := by intro ρ apply Subtype.ext show (ρ : Measure (Fin 2)).bind - (Kernel.const (Fin 2) ((PMF.uniformOfFintype (Fin 2)).toMeasure)) - = (PMF.uniformOfFintype (Fin 2)).toMeasure + (Kernel.const (Fin 2) (fairCoinFin2.toMeasure)) + = fairCoinFin2.toMeasure haveI : IsProbabilityMeasure (ρ : Measure (Fin 2)) := ρ.2 rw [Measure.const_comp, measure_univ, one_smul] apply tendsto_nhds_of_eventually_eq @@ -474,7 +474,7 @@ theorem odometer_not_attracting : ¬ AttractingKernel (odometerIMK (p := p)) := -- so Haar would equal a Dirac mass — impossible, Haar is non-atomic have hHaar : haarZp (p := p) = Measure.dirac y := by have := congrArg (fun m : ProbabilityMeasure ℤ_[p] => (m : Measure ℤ_[p])) hy - simpa [MeasureTheory.diracProba] using this.symm + exact this.symm -- Haar is odometer-invariant, so `δ_y = δ_{1+y}`, forcing `1 = 0` have hinv : (haarZp (p := p)).map (1 + ·) = haarZp (p := p) := (measurePreserving_odometer 1).map_eq rw [hHaar, Measure.map_dirac' measurable_odometer_map] at hinv @@ -517,10 +517,9 @@ theorem no_mp_attractor_to_markov : rw [Measure.dirac_apply_of_mem (Set.mem_singleton _)] rw [hmap] at hlhs have hrhs : markovIMK.μ {φ 0} = (2 : ENNReal)⁻¹ := by - show (PMF.uniformOfFintype (Fin 2)).toMeasure {φ 0} = (2 : ENNReal)⁻¹ - rw [PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton _), - PMF.uniformOfFintype_apply] - norm_num + show fairCoinFin2.toMeasure {φ 0} = (2 : ENNReal)⁻¹ + rw [PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton _)] + simp only [fairCoinFin2, PMF.ofFintype_apply] rw [hrhs, ENNReal.inv_eq_one] at hlhs exact absurd hlhs (by norm_num) diff --git a/ZeroParadox/Valuation/BoundaryGap.lean b/ZeroParadox/Valuation/BoundaryGap.lean index aade43b1..6bd257ce 100644 --- a/ZeroParadox/Valuation/BoundaryGap.lean +++ b/ZeroParadox/Valuation/BoundaryGap.lean @@ -1,5 +1,6 @@ -- EXPERIMENTAL (branch scaffolding): bottom-as-boundary pivot, worked through from the ground up; mostly re-derivation of existing framework results, kept for transparency. Curated/load-bearing results are indexed in ZeroParadox/BottomCannotBe.lean and classified in ZeroParadox/MANIFEST.md. import ZeroParadox.Valuation.PadicTree +import ZeroParadox.Order.PowerSet import Mathlib.Tactic set_option maxHeartbeats 400000 @@ -67,6 +68,10 @@ theorem nonroot_has_parent (v : Vtx) (hv : v ≠ []) : tree.Adj v v.dropLast := refine Or.inr ⟨v.getLast hv, ?_⟩ rw [List.dropLast_append_getLast hv] +section ListMembership +-- [ZP port] Lean 4.35: Finset `∈` elaborates via `SetLike.instMembership`, whose proof spends `Classical.choice` (`Multiset.Nodup.ext`); scope `ZeroParadox/Order/PowerSet.lean`'s `psListMem`. +attribute [local instance high] psListMem + /-- **The sharp (non-vacuous) open question.** The real content: `tree` embeds into a tree in which every vertex has exactly three neighbours — the Bruhat-Tits tree of ℚ₂. Unlike `EmbedsAsRootedSubtree` this is NOT trivially true: `tree` itself is not a witness, because its root has degree 2 (`root_adj_iff`). Stated; @@ -75,6 +80,7 @@ def EmbedsInThreeRegularTree : Prop := ∃ (W : Type) (T : SimpleGraph W), (∀ v : W, ∃ s : Finset W, s.card = 3 ∧ ∀ w, T.Adj v w ↔ w ∈ s) ∧ T.IsTree ∧ Nonempty (tree ↪g T) +end ListMembership end ZeroParadox diff --git a/ZeroParadox/Valuation/ContractionRate.lean b/ZeroParadox/Valuation/ContractionRate.lean index fb110402..f73537b0 100644 --- a/ZeroParadox/Valuation/ContractionRate.lean +++ b/ZeroParadox/Valuation/ContractionRate.lean @@ -131,7 +131,7 @@ theorem contraction_orbit_tendsto_zero {c : Q₂} (hc : ‖c‖ < 1) (x : Q₂) tendsto_pow_atTop_nhds_zero_of_lt_one (norm_nonneg _) hc simpa using hbase.mul_const ‖x‖ -/-! ### Non-attractor half (GO): unit multipliers preserve norm, so they are NOT attractors -/ +/-! ### Non-attractor half (GO): norm-one multipliers preserve norm, so they are NOT attractors -/ /-- Non-attractor for units (routine normed-multiplicativity). For a 2-adic unit `u` (`‖u‖ = 1`) and any starting point `x`, the orbit's norm is constant: `‖uⁿ·x‖ = ‖x‖` for all `n`. Used diff --git a/ZeroParadox/Valuation/NuLeafReconcile.lean b/ZeroParadox/Valuation/NuLeafReconcile.lean index df6350d1..88a725e8 100644 --- a/ZeroParadox/Valuation/NuLeafReconcile.lean +++ b/ZeroParadox/Valuation/NuLeafReconcile.lean @@ -87,7 +87,7 @@ noncomputable instance simplex_point_unique_NuLeafReconcile : Unique simplexPoin have h : stdSimplex ℝ (Fin 1) = {fun _ ↦ (1 : ℝ)} := stdSimplex_unique ℝ (Fin 1) -- transport the singleton `Unique` instance across the set equality of carriers have e : simplexPoint_NuLeafReconcile ≃ ↥({fun _ ↦ (1 : ℝ)} : Set (Fin 1 → ℝ)) := - Equiv.setCongr h + Set.equivOfEq h exact e.unique /-- **GO (leaf-level ν reconciliation, IN-statement).** A genuine homeomorphism between the two diff --git a/ZeroParadox/Valuation/NuRateMatch.lean b/ZeroParadox/Valuation/NuRateMatch.lean index 4f15fd04..031878e0 100644 --- a/ZeroParadox/Valuation/NuRateMatch.lean +++ b/ZeroParadox/Valuation/NuRateMatch.lean @@ -18,11 +18,13 @@ defer to my AI assistant regarding the specifics of how the internals work. --- ## Formal Overview (AI-assisted) -At `a = 1/4` the kernel of `ZeroParadox/Order/MarkovContractionDual.lean` scales the imbalance by -`1 - 2a = 1/2` (`step_imb`), the p-adic doubling rate. The match is `padic_markov_shared_rate_envelope`; -the `example` after `padic_markov_no_orbit_correspondence` states that match step by step, for every -start. Both sides are real numbers: no category, inverse limit or map between `Fin 2 → ℝ` and `Q₂` is -built. -/ +"#2" and "#3" are the bottom-diagram probe campaign's labels for the Markov attractor node and the +p-adic floor. At `a = 1/4` the kernel of `ZeroParadox/Order/MarkovContractionDual.lean` scales the +imbalance by `1 - 2a = 1/2` (`step_imb`), the p-adic doubling rate. The match is +`padic_markov_shared_rate_envelope`. The first `example` after `padic_markov_no_orbit_correspondence` +is the cross-multiplied identity `‖2ⁿx‖ · imb v₀ = imb (Pⁿ v₀) · ‖x‖`, which holds at every start; it +is a step-by-step proportionality only for `x ≠ 0` and `imb v₀ ≠ 0` (the next two `example`s). Both +sides are real numbers: no category, inverse limit or map between `Fin 2 → ℝ` and `Q₂` is built. -/ namespace ZeroParadox @@ -56,7 +58,8 @@ theorem padic_orbit_half (x : Q₂) (n : ℕ) : ‖(2 : Q₂) ^ n * x‖ = ((1 : ℝ) / 2) ^ n * ‖x‖ := by rw [padic_orbit_norm x n, padic_env_eq] -/-- **GO capstone (witness, not narration).** Both ν-attractor distance sequences are exactly the +/-- **GO capstone (witness, not narration).** The p-adic orbit norm and the Markov signed imbalance + (`imb`, which can be negative) are both exactly the single shared envelope `(1/2)ⁿ` scaled by a per-orbit constant (Markov: `imb v₀`; p-adic: `‖x‖`), and that envelope `→ 0`. The shared rate **constant** `1/2` is exhibited in-statement — an envelope match across the two ν-attractors #2 and #3, NOT an orbit isomorphism. Rate-level complement to @@ -64,7 +67,7 @@ theorem padic_orbit_half (x : Q₂) (n : ℕ) : theorem padic_markov_shared_rate_envelope (x : Q₂) (v₀ : Fin 2 → ℝ) : -- the shared envelope tends to 0 Tendsto (fun n : ℕ => ((1 : ℝ) / 2) ^ n) atTop (𝓝 0) ∧ - -- #2 (Markov, a = 1/4): imbalance distance is exactly the envelope · (imb v₀) + -- #2 (Markov, a = 1/4): the signed imbalance is exactly the envelope · (imb v₀) (∀ k : ℕ, imb ((markovStep (1/4))^[k] v₀) = ((1 : ℝ) / 2) ^ k * imb v₀) ∧ -- #3 (p-adic doubling): orbit distance is exactly the envelope · ‖x‖ (∀ n : ℕ, ‖(2 : Q₂) ^ n * x‖ = ((1 : ℝ) / 2) ^ n * ‖x‖) := @@ -72,10 +75,11 @@ theorem padic_markov_shared_rate_envelope (x : Q₂) (v₀ : Fin 2 → ℝ) : /-! ### The balanced start -/ -/-- At a balanced start (`hbal`) and `x ≠ 0`: the p-adic orbit distance stays positive while the - `markovStep (1/4)` imbalance is `0` at every step. The start, not the rate, sets the Markov - constant to `0`; the `example` below holds for every start, so the name's "no correspondence" - is this balanced start only. -/ +/-- At a balanced start (`hbal`: any `v₀` on the line `imb v₀ = 0`) and `x ≠ 0`: the p-adic orbit + norm stays positive while the `markovStep (1/4)` imbalance is `0` at every step. The start, not + the rate, sets the Markov constant to `0`. The cross-multiplied identity below holds at every + start, and divides out to a proportionality only when `x ≠ 0` and `imb v₀ ≠ 0`; on the balanced + line it reads `0 = 0`. So the name's "no correspondence" is that line only. -/ theorem padic_markov_no_orbit_correspondence (x : Q₂) (hx : x ≠ 0) {v₀ : Fin 2 → ℝ} (hbal : imb v₀ = 0) : (∀ n, 0 < ‖(2 : Q₂) ^ n * x‖) ∧ @@ -90,6 +94,19 @@ example (x : Q₂) (v₀ : Fin 2 → ℝ) (n : ℕ) : ‖(2 : Q₂) ^ n * x‖ * imb v₀ = imb ((markovStep (1/4))^[n] v₀) * ‖x‖ := by rw [padic_orbit_half, markov_imbalance_quarter]; ring +-- Statement: for `x ≠ 0` and `imb v₀ ≠ 0` the identity divides out: the two ratios to the start agree +-- at every step. +example (x : Q₂) (hx : x ≠ 0) (v₀ : Fin 2 → ℝ) (hv : imb v₀ ≠ 0) (n : ℕ) : + ‖(2 : Q₂) ^ n * x‖ / ‖x‖ = imb ((markovStep (1/4))^[n] v₀) / imb v₀ := by + have hx' : ‖x‖ ≠ 0 := norm_ne_zero_iff.mpr hx + rw [padic_orbit_half, markov_imbalance_quarter, mul_div_assoc, mul_div_assoc, div_self hx', + div_self hv] + +-- Statement: at a balanced start both sides of the identity are `0`, whatever `x` is. +example (x : Q₂) (v₀ : Fin 2 → ℝ) (hbal : imb v₀ = 0) (n : ℕ) : + ‖(2 : Q₂) ^ n * x‖ * imb v₀ = 0 ∧ imb ((markovStep (1/4))^[n] v₀) * ‖x‖ = 0 := by + rw [markov_imbalance_quarter, hbal]; simp + /-- The uniform vector `unif = ![1/2,1/2]` is balanced (`imb unif = 0`), so it meets the hypothesis `hbal` of `padic_markov_no_orbit_correspondence`. -/ theorem unif_balanced : imb unif = 0 := by diff --git a/ZeroParadox/Valuation/Padic.lean b/ZeroParadox/Valuation/Padic.lean index 827871fb..93f7a69c 100644 --- a/ZeroParadox/Valuation/Padic.lean +++ b/ZeroParadox/Valuation/Padic.lean @@ -45,8 +45,12 @@ notation "Q₂" => (ℚ_[2] : Type) The foundational distinction is binary: a state either exists or does not. Modelled as a free two-constructor inductive type with no natural-number dependency. AX-B1 is a modelling commitment (the choice of binary structure); distinctness of -the two states is then verified by decidable equality, requiring no classical axioms. -/ +the two states is then verified by decidable equality, requiring no classical axioms. +AX-B1 itself is the cover of ⊥ with a two-element first interval (`HasFirstStep`, +`ZeroParadox/Reals/OrderedField.lean`); that this carrier has exactly two states is its own choice. -/ +-- [ZP port] Lean 4.35: Mathlib's `Fintype` deriving handler needs the pre-4.35 defeq transparency. +set_option backward.isDefEq.respectTransparency false in /-- The two ontological states: non-existence (⊥ in ZP-A) and existence. -/ -- [ZP-CUSTOM] replaces: Fin 2 | reason: Fin 2's constructors are ⟨0,_⟩ and ⟨1,_⟩ — natural numbers. nullState ≠ ℕ's 0 by convention; it is a semantic state with no numeric meaning. Free inductive eliminates the ℕ dependency and makes ⊥ ↦ null a structural fact, not a labelling choice. inductive OntologicalStates where @@ -429,8 +433,8 @@ rather than annotated.)* *(Three corrections, all 2026-08-01, all caught by gates rather than by me. (i) This paragraph once cited `f_snap_impossible` as holding "on the Archimedean side", mis-scoping a theorem that covers every -ordered field. (ii) The fix for (i) then attributed the wrong proof route — "density -(`LinearOrderedSemiField.toDenselyOrdered`, then `not_covBy`)" — which is the route of +ordered field. (ii) The fix for (i) then attributed the wrong proof route — density, then no cover +(`LinearOrderedSemiField.toDenselyOrdered`, then `not_covBy_of_denselyOrdered`) — which is the route of `axb1_fails_in_ordered_field` four lines further down, whose own docstring says it is proved through Mathlib **rather than** through `f_snap_impossible`. A wrong reason under a true conclusion breaks nothing downstream, which is exactly why it needed a gate to find. (iii) The same fix then called the diff --git a/ZeroParadox/Valuation/PadicCharacter.lean b/ZeroParadox/Valuation/PadicCharacter.lean index f3dbb5e1..ae0562e8 100644 --- a/ZeroParadox/Valuation/PadicCharacter.lean +++ b/ZeroParadox/Valuation/PadicCharacter.lean @@ -2,6 +2,7 @@ import ZeroParadox.Valuation.PadicHaar import Mathlib.Algebra.Group.AddChar import Mathlib.MeasureTheory.Integral.Bochner.Basic +import Mathlib.MeasureTheory.Integral.Bochner.Set import Mathlib.MeasureTheory.Group.Measure import Mathlib.Tactic diff --git a/ZeroParadox/Valuation/PadicErgodic.lean b/ZeroParadox/Valuation/PadicErgodic.lean index 7e82b47f..93035905 100644 --- a/ZeroParadox/Valuation/PadicErgodic.lean +++ b/ZeroParadox/Valuation/PadicErgodic.lean @@ -89,8 +89,7 @@ theorem denseRange_odometer_orbit (x : ℤ_[p]) : DenseRange (fun n : ℕ => x + (n : ℤ_[p])) := by have hg : DenseRange (fun y : ℤ_[p] => x + y) := Function.Surjective.denseRange (fun z => ⟨z - x, by ring⟩) - simpa [Function.comp] using - hg.comp PadicInt.denseRange_natCast (continuous_const.add continuous_id) + exact hg.comp PadicInt.denseRange_natCast (continuous_const.add continuous_id) end ZeroParadox diff --git a/ZeroParadox/Valuation/PadicKozyrev.lean b/ZeroParadox/Valuation/PadicKozyrev.lean index 52c137ee..c6330ee2 100644 --- a/ZeroParadox/Valuation/PadicKozyrev.lean +++ b/ZeroParadox/Valuation/PadicKozyrev.lean @@ -185,9 +185,12 @@ theorem sum_char_multiples_eq_zero (n : ℕ) (φ : AddChar (ZMod (p ^ n)) ℂ) ( refine Finset.sum_congr rfl (fun r _ => ?_) simp only [Equiv.coe_addRight] by_cases hr : (p : ZMod (p ^ n)) ^ j ∣ r - · rw [if_pos hr, if_pos (dvd_add hr hdvd), φ.map_add_eq_mul, mul_comm] - · rw [if_neg hr, if_neg (fun hc => hr (by - have := dvd_sub hc hdvd; rwa [add_sub_cancel_right] at this)), mul_zero] + · rw [if_pos hr] + refine (if_pos (dvd_add hr hdvd)).trans ?_ + rw [φ.map_add_eq_mul, mul_comm] + · rw [if_neg hr, mul_zero] + exact if_neg (fun hc => hr (by + have := dvd_sub hc hdvd; rwa [add_sub_cancel_right] at this)) have hne : (1 : ℂ) - φ ((p : ZMod (p ^ n)) ^ j * x) ≠ 0 := sub_ne_zero.mpr (Ne.symm hx) have hz : (1 - φ ((p : ZMod (p ^ n)) ^ j * x)) * ∑ r : ZMod (p ^ n), (if (p : ZMod (p ^ n)) ^ j ∣ r then φ r else 0) = 0 := by @@ -318,7 +321,7 @@ theorem integral_char_shellLoad (n : ℕ) (φ : AddChar (ZMod (p ^ n)) ℂ) (α = Set.indicator {z : ℤ_[p] | ‖z‖ ≤ (p : ℝ) ^ (-(m : ℤ))} (paChar (p := p) n φ) y - Set.indicator {z : ℤ_[p] | ‖z‖ ≤ (p : ℝ) ^ (-((m + 1 : ℕ) : ℤ))} (paChar (p := p) n φ) y := by intro y - rw [shellSet, Set.indicator_diff hsub, Pi.sub_apply] + rw [shellSet, Set.indicator_sdiff hsub, Pi.sub_apply] have step1 : ∫ y, paChar (p := p) n φ y * shellLoad (p := p) α m y ∂(haarZp (p := p)) = (shellConst (p := p) α m : ℂ) * ∫ y, Set.indicator (shellSet (p := p) m) (paChar (p := p) n φ) y ∂(haarZp (p := p)) := by diff --git a/ZeroParadox/Valuation/PadicTree.lean b/ZeroParadox/Valuation/PadicTree.lean index cd944467..059196e4 100644 --- a/ZeroParadox/Valuation/PadicTree.lean +++ b/ZeroParadox/Valuation/PadicTree.lean @@ -56,7 +56,7 @@ def children (v : Vtx) : Set Vtx := {v ++ [0], v ++ [1]} def tree : SimpleGraph Vtx where Adj v w := (∃ d : Fin 2, w = v ++ [d]) ∨ (∃ d : Fin 2, v = w ++ [d]) symm := by - intro v w h + refine ⟨fun v w h => ?_⟩ rcases h with ⟨d, hd⟩ | ⟨d, hd⟩ · exact Or.inr ⟨d, hd⟩ · exact Or.inl ⟨d, hd⟩ diff --git a/ZeroParadox/Valuation/PadicVladimirov.lean b/ZeroParadox/Valuation/PadicVladimirov.lean index b11d7eb7..27c5817a 100644 --- a/ZeroParadox/Valuation/PadicVladimirov.lean +++ b/ZeroParadox/Valuation/PadicVladimirov.lean @@ -552,7 +552,7 @@ example (n : ℕ) (a : ℤ_[p]) (ha : (p : ℝ) ^ (-(n : ℤ)) < ‖a‖) : section ShellControlThree -local instance : Fact (Nat.Prime 3) := ⟨by norm_num⟩ +local instance instFactPrimeThreeShellControl : Fact (Nat.Prime 3) := ⟨by norm_num⟩ -- Statement: control, at `p = 3` the shell-`0` and ball-`1` indicators differ in length. example : ‖shellIndicatorL2 (p := 3) 0‖ ≠ ‖ballIndicatorL2 (p := 3) 1‖ := by diff --git a/ZeroParadox/Valuation/PoleCompletion.lean b/ZeroParadox/Valuation/PoleCompletion.lean index 59935d54..4dda0bd7 100644 --- a/ZeroParadox/Valuation/PoleCompletion.lean +++ b/ZeroParadox/Valuation/PoleCompletion.lean @@ -39,13 +39,13 @@ The self-referential content of that fold is here, and it is **a genuine typecla AbstractSelfApp End` holds: a self-map whose only fixed point is ⊥. Via `SelfApp.toAFAStructure`, `End` thereby also carries the AFA / Quine-atom structure. -**The delta from ℚ₂ (the point of the exercise).** `ZeroParadox/Computability/SelfApp.lean` records (the note beginning "ℚ_[2] is a field, not a ZPSemilattice") that ℚ₂ — *a field, not a -ZPSemilattice* — could NOT be an `AbstractSelfApp` instance; its ×2/0 fixed point is proved only as a -standalone parallel. The tree boundary clears exactly that bar: it *is* a semilattice, so the same +**The delta from ℚ₂ (the point of the exercise).** `ZeroParadox/Computability/SelfApp.lean` (the note +"no ZPSemilattice ℚ_[2] is DEFINED") gives ℚ₂ no `AbstractSelfApp` instance, not that none could +exist; its ×2/0 fixed point is proved only as a standalone parallel. The tree boundary clears exactly that bar: it *is* a semilattice, so the same fixed-point fact is a **genuine instance**. Self-reference closing at the floor is not merely analogous to -the Quine atom's **structural** fixed point here — it is one, by the framework's own definition. (The literal -set-membership `⊥ = {⊥}` stays a metatheoretic commitment, as everywhere; this is the structural -self-application face, the axiom-free `t_exec` half.) +the Quine atom's **structural** fixed point here — it is one, by the framework's own definition. (`⊥ = {⊥}` of this floor +is ill-typed and not asserted; `selfApp_quine_role_iff` (`ZeroParadox/Settheory/QuineDichotomy.lean`) at `instAbstractSelfAppEnd` +makes the floor the die Quine-atom role's only occupant here (`propext` and `Quot.sound`, choice-free); the axiom-free half is `t_exec`.) **Honest fence.** The tree↔ℚ₂ digit isomorphism is not formalized in this file, so the mirror to `q2SelfApp` is a proved PARALLEL (same map, same unique fixed point), never a Lean `=`; and the "both children at once @@ -78,16 +78,14 @@ theorem boundaryDouble_unique_fp (x : End) (h : boundaryDouble x = x) : x = botE /-- The boundary `End = ℕ → Fin 2` is a `ZPSemilattice` pointwise (join = max, ⊥ = `botEnd`). Unlike ℚ₂ (a field), the tree boundary IS a semilattice, so it can host a genuine `AbstractSelfApp` instance. -/ instance instZPSemilatticeEnd : ZPSemilattice End where - join x y := fun n => max (x n) (y n) + -- [ZP port] Lean 4.35: core's new `Fin.instMax` (`Init/Data/Fin/MinMax.lean`) proves its bound by + -- `Std.max_lt_iff`, which carries `Classical.choice`; build the same max (defeq) from `Nat.max_lt`. + join x y := fun n => ⟨max (x n).val (y n).val, Nat.max_lt.2 ⟨(x n).isLt, (y n).isLt⟩⟩ bot := botEnd - join_assoc := by intro x y z; funext n; exact max_assoc _ _ _ - join_comm := by intro x y; funext n; exact max_comm _ _ - join_idem := by intro x; funext n; exact max_self _ - bot_join := by - intro x; funext n - show max (botEnd n) (x n) = x n - simp only [botEnd] - exact max_eq_right (Fin.zero_le _) + join_assoc := by intro x y z; funext n; exact Fin.ext (Nat.max_assoc _ _ _) + join_comm := by intro x y; funext n; exact Fin.ext (Nat.max_comm _ _) + join_idem := by intro x; funext n; exact Fin.ext (Nat.max_self _) + bot_join := by intro x; funext n; exact Fin.ext (Nat.zero_max _) /-- **The genuine instance.** The tree boundary is an `AbstractSelfApp`: the self-application ×2 (`boundaryDouble`) has the floor `botEnd` as its unique fixed point. Where ℚ₂ could only be a standalone diff --git a/ZeroParadox/Valuation/PoleCorners.lean b/ZeroParadox/Valuation/PoleCorners.lean index 0c158e30..8aa147b1 100644 --- a/ZeroParadox/Valuation/PoleCorners.lean +++ b/ZeroParadox/Valuation/PoleCorners.lean @@ -54,6 +54,8 @@ namespace ZeroParadox /-! ### § I. The pole and its four representations -/ +-- [ZP port] Lean 4.35: Mathlib's `Fintype` deriving handler needs the pre-4.35 defeq transparency. +set_option backward.isDefEq.respectTransparency false in /-- The pole: the two-element type `{0, ∞}` — the framework's self-dual point `0 = ∞`. -/ inductive Pole where | zero diff --git a/ZeroParadox/Valuation/PolePassage.lean b/ZeroParadox/Valuation/PolePassage.lean new file mode 100644 index 00000000..039adcdc --- /dev/null +++ b/ZeroParadox/Valuation/PolePassage.lean @@ -0,0 +1,276 @@ +-- EXPERIMENTAL (bottom-diagram probe, not a finalized layer): the snap arc on the 2-adic sphere `OnePoint ℚ_[2]`, its inversion, and its valuation reading. Curated results indexed in ZeroParadox/MANIFEST.md. +import ZeroParadox.Valuation.PoleCornersBridge +import ZeroParadox.Reals.OrderedField +import Mathlib.RingTheory.HahnSeries.Valuation +import Mathlib.RingTheory.HahnSeries.Summable +import Mathlib.GroupTheory.ArchimedeanDensely +import Mathlib.Topology.Path +import Mathlib.Topology.Instances.ENat +import Mathlib.Topology.Instances.Real.Lemmas +import Mathlib.Tactic + +set_option maxHeartbeats 400000 + +/-! +# The snap arc on the 2-adic sphere: no passage through `∞`, a return in the valuation + +## Engineer's Take + +This file is one of a series of iterative attempts on this branch to build a map of how the various +bottoms interconnect, and by extension how bottom moves from being the floor, a thing (a noun), to a +verb (an action). The Lean here is our attempt, one way or the other, to get a clean verification. I +defer to my AI assistant regarding the specifics of how the internals work. + +--- + +## Formal Overview (AI-assisted) +The `cnfToZp2` tower images (`snap_arc_z2_loop`) on `Sphere`: no route from `0` of `ℚ_[2]` through +`∞` of `Sphere`, the `rInv` image, the `q2Val` return to `⊤` of `ℕ∞`, and the `OnePoint ℝ` control. +§ VI: `HasFirstStep 0` in an ordered group iff not dense. § VII: the dense-valued `HahnSeries ℚ ℚ`. +-/ + +namespace ZeroParadox + +open OnePoint Filter Topology + +/-! ### § I. The arc on the sphere, and its image under inversion -/ + +/-- `Statement:` stage `n` of the arc: the `cnfToZp2` image of `towerNONote n`, as a point of + `Sphere`. -/ +noncomputable def arcS (n : ℕ) : Sphere := + OnePoint.some ((cnfToZp2 (towerNONote n) : ℤ_[2]) : ℚ_[2]) + +/-- `Statement:` on `Sphere`, the arc tends to `0` of `ℚ_[2]` (the third conjunct of + `snap_arc_z2_loop`, carried along `ℤ_[2] → ℚ_[2] → Sphere`). -/ +theorem arcS_tendsto_zero : Tendsto arcS atTop (𝓝 (OnePoint.some (0 : ℚ_[2]))) := by + have h : Tendsto (fun n => ((cnfToZp2 (towerNONote n) : ℤ_[2]) : ℚ_[2])) atTop (𝓝 0) := by + have := (continuous_subtype_val (p := fun x : ℚ_[2] => ‖x‖ ≤ 1)).tendsto (0 : ℤ_[2]) + exact this.comp tower_converges_to_zero + exact (OnePoint.continuous_coe.tendsto _).comp h + +/-- `Statement:` `rInv ∘ arcS` tends to `∞` of `Sphere`, starts at `∞`, and has stage `n + 1` equal + to `(2 ^ (n + 1))⁻¹`. + `Reading:` **INVERSION** — `rInv` carries the arc's loop at `0` of `ℚ_[2]` onto a loop at `∞` of + `Sphere`; it exchanges the two loops and does not join them (`arc_never_meets_infty`). -/ +theorem rInv_arcS : + Tendsto (fun n => rInv (arcS n)) atTop (𝓝 (∞ : Sphere)) ∧ + rInv (arcS 0) = ∞ ∧ + ∀ n : ℕ, rInv (arcS (n + 1)) = OnePoint.some (((2 : ℚ_[2]) ^ (n + 1))⁻¹) := by + refine ⟨?_, ?_, fun n => ?_⟩ + · have := (continuous_rInv.tendsto _).comp arcS_tendsto_zero + rwa [rInv_zero] at this + · show rInv (OnePoint.some ((cnfToZp2 (towerNONote 0) : ℤ_[2]) : ℚ_[2])) = ∞ + rw [snap_arc_z2_loop.1]; simp + · have h2 : ((2 : ℚ_[2]) ^ (n + 1)) ≠ 0 := pow_ne_zero _ (by norm_num) + have hstage : cnfToZp2 (towerNONote (n + 1)) = (2 : ℤ_[2]) ^ (n + 1) := by + rw [towerNONote_succ_eq, cnfToZp2_omegaPowNote, towerImageStep, cnfToZp2_tower_valuation] + show rInv (OnePoint.some ((cnfToZp2 (towerNONote (n + 1)) : ℤ_[2]) : ℚ_[2])) = _ + have hc : (((2 : ℤ_[2]) ^ (n + 1) : ℤ_[2]) : ℚ_[2]) = (2 : ℚ_[2]) ^ (n + 1) := by + rw [PadicInt.coe_pow]; norm_cast + rw [hstage, hc, rInv_coe_ne h2] + +/-! ### § II. A clopen set separates `0` of `ℚ_[2]` from `∞` of `Sphere` -/ + +/-- `Statement:` the image in `Sphere` of the closed unit ball of `ℚ_[2]`. -/ +def ballS : Set Sphere := OnePoint.some '' Metric.closedBall (0 : ℚ_[2]) 1 + +/-- `Statement:` `ballS` is clopen in `Sphere`. -/ +theorem ballS_isClopen : IsClopen ballS := by + refine ⟨?_, ?_⟩ + · exact ((isCompact_closedBall (0 : ℚ_[2]) 1).image OnePoint.continuous_coe).isClosed + · exact OnePoint.isOpenMap_coe _ (IsUltrametricDist.isOpen_closedBall _ one_ne_zero) + +/-- `Statement:` every stage of the arc and `0` of `ℚ_[2]` lie in `ballS`, `∞` of `Sphere` does not, + `∞` is outside the connected component of `0`, and the arc does not tend to `∞`. -/ +theorem arc_never_meets_infty : + (∀ n, arcS n ∈ ballS) ∧ OnePoint.some (0 : ℚ_[2]) ∈ ballS ∧ (∞ : Sphere) ∉ ballS ∧ + (∞ : Sphere) ∉ connectedComponent (OnePoint.some (0 : ℚ_[2])) ∧ + ¬ Tendsto arcS atTop (𝓝 (∞ : Sphere)) := by + have h0 : OnePoint.some (0 : ℚ_[2]) ∈ ballS := ⟨0, by simp, rfl⟩ + have hinf : (∞ : Sphere) ∉ ballS := by + rintro ⟨x, -, hx⟩; exact OnePoint.coe_ne_infty x hx + refine ⟨fun n => ⟨_, by simpa using (cnfToZp2 (towerNONote n)).2, rfl⟩, h0, hinf, + fun h => hinf (ballS_isClopen.connectedComponent_subset h0 h), fun h => ?_⟩ + exact OnePoint.coe_ne_infty _ (tendsto_nhds_unique arcS_tendsto_zero h) + +/-- `Statement:` no continuous path in `Sphere` runs from `0` of `ℚ_[2]` to `∞` of `Sphere`. The + path form inside `ℚ_[2]`, from a nonzero point to `0`, is `c3_irreversible`. -/ +theorem no_path_zero_infty : IsEmpty (Path (OnePoint.some (0 : ℚ_[2]) : Sphere) ∞) := by + refine ⟨fun γ => ?_⟩ + have hc : IsClopen (γ ⁻¹' ballS) := ballS_isClopen.preimage γ.continuous + rcases isClopen_iff.1 hc with h | h + · have : (0 : unitInterval) ∈ γ ⁻¹' ballS := by + show γ 0 ∈ ballS; rw [γ.source]; exact ⟨0, by simp, rfl⟩ + rw [h] at this; exact this + · have : (1 : unitInterval) ∈ γ ⁻¹' ballS := by rw [h]; trivial + have h1 : γ 1 ∈ ballS := this + rw [γ.target] at h1 + obtain ⟨x, -, hx⟩ := h1 + exact OnePoint.coe_ne_infty x hx + +/-! ### § III. The valuation reading: from `⊤` of `ℕ∞` and back to `⊤` -/ + +/-- `Statement:` `q2Val` of the arc is `⊤` of `ℕ∞` at stage `0`, is `n` at every stage `n ≥ 1`, and + tends to `⊤`. + `Reading:` **COINCIDENCE** — the `⊤` the valuation returns to is the value at the same `0` of + `ℤ_[2]` the arc started from (`q2Val_bot`, `snap_arc_z2_loop`), not `∞` of `Sphere` + (`arc_never_meets_infty`). The supremum form is `tower_height_floor_reconciliation`. -/ +theorem arc_q2Val : + q2Val (cnfToZp2 (towerNONote 0)) = ⊤ ∧ + (∀ n : ℕ, 1 ≤ n → q2Val (cnfToZp2 (towerNONote n)) = (n : ℕ∞)) ∧ + Tendsto (fun n => q2Val (cnfToZp2 (towerNONote n))) atTop (𝓝 ⊤) := by + have hfin : ∀ n : ℕ, 1 ≤ n → q2Val (cnfToZp2 (towerNONote n)) = (n : ℕ∞) := by + intro n hn + simp [q2Val, snap_arc_z2_loop.2.1 n hn, cnfToZp2_tower_valuation] + refine ⟨by rw [snap_arc_z2_loop.1]; exact q2Val_bot, hfin, ?_⟩ + refine ENat.tendsto_nhds_top_iff_natCast_lt.2 fun m => ?_ + filter_upwards [eventually_ge_atTop (m + 1)] with n hn + rw [hfin n (by omega)] + exact_mod_cast (by omega : m < n) + +/-! ### § IV. A run built by joins does not return to `⊥` of `L` at any finite stage -/ + +/-- `Statement:` in any `ZPSemilattice L`, if `S (n + 1) = join (S n) (z n)` for all `n` and + `S 1 ≠ bot`, then `S n ≠ bot` for every `n ≥ 1` (by `t_snap_irreversible`). + `Reading:` the return in `snap_arc_z2_loop` is a limit in `ℤ_[2]`, which this statement does + not quantify over. -/ +theorem join_run_never_returns {L : Type*} [ZPSemilattice L] (S : ℕ → L) (z : ℕ → L) + (hrun : ∀ n, S (n + 1) = ZPSemilattice.join (S n) (z n)) (h1 : S 1 ≠ ZPSemilattice.bot) : + ∀ n, 1 ≤ n → S n ≠ ZPSemilattice.bot := by + intro n hn + induction n with + | zero => omega + | succ k ih => + rcases Nat.lt_or_ge k 1 with hk | hk + · have : k = 0 := by omega + subst this; exact h1 + · intro hb + exact t_snap_irreversible (x := ZPSemilattice.bot) (y := S k) (ZPSemilattice.bot_le _) + (Ne.symm (ih hk)) ⟨z k, (hrun k).symm.trans hb⟩ + +-- Statement: the arc's step `towerImageStep` lowers the norm at every nonzero point of `ℤ_[2]` +-- (`towerImageStep_norm_drift`), so it is not inflationary in the norm order, as a join is. +example : ∀ x : ℤ_[2], x ≠ 0 → ‖towerImageStep x‖ < ‖x‖ := towerImageStep_norm_drift.1 + +/-! ### § V. Control: `OnePoint ℝ` -/ + +/-- `Statement:` `∞` of `OnePoint ℝ` lies in the connected component of `0` of `ℝ`. + `Reading:` **CARRIER** — on `Sphere` they do not (`arc_never_meets_infty`). -/ +theorem real_zero_infty_connected : + (∞ : OnePoint ℝ) ∈ connectedComponent (OnePoint.some (0 : ℝ)) := by + rw [PreconnectedSpace.connectedComponent_eq_univ]; trivial + +/-! ### § VI. The value chart: a first step at `0` exactly when the order is not dense -/ + +/-- `Statement:` in a linearly ordered additive commutative group `G`, `HasFirstStep (0 : G)` iff + `G` is not densely ordered (standard; e.g. Clay–Rolfsen, arXiv:0705.2623, Prop. 1.1). No + Archimedean hypothesis. The whole-order form, over any + `Preorder`, is `axb1_fails_everywhere_iff_dense`; translation by `a` carries a cover at `a` to + one at `0`. -/ +theorem cover_at_zero_iff_not_dense {G : Type*} [AddCommGroup G] [LinearOrder G] + [IsOrderedAddMonoid G] : HasFirstStep (0 : G) ↔ ¬ DenselyOrdered G := by + constructor + · rintro ⟨a, ha⟩ hd + obtain ⟨c, h1, h2⟩ := exists_between ha.1 + exact ha.2 h1 h2 + · intro hnd + rw [axb1_fails_everywhere_iff_dense] at hnd + push Not at hnd + obtain ⟨a, ⟨b, hab⟩⟩ := hnd + exact ⟨b - a, sub_pos.2 hab.1, fun c hc0 hcb => + hab.2 (lt_add_of_pos_right a hc0) (lt_sub_iff_add_lt'.1 hcb)⟩ + +/-- `Statement:` with `[Archimedean G]`, `HasFirstStep (0 : G)` iff `G ≃+o ℤ`, by Mathlib's + `LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered`. -/ +theorem cover_at_zero_iff_int {G : Type*} [AddCommGroup G] [LinearOrder G] + [IsOrderedAddMonoid G] [Archimedean G] : HasFirstStep (0 : G) ↔ Nonempty (G ≃+o ℤ) := by + rw [cover_at_zero_iff_not_dense, LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered] + +-- Statement: ℤ, the value group of `q2Val` off `⊤`, has its first step at `0`: `0 ⋖ 1`. +example : HasFirstStep (0 : ℤ) := ⟨1, ⟨zero_lt_one, fun _ h1 h2 => by omega⟩⟩ +-- Statement: control, ℝ has none (`axb1_fails_in_ordered_field`). +example : ¬ HasFirstStep (0 : ℝ) := axb1_fails_in_ordered_field +-- Statement: in `ℕ∞`, the codomain of `q2Val`, nothing is covered by `⊤` (Mathlib's +-- `WithTop.coe_covBy_top`), so the step `⊤ → 1` of `arc_q2Val` is not a cover. +example : ¬ ∃ b : ℕ∞, b ⋖ ⊤ := by + rintro ⟨b, hb⟩ + induction b using ENat.recTopCoe with + | top => exact lt_irrefl _ hb.1 + | coe n => exact not_isMax n (WithTop.coe_covBy_top.1 hb) +-- Statement: the same in `WithTop ℚ`, the codomain of `HahnSeries.addVal ℚ ℚ` (§ VII). +example : ¬ ∃ b : WithTop ℚ, b ⋖ ⊤ := by + rintro ⟨b, hb⟩ + induction b using WithTop.recTopCoe with + | top => exact lt_irrefl _ hb.1 + | coe r => exact not_isMax r (WithTop.coe_covBy_top.1 hb) + +/-! ### § VII. Control: a dense value group, `HahnSeries ℚ ℚ` -/ + +-- Statement: `HahnSeries ℚ ℚ` is a field (Mathlib); its additive valuation takes values in `WithTop ℚ`. +noncomputable example : Field (HahnSeries ℚ ℚ) := inferInstance + +/-- `Statement:` stage `0` is `0` of `HahnSeries ℚ ℚ`; stage `n + 1` is the monomial + `single ((n + 1) / 2) 1`. -/ +noncomputable def hahnArc : ℕ → HahnSeries ℚ ℚ + | 0 => 0 + | n + 1 => HahnSeries.single (((n : ℚ) + 1) / 2) (1 : ℚ) + +/-- `Statement:` `addVal` of `hahnArc` is `⊤` at stage `0`, is `(n + 1) / 2` at stage `n + 1`, and + eventually exceeds every rational. + `Reading:` **CARRIER** — the valuation runs `⊤ → finite → ⊤` over the dense value group `ℚ`, as + `arc_q2Val` does over `ℤ`; a first step at `0` of the value group is not needed for it. -/ +theorem hahnArc_loop : + HahnSeries.addVal ℚ ℚ (hahnArc 0) = ⊤ ∧ + (∀ n : ℕ, HahnSeries.addVal ℚ ℚ (hahnArc (n + 1)) = ((((n : ℚ) + 1) / 2 : ℚ) : WithTop ℚ)) ∧ + (∀ q : ℚ, ∀ᶠ n in atTop, (q : WithTop ℚ) < HahnSeries.addVal ℚ ℚ (hahnArc n)) := by + have hs : ∀ n : ℕ, + HahnSeries.addVal ℚ ℚ (hahnArc (n + 1)) = ((((n : ℚ) + 1) / 2 : ℚ) : WithTop ℚ) := + fun n => by + rw [HahnSeries.addVal_apply] + exact HahnSeries.orderTop_single one_ne_zero + refine ⟨by simp [hahnArc], hs, fun q => ?_⟩ + obtain ⟨N, hN⟩ := exists_nat_gt (2 * q) + filter_upwards [eventually_ge_atTop (N + 1)] with n hn + obtain ⟨m, rfl⟩ : ∃ m, n = m + 1 := ⟨n - 1, by omega⟩ + rw [hs m, WithTop.coe_lt_coe] + have : (N : ℚ) ≤ m := by exact_mod_cast (by omega : N ≤ m) + linarith + +/-- `Statement:` below every positive value of `addVal` on `HahnSeries ℚ ℚ` lies a smaller positive + value, taken by a monomial. -/ +theorem hahn_no_least_positive_value (x : HahnSeries ℚ ℚ) (hx : x ≠ 0) + (hpos : (0 : WithTop ℚ) < HahnSeries.addVal ℚ ℚ x) : + ∃ y : HahnSeries ℚ ℚ, (0 : WithTop ℚ) < HahnSeries.addVal ℚ ℚ y ∧ + HahnSeries.addVal ℚ ℚ y < HahnSeries.addVal ℚ ℚ x := by + rw [HahnSeries.addVal_apply_of_ne hx] at hpos ⊢ + have h0 : (0 : ℚ) < x.order := WithTop.coe_lt_coe.1 hpos + refine ⟨HahnSeries.single (x.order / 2) (1 : ℚ), ?_⟩ + rw [HahnSeries.addVal_apply, HahnSeries.orderTop_single one_ne_zero] + exact ⟨WithTop.coe_lt_coe.2 (half_pos h0), WithTop.coe_lt_coe.2 (half_lt_self h0)⟩ + +-- Statement: the value group ℚ has no first step at `0` (`cover_at_zero_iff_not_dense`) and no least +-- positive element (`f_snap_impossible`). +example : ¬ HasFirstStep (0 : ℚ) ∧ ¬ ∃ ε₀ : ℚ, 0 < ε₀ ∧ ¬ ∃ δ : ℚ, 0 < δ ∧ δ < ε₀ := + ⟨fun h => cover_at_zero_iff_not_dense.1 h inferInstance, f_snap_impossible⟩ + +end ZeroParadox + +/-! ## Axiom Purity Check -/ +section PurityCheck +open ZeroParadox +#print axioms arcS +#print axioms arcS_tendsto_zero +#print axioms rInv_arcS +#print axioms ballS +#print axioms ballS_isClopen +#print axioms arc_never_meets_infty +#print axioms no_path_zero_infty +#print axioms arc_q2Val +#print axioms join_run_never_returns +#print axioms real_zero_infty_connected +#print axioms cover_at_zero_iff_not_dense +#print axioms cover_at_zero_iff_int +#print axioms hahnArc +#print axioms hahnArc_loop +#print axioms hahn_no_least_positive_value +end PurityCheck diff --git a/ZeroParadox/Valuation/PoleRegistration.lean b/ZeroParadox/Valuation/PoleRegistration.lean index e4429c2f..914d87fe 100644 --- a/ZeroParadox/Valuation/PoleRegistration.lean +++ b/ZeroParadox/Valuation/PoleRegistration.lean @@ -65,8 +65,8 @@ theorem registered_discriminator_exists {α : Type*} : (de Jong 2023, Def. 15) — the type of truth values, so `PoleDiscriminator` is not about partiality; it says a `Bool` test decides EVERY proposition. Principle: the inert-packaging `example` below is, in topos vocabulary, **the subobject classifier Ω is decidable** (`Ω ≅ 1 + 1`). ⚠ There that is -EQUIVALENT to excluded middle; here only the forward leg is proved, because a `Bool` decider is DATA -— the `Prop`/`Type` fence, stated in `ZeroParadox/Category/ExcludedMiddleBridge.lean`. +EQUIVALENT to excluded middle; here only the forward leg is proved, and a candidate reason is that a +`Bool` decider is DATA — the `Prop`/`Type` fence, stated in `ZeroParadox/Category/ExcludedMiddleBridge.lean`. `Option`/`Part` are LIFTINGS of dominances, not dominances. Sources, attribution and scope in the ride-along `ZeroParadox/Valuation/PoleRegistration.md`. -/ @@ -99,8 +99,8 @@ example : PoleDiscriminator → ChoiceFragment := by -- Statement: and back again, so the two hypotheses are inter-derivable. -- The content is not the inter-derivability — both sides are theorems here — it is that BOTH LEGS -- ARE CHOICE-FREE: this one measures `[propext, Quot.sound]`, and it uses no excluded middle at --- all. The two predicates of `em_of_choiceFragment` are each constructively inhabited, so `decide (ch A = ch B)` --- is already data and the chooser alone supplies it. +-- all. `decide (ch A = ch B)` is data because `Bool` has decidable equality; the chooser supplies +-- `ch A` and `ch B` on the predicates `b = true ∨ x.Dom` and `b = false ∨ x.Dom`, each inhabited. example : ChoiceFragment → PoleDiscriminator := by intro h obtain ⟨ch, hch⟩ := h @@ -127,8 +127,8 @@ example : ChoiceFragment → PoleDiscriminator := by theorem dom_mk (p : Prop) (f : p → Unit) : (Part.mk p f).Dom = p := rfl /-- `Statement:` a uniform discriminator on the Sierpiński domain yields excluded middle. - `Reading:` CITED, not claimed — de Jong 2023 § 2.3, and Proposition 63 with Proposition 62, - which state this taboo at S itself. Local only in not routing through + `Reading:` CITED, not claimed — de Jong 2023 § 2.3, and Proposition 63 with Proposition 62 + (arXiv v5 numbering), which state this taboo at S itself. Local only in not routing through Diaconescu, a fact about proof STRUCTURE: the `example`s above show the hypothesis inter-derivable with `ChoiceFragment`. ⚠ The conclusion is `Prop`-valued, NOT `∀ p, Decidable p` — `Prop`/`Type` stratification. -/ @@ -149,9 +149,9 @@ theorem poleDiscriminator_of_classical : PoleDiscriminator := by de Jong 2023 § 2.3 has § II's taboo. That which END the discriminator sits on decides which taboo you get is prior art in constructive/predicative domain theory, NOT this framework's; § II proves one -instance of the top-end half. Closest: **Proposition 63** with 62 — since `⊤ ⊑ x` IS `x.Dom` in -`Part Unit`, they state exactly `em_of_poleDiscriminator`'s taboo; Proposition 22 is the BOTTOM end, -yielding only the WEAK form. ⚠ That the ends are therefore DIFFERENT conditions does NOT follow from +instance of the top-end half. Closest (arXiv v5 numbering): **Proposition 63** with 62 — since +`⊤ ⊑ x` IS `x.Dom` in `Part Unit`, they state exactly `em_of_poleDiscriminator`'s taboo; +Proposition 22 is the BOTTOM end, yielding the WEAK form. ⚠ That the ends are therefore DIFFERENT conditions does NOT follow from those results — the ride-along says why. Knapp 2020 supplies the `Option`/`Part` vocabulary; the weak-versus-full distinction is fenced in `ZeroParadox/Category/LawvereTaboo.lean`. Details: `ZeroParadox/Valuation/PoleRegistration.md`. -/ diff --git a/ZeroParadox/Valuation/PoleRegistration.md b/ZeroParadox/Valuation/PoleRegistration.md index b55e0162..16b87518 100644 --- a/ZeroParadox/Valuation/PoleRegistration.md +++ b/ZeroParadox/Valuation/PoleRegistration.md @@ -15,9 +15,10 @@ the two `example`s in § II prove that, both directions: in § II. So § II's hypothesis and the one already in `ZeroParadox/Category/ExcludedMiddleBridge.lean` are **inter-derivable**, not two principles. -**The return leg runs on the chooser's DATA, and uses no excluded middle at all.** The two predicates of -`em_of_choiceFragment` are each constructively inhabited, so `decide (ch A = ch B)` is already data. -`em_of_choiceFragment` plays no part: it runs `ChoiceFragment → ExcludedMiddle`, forward, and +**The return leg runs on the chooser's DATA, and uses no excluded middle at all.** `decide (ch A = ch B)` +is data because `Bool` has decidable equality; the chooser supplies `ch A` and `ch B` on two inhabited +predicates, `b = true ∨ x.Dom` and `b = false ∨ x.Dom`, the same pair `em_of_choiceFragment`'s proof +forms internally. The theorem `em_of_choiceFragment` itself plays no part: it runs `ChoiceFragment → ExcludedMiddle`, forward, and composing it with the first bullet would run forward twice and never return. **What the two legs establish is COST, not the arrows.** Both sides are theorems of the ambient @@ -28,8 +29,7 @@ measured 2026-09-17 by naming the anonymous `example`s: forward `[propext]`, ret `[propext, Quot.sound]`, and the inert-packaging leg at no axioms at all — and that `PoleDiscriminator` is the pole vocabulary for `ChoiceFragment` — the relationship `uniformChartSelection_iff_choiceFragment` already records for chart selection, and -already stated in prose at `ExcludedMiddleBridge.lean` and `ChoiceCannotBe.lean`. Witnessed here, -not discovered here. +`ZeroParadox/Category/ChoiceCannotBe.lean` § III already indexes. Witnessed here, not discovered here. ⚠ **A failed elaboration measures a CONSTRUCTION, never a route** — and it is the axiom budget, never the arrow, that is ever in question here. The natural construction of a discriminator from excluded @@ -47,7 +47,7 @@ strength. ## Sources, read at rung D **T. de Jong, "Apartness, sharp elements, and the Scott topology of domains," MSCS 2023** -(arXiv:2106.05064v5), filed in `.claude-local/papers/`. Page 7, § 2.3, verbatim: *"decidable equality +(arXiv:2106.05064v5). Page 7, § 2.3, verbatim: *"decidable equality on all of S is equivalent to excluded middle"*. ⚠ **Every result number below is the arXiv v5 numbering**, which is the edition read. The MSCS @@ -80,8 +80,11 @@ known properties of decidable objects, see Acuña-Linton"* — **O. Acuña-Orteg of an Elephant* A4.5.22; that is **not read here and not corroborated by the source that is**. ⚠ **In a topos those four are EQUIVALENT; this file proves one direction.** The converse is exactly -what §§ above leave open, and the reason is the `Prop`/`Type` stratification — a `Bool`-valued -decider is data, `ExcludedMiddle` is `Prop`-valued, and a topos has no such split. The canonical +what §§ above leave open, and a candidate reason is the `Prop`/`Type` stratification — a `Bool`-valued +decider is data, `ExcludedMiddle` is `Prop`-valued, and `Or` in `Prop` does not eliminate into `Bool`. +In a topos a decided proposition determines an element of 1 + 1 +(`ZeroParadox/Category/ChoiceCannotBe.md`, § "The headline fence"), while Ω ≅ 1 + 1 is condition (4) +of the lemma above and holds exactly in the Boolean toposes. The canonical statement of that fence is `ZeroParadox/Category/ExcludedMiddleBridge.lean`'s `ChoiceFragment` docstring; it is not restated here. @@ -101,9 +104,9 @@ is `Decidable`. **Credit runs one way: an instance of theirs, never a generaliza **T. de Jong and M. H. Escardó, "Predicative Aspects of Order Theory in Univalent Foundations," FSCD 2021** (arXiv:2102.08812v5) and *"On Small Types in Univalent Foundations"* (arXiv:2111.00482v5, -LMCS 2023), both filed. Same neighbourhood, and **this file makes no claim about what either proves** -— a previous version characterised their Corollary 39 / Theorem 42 and that characterisation was -withdrawn as unverified. Read them before citing them. +LMCS 2023), both filed. Same neighbourhood. **This file cites neither for any result of its own.** The +first is cited, read from source, at `ZeroParadox/Category/LawvereTaboo.lean` (Corollary 39(iii)-(iv), +p. 11, in the comment above `wem_of_fixedPointFree`) and `ZeroParadox/Category/BottomUndecidable.lean` § II. **C. Knapp, "Partial Functions and Recursion in Univalent Type Theory," 2020** (arXiv:2011.00272), filed. **Definition 5.17** (p. 92): a *dominance* is a **set of propositions** `d : U → U` closed @@ -169,9 +172,10 @@ value, no novelty claim. Three things are genuinely here: 2. **A modesty result, WITNESSED here and stated in prose elsewhere already.** `PoleDiscriminator` and the corpus's own `ChoiceFragment` are inter-derivable, both legs now `example`s in § II, and both choice-free. So § II introduces **no new principle** — it is the pole vocabulary for a - hypothesis the corpus already had. ⚠ Not a discovery: `ExcludedMiddleBridge.lean` and - `ChoiceCannotBe.lean` already say in prose that `ChoiceFragment` is really `∀ p, Decidable p`. - What is added is the machine-checked witness, not the observation. + hypothesis the corpus already had. ⚠ Not a discovery: `ExcludedMiddleBridge.lean` relates + `ChoiceFragment` to data-valued decidability directly (the `example` after its definition, + `ChoiceFragment ↔ Nonempty (∀ p, Decidable p)`). What is added here is the witness through + `PoleDiscriminator`, not the observation. 3. **The consequence at the computational floor**, § III: what § II costs constructively, ZP-K's floor cannot buy at any price — no *computable* discriminator decides self-application, by reduction to `self_halting_undecidable`. diff --git a/ZeroParadox/Valuation/PricedPadicInterface.lean b/ZeroParadox/Valuation/PricedPadicInterface.lean index 3b1e12d4..2cd7451b 100644 --- a/ZeroParadox/Valuation/PricedPadicInterface.lean +++ b/ZeroParadox/Valuation/PricedPadicInterface.lean @@ -101,9 +101,8 @@ theorem nScale_bot : 2 * 0 = 0 := rfl /-- **The `val_scale` content, choice-free.** Doubling raises the 2-adic count by one, off the bottom — here with the successor taken on ℕ (`v2nat n n + 1`) and then cast, so the statement is choice-free. This is the mathematical content of ZP-J's `val_scale` on this carrier; the one lemma needing fuel -saturation. Compare `v2_scale`, which states the same fact in the axiom's literal `+ 1`-in-`ℕ∞` form and -thereby inherits `Classical.choice` from the ambient `ℕ∞` LITERAL (`AddMonoidWithOne ℕ∞`), not from -the addition and not from the carrier. -/ +saturation. Compare `v2_scale`, which states the same fact in the axiom's literal `+ 1`-in-`ℕ∞` form +and carries `Classical.choice` through its proof: `v2` and `(a : ℕ∞) + 1` print clean in § IV. -/ theorem v2_scale_nat (n : ℕ) (hn : n ≠ 0) : v2 (2 * n) = ((v2nat n n + 1 : ℕ) : ℕ∞) := by have h2n : 2 * n ≠ 0 := by omega rw [v2, if_neg h2n] @@ -113,44 +112,38 @@ theorem v2_scale_nat (n : ℕ) (hn : n ≠ 0) : v2 (2 * n) = ((v2nat n n + 1 : rw [e, v2nat_succ, if_neg (by omega : ¬ (2 * n) % 2 = 1), if_neg h2n, show (2 * n) / 2 = n from by omega, v2nat_stable (2 * n - 1) n (by omega)] -/-- **The `ℕ∞` numerals `0` and `1` carry `Classical.choice` — the localization instrument, -corrected twice.** ⚠⚠ EVERY FOOTPRINT HERE IS PIN-RELATIVE, NOT STRUCTURAL, and this one is known -to have moved: Brasca and Clemente (*Synthetic Differential Geometry in Lean*, arXiv:2603.17457, -§2.2) report that writing `(2 : R)` for a ring `R` USED to require choice through this same -`instOfNatAtLeastTwo` route, and that it was subsequently fixed in Mathlib. Their constraint forces +/-- **`(a : ℕ∞) + (b : ℕ∞) = ↑(a + b)`, through Mathlib's `Nat.cast_add` — the localization +instrument for the `ℕ∞` numerals.** ⚠⚠ EVERY FOOTPRINT HERE IS PIN-RELATIVE, NOT STRUCTURAL: +Brasca and Clemente (*Synthetic Differential Geometry in Lean*, arXiv:2603.17457, +§2.2, pp. 7-8) report that writing `(2 : R)` for a ring `R` USED to require choice: the `OfNat R 2` +instance needs `Nat.AtLeastTwo`, whose proof used the `lia` tactic, which depends on choice; they +report this fixed in Mathlib. Their constraint forces the audit ours only benefits from — the Kock–Lawvere axiom is inconsistent with excluded middle, so for them a stray `Classical.choice` is a contradiction rather than a blemish. Read every claim below -as "measured at the pinned Mathlib, 2026-08-30", never as a fact about the library. -⚠ Numerals ≥ 2 are CLEAN AT THE PIN: `(2 : ℕ∞)` is `[propext]`, resolving through -`instOfNatAtLeastTwo` and `Nat.cast`. Only `0` and `1` are tainted, and through DIFFERENT -bundles: `1` via `instAddMonoidWithOneENat` (the `AddMonoidWithOne ℕ∞`), `0` via -`instCommSemiringENat` (the `CommSemiring ℕ∞`). ⚠ Cite the INSTANCES, not their projections: +as "measured at the pinned Mathlib", never as a fact about the library. +At the pin, § IV prints: `(0 : ℕ∞)`, `(1 : ℕ∞)`, `(a : ℕ∞) + 1` and `(a : ℕ∞) + ((1 : ℕ) : ℕ∞)` measure +no axioms, and `(2 : ℕ∞)` measures `[propext]` (through `instOfNatAtLeastTwo`); the bundles +`instAddMonoidWithOneENat` (the `AddMonoidWithOne ℕ∞`) and `instCommSemiringENat` (the +`CommSemiring ℕ∞`) carry `Classical.choice`. ⚠ Cite the INSTANCES, not their projections: `AddMonoidWithOne.toOne` is itself axiom-free. -⚠⚠ This docstring previously said ℕ∞ ADDITION is classical "regardless of the summands". That is -FALSE, measured 2026-08-30: `Add ℕ∞`, `HAdd ℕ∞ ℕ∞ ℕ∞`, `NatCast ℕ∞` and `(a : ℕ∞) + (b : ℕ∞)` -all report NO axioms. What carries choice is the LITERAL: `One ℕ∞`, `OfNat ℕ∞ 1` and the bundled -`AddMonoidWithOne ℕ∞` — and `Zero ℕ∞` / `OfNat ℕ∞ 0` likewise. Hence `(a : ℕ∞) + 1` carries it -and `(a : ℕ∞) + ((1 : ℕ) : ℕ∞)` does not. -The CONCLUSION stands and is confirmed directly — `#print axioms ValuationStructure` reports -`Classical.choice`, so `val_scale` as spelled costs choice on every carrier — but it follows from -the numeral, not from the operator. ⚠ And this theorem does not witness it: the same proposition -proved by `induction b with | zero => rfl | succ n ih => rfl` reports NO axioms, so the footprint -below comes from THIS proof term, not from any instance in the statement. An instance's footprint -must be EMITTED, never inferred from a theorem that mentions it. -/ +This theorem carries `Classical.choice` (§ IV) and witnesses nothing about the instances in its +statement: the same proposition proved by `induction b with | zero => rfl | succ n ih => rfl` reports +NO axioms, so the footprint comes from THIS proof term. An instance's footprint must be EMITTED, never +inferred from a theorem that mentions it. -/ -- ⚠ THE NAME RECORDS THE ORIGINAL, MISTAKEN DIAGNOSIS and is kept as a stable handle (R-NAMING: --- never rename a formal identifier). The choice is the NUMERAL, not the addition, and this --- theorem's own footprint is its proof term's — the same proposition proved by induction and --- `rfl` is axiom-free. Same technique, one domain over: ZeroParadox/Ordinal/SyntacticCollapse.lean --- pins Mathlib's ℚ instances the same way, by a `rfl` proof that still reports choice. +-- never rename a formal identifier). At the pin neither the addition nor the numerals carry choice +-- (§ IV), and this theorem's own footprint is its proof term's — the same proposition proved by +-- induction and `rfl` is axiom-free. Same technique, one domain over: +-- ZeroParadox/Ordinal/SyntacticCollapse.lean pins Mathlib's ℚ instances the same way, by a `rfl` +-- proof that still reports choice. theorem enat_add_choice (a b : ℕ) : (a : ℕ∞) + (b : ℕ∞) = ((a + b : ℕ) : ℕ∞) := (Nat.cast_add a b).symm -/-- **ZP-J `val_scale`, literal form — carries the `ℕ∞`-NUMERAL choice.** The same fact as -`v2_scale_nat`, written with the successor in `ℕ∞` exactly as the ZP-J axiom states it (`val x + 1`). -Its footprint is `[propext, Classical.choice, Quot.sound]`, from the `ℕ∞` numeral (`One ℕ∞`), NOT from -the addition. ⚠ On THIS carrier (ℕ) that is the whole story. On ℤ_[2] it is not: `PadicInt` itself -carries `Classical.choice`, so `q2Val_scale` would be tainted even with a choice-free numeral, and -the two contributions do NOT separate there. -/ +/-- **ZP-J `val_scale`, literal form.** The same fact as `v2_scale_nat`, written with the successor in +`ℕ∞` exactly as the ZP-J axiom states it (`val x + 1`). Its footprint is +`[propext, Classical.choice, Quot.sound]` (§ IV), through its proof: `v2`, the numeral `(1 : ℕ∞)` and +`(a : ℕ∞) + 1` print clean there. ⚠ On ℤ_[2] `PadicInt` itself carries `Classical.choice`, so every +statement mentioning that carrier, `q2Val_scale` included, carries it whatever its proof. -/ theorem v2_scale (n : ℕ) (hn : n ≠ 0) : v2 (2 * n) = v2 n + 1 := by rw [v2_scale_nat n hn, v2, if_neg hn, Nat.cast_add_one] @@ -210,9 +203,8 @@ either `x` is in the ball around the bottom stream or it is not — no intermedi step-function character of p-adic balls, choice-free via decidability of a bounded quantifier. -/ theorem clopen_gap_at_bot (n : ℕ) (x : Str) : AgreeTo n botStr x ∨ ¬ AgreeTo n botStr x := by - rcases decidableAgreeTo n botStr x with h | h - · exact Or.inr h - · exact Or.inl h + exact Decidable.falseTrueCases (motive := fun _ => AgreeTo n botStr x ∨ ¬ AgreeTo n botStr x) + (fun h => Or.inr h) (fun h => Or.inl h) (decidableAgreeTo n botStr x) /-- Agreement at every depth is incompatible with apartness. -/ theorem not_apart_of_agree_all (x y : Str) (h : ∀ n, AgreeTo n x y) : ¬ Apart x y := by @@ -253,8 +245,8 @@ section PurityCheck open ZeroParadox -- Constructive side: the valuation face. `v2_scale_nat` (the content) is choice-free; `v2_scale` (the --- literal `ℕ∞` axiom form) carries `Classical.choice`, from the NUMERAL (`One ℕ∞`), not the addition. --- ⚠ That localization holds on ℕ only. On ℤ_[2] nothing separates: the choice is INTRODUCED at +-- literal `ℕ∞` axiom form) carries `Classical.choice` through its proof, the numerals and the +-- addition printing clean below. ⚠ On ℤ_[2] nothing separates: the choice is INTRODUCED at -- layer 0 (`padicValNat`), below the completion, and `Padic`/`PadicInt` INHERIT rather than add -- it — which is why both report it. Every statement mentioning that carrier carries it. #print axioms v2nat @@ -268,16 +260,14 @@ open ZeroParadox #print axioms nScale_unique_fp #print axioms nScale_ne_self --- ⭐ THE NUMERAL CLAIM, EMITTED. The docstring at § I says the ℕ∞ numerals `0` and `1` carry --- choice and that ≥ 2 do not. These print the three numerals THEMSELVES rather than the bundles --- they resolve through. ⚠ Three prints settle three numerals; `≥ 2` beyond the `2` shown follows +-- ⭐ THE NUMERAL CLAIM, EMITTED. These print the three numerals THEMSELVES, then the two bundles +-- § I's docstring names. ⚠ Three prints settle three numerals; `≥ 2` beyond the `2` shown follows -- from the shared `instOfNatAtLeastTwo` route, not from this list. private def _enatZero : ℕ∞ := 0 private def _enatOne : ℕ∞ := 1 private def _enatTwo : ℕ∞ := 2 --- ⚠ The pair below is the LOAD-BEARING premise of `Scale.lean`'s `_VScast` counterfactual: the --- addition is clean and only the numeral is not. It was asserted in this file and consumed in --- that one, and printed at neither end until now. +-- ⚠ The pair below is the premise of `Scale.lean`'s `_VSlit`/`_VScast` counterfactual: the +-- successor spelled `+ 1` and spelled `+ ((1 : ℕ) : ℕ∞)`. It is printed here and consumed there. private def _addOne (a : ℕ) : ℕ∞ := (a : ℕ∞) + 1 private def _addOneCast (a : ℕ) : ℕ∞ := (a : ℕ∞) + ((1 : ℕ) : ℕ∞) #print axioms _enatZero diff --git a/ZeroParadox/Valuation/PricedPadicInterface.md b/ZeroParadox/Valuation/PricedPadicInterface.md index 8fd8ee3b..9a45deb1 100644 --- a/ZeroParadox/Valuation/PricedPadicInterface.md +++ b/ZeroParadox/Valuation/PricedPadicInterface.md @@ -64,14 +64,14 @@ these are the numbers it reported, not the numbers that were hoped for). `not_apart_of_agree_all` report **no axioms at all**; `v2_bot`, `v2_unique` and `clopen_gap_at_bot` report `[propext]`; `v2_scale_nat`, `nScale_unique_fp`, `nScale_ne_self` report `[propext, Quot.sound]` and `agree_all_iff` reports `[Quot.sound]` (the `funext`). -* **One instance-level exception, on the constructive side, reported not hidden.** The ZP-J `val_scale` - axiom in its literal form `v2_scale : v2 (2n) = v2 n + 1` reports `[propext, Classical.choice, - Quot.sound]` — **and on this carrier (ℕ) it is not the carrier's.** It is the ambient `ℕ∞` - NUMERAL: `One ℕ∞` carries it, while `Add ℕ∞`, `Nat.cast : ℕ → ℕ∞` and `(a : ℕ∞) + (b : ℕ∞)` - are all axiom-free — measured 2026-08-30, and `(2 : ℕ∞)` is clean too, so it is the `0` and `1` - numerals specifically. The content of the axiom is choice-free — `v2_scale_nat` states the same +* **Two declarations on the constructive side carry `Classical.choice` — `v2_scale` and the exhibit + `enat_add_choice` — both through their proofs; each has a choice-free counterpart.** The ZP-J + `val_scale` axiom in its literal form `v2_scale : v2 (2n) = v2 n + 1` reports `[propext, Classical.choice, Quot.sound]` — + **and on this carrier (ℕ) it is neither the carrier's nor the statement's.** `v2`, the numeral + `(1 : ℕ∞)` and `(a : ℕ∞) + 1` all print clean in the Lean file's purity block, so the choice comes + from `v2_scale`'s proof. The content of the axiom is choice-free — `v2_scale_nat` states the same fact with the successor on `ℕ` and comes out `[propext, Quot.sound]`. ⚠ None of this carries over - to `ℤ_[2]`, where the carrier itself is tainted. See "The `ℕ∞`-numeral finding". + to `ℤ_[2]`, where the carrier itself is tainted. See "Where the constructive side's two choices arrive". * **The crossing — `Classical.choice`.** `natToZ2`, `natToZ2_bot`, `natToZ2_scale` and `crossVal_bot_agrees` all report `[propext, Classical.choice, Quot.sound]`. @@ -81,20 +81,18 @@ Mathlib's p-adic results are eliminable, and it does **not** show `padicValNat`' *in Mathlib* — that would require re-proving Mathlib's valuation API on a different definition, which is not attempted here. `#print axioms` reports how a proof was written, never what a theorem requires. -## The `ℕ∞`-numeral finding — reported, not explained away +## Where the constructive side's two choices arrive -The one INSTANCE-LEVEL `Classical.choice` on the constructive side was not predicted. On the ℕ side it arrives -through Mathlib's `ℕ∞` NUMERAL, not the addition and not the valuation — and, on ℕ, not the carrier: +The Lean file's purity block prints the `ℕ∞` numerals and the bundles they belong to, so where the +constructive side's two `Classical.choice` footprints arrive is read off the instrument. At the pin the numerals +`(0 : ℕ∞)` and `(1 : ℕ∞)`, and `(a : ℕ∞) + 1`, measure no axioms; `(2 : ℕ∞)` measures `[propext]`; the +bundles `instAddMonoidWithOneENat` and `instCommSemiringENat` carry `Classical.choice`. `enat_add_choice` (`(a : ℕ∞) + (b : ℕ∞) = ↑(a + b)`) reports `[propext, Classical.choice, Quot.sound]` — but that is its PROOF TERM, not an instance: the same proposition proved by induction and `rfl` -reports no axioms at all. Measured 2026-08-30, `ℕ∞` ADDITION is choice-free and the LITERAL numerals `0` and `1` are what -is tainted, through DIFFERENT bundles — `1` via `instAddMonoidWithOneENat`, `0` via -`instCommSemiringENat`. This is the documented instance hazard, -here located exactly — and it has a consequence for the ZP-J layer: because `ValuationStructure.val` -targets `ℕ∞` and `val_scale` is stated as `val x + 1`, the *statement* of that axiom carries -`Classical.choice` on **any** carrier, `ℕ` and `ℤ_[2]` alike. So `q2Val_scale`'s footprint (`ZeroParadox/Valuation/Scale.lean`) -is not evidence about what the p-adic completion mathematically REQUIRES. This file separates the two contributions: `v2_scale_nat` isolates the choice-free -valuation content, and the numeral accounts for the rest ON ℕ. ⚠ It does NOT carry over to ℤ_[2]: +reports no axioms at all. `ValuationStructure` itself measures no axioms (`ZeroParadox/Valuation/Scale.lean`'s +purity block), so the *statement* of `val_scale`, `val x + 1`, costs no choice on a carrier that costs +none. This file separates the contributions on ℕ: `v2_scale_nat` isolates the choice-free valuation +content, and `v2_scale`'s proof accounts for the rest. ⚠ It does NOT carry over to ℤ_[2]: `PadicInt` is itself choice-tainted, so nothing there separates. The remaining `Classical.choice` in the crossing (`natToZ2`, `crossVal_bot_agrees`) is attributable to the p-adic target alone. @@ -109,14 +107,14 @@ Two faces, matching the two faces of Group A: axioms hold choice-free with `scale = (2 * ·)`: `scale_bot` (`nScale_bot`), `val_bot` (`v2_bot`), `val_unique` (`v2_unique`); and the fixed-point content `nScale_unique_fp` (the bottom is the unique fixed point of doubling) is proved directly. The fourth axiom, `val_scale`, holds choice-free *in - content* (`v2_scale_nat`) but carries `Classical.choice` *in its literal `ℕ∞`-successor form* - (`v2_scale`) — from the ambient `ℕ∞` NUMERAL, not the addition and, on ℕ, not the carrier - (see "The `ℕ∞`-numeral finding"). + content* (`v2_scale_nat`); its literal `ℕ∞`-successor form `v2_scale` carries `Classical.choice` + through its proof, not through the numeral, the addition or, on ℕ, the carrier + (see "Where the constructive side's two choices arrive"). This is the choice-free mirror of `q2Val_bot`, `q2Val_unique`, `q2Scale_bot` and `q2Scale_unique_fp` (`ZeroParadox/Valuation/Scale.lean`), which prove the same axioms in `ℤ_[2]` via `PadicInt.valuation`; the comparison localizes § V's choice on the ℕ side only. ⚠ On `ℤ_[2]` nothing separates: `PadicInt` is itself choice-tainted, so the carrier alone already accounts - for it whatever the numeral does. + for it. * **The ball face — digit streams `Str := ℕ → Fin 2`.** `AgreeTo n x y` ("agree to depth n") is the ball relation; `Apart x y := ∃ n, x n ≠ y n` is its positive complement. The ultrametric strong triangle (depth form), nested balls, descent to a single point, and total separation all hold @@ -191,7 +189,7 @@ design, not the tree. ## Structure - § I The valuation face — `v2` on ℕ, the ZP-J axioms priced (three choice-free; `val_scale`'s - content choice-free, its literal `ℕ∞` form carrying the instance choice). + content choice-free, its literal `ℕ∞` form's proof carrying choice). - § II The ball face — digit streams, agreement, apartness, separation, choice-free. - § III The crossing — one named map ℕ → `ℤ_[2]`, priced. - § IV Axiom Purity Check — the deliverable. diff --git a/ZeroParadox/Valuation/RiemannSphere.lean b/ZeroParadox/Valuation/RiemannSphere.lean index 728d1dc9..7374e638 100644 --- a/ZeroParadox/Valuation/RiemannSphere.lean +++ b/ZeroParadox/Valuation/RiemannSphere.lean @@ -3,6 +3,7 @@ import Mathlib.Topology.Compactification.OnePoint.ProjectiveLine import Mathlib.NumberTheory.Padics.ProperSpace import ZeroParadox.Die import ZeroParadox.Algebra.WheelFrac +import ZeroParadox.Valuation.SnapDichotomy import Mathlib.Tactic set_option maxHeartbeats 400000 @@ -26,20 +27,20 @@ This file builds the **topological Riemann sphere over ℚ₂** — the one-poin result `rInvHomeo` is that this map is a **homeomorphism** of the sphere, and `rInv_swaps` is that it **swaps the floor `0` with the point at infinity `∞`** (the 0=∞ antipodality, made literal). -Mathlib's field inversion uses `0⁻¹ = 0` and is *discontinuous at 0* (beside `Sphere` and a wheel: the -`example` after `rInv_swaps`); adjoining `∞` and sending `0 ↦ ∞` *repairs* that discontinuity. +Mathlib's field inversion uses `0⁻¹ = 0` and is *discontinuous at 0* (`example`s after `rInv_swaps`, +beside `Sphere` and a wheel); adjoining `∞` and sending `0 ↦ ∞` *repairs* that discontinuity. The real work is the two continuity proofs at the special points (as `x → 0`, `x⁻¹ → ∞`; symmetrically at `∞`), which go through `OnePoint`'s neighborhood-of-∞ API (`nhds_infty_eq`, the cocompact filter) and the fact that `ℚ_[2]` is a `ProperSpace` (closed balls compact, so leaving every compact ⟺ norm → ∞). **Honest scope.** This is a TOPOLOGICAL homeomorphism — the p-adic Riemann sphere, the framework's originating intuition (0 and ∞ antipodal under `z ↦ 1/z`). It is a standalone result. It is **NOT** the -cross-construction "inversion = passing to Cᵒᵖ" unification, which a prior-art check -(`.claude-local/notes/inv_cop_prior_art_2026-06-30.md`) recorded as non-buildable (no common type; the -abstract ⊥↔⊤ swap is already Mathlib's `compl_bot`/`compl_top`). Do not read this as that. +cross-construction "inversion = passing to Cᵒᵖ" unification, which is not built (no common type; the +abstract ⊥↔⊤ swap is already Mathlib's `compl_bot`/`compl_top`; the prior-art record in +`ZeroParadox/BottomCannotBe.lean` § INVERSION). Do not read this as that. ## Structure -- Opening (unheaded) `rInv`, `continuous_rInv`, `rInvHomeo`, `rInv_swaps` — inversion, the 0↔∞ swap. +- § 0 and opening: `onePointInv` (proper normed fields), `rInv`, `rInvHomeo`, `rInv_swaps` — the 0↔∞ swap. - § V–VI `rScale`, `rInv_conj_rScale`, `rScale_valuation` — pole-fixing scalings, a valuation coordinate. - § VII–VIII `sNorm`, `rInvRelIso`, `unitDouble_reach_iff` — the norm preorder; unit and doubling moves. - § IX `upV`, `downV`, `upClosure`, `rInv_conj_upV` — rounding the valuation to a landing; the flip. @@ -53,6 +54,113 @@ open OnePoint Filter Topology -- This is a topological result, not the choice-free core; the purity check notes the footprint. attribute [local instance] Classical.propDecidable +/-! ### § 0. Inversion on the one-point compactification of any proper normed field + +No Mathlib analog located as of 2026-11-04, searched as follows: grep of the pinned Mathlib +`Topology/Compactification/OnePoint/` (its `ProjectiveLine.lean` TODO, to make `equivProjectivization` +a homeomorphism for `K = ℝ`, is not this map); `exact?` on "a continuous self-map of `OnePoint ℝ` +sending `0 ↦ ∞`, `∞ ↦ 0`, `x ↦ x⁻¹` otherwise" (no result); one LeanExplore query (nearest hits +`Homeomorph.onePointCongr`, `OnePoint.continuous_map`, which fix `∞`). Algebraically `onePointInv` is +the swap-matrix case of Mathlib's `OnePoint.instGLAction`. Prior art: TauCeti's `OnePoint.invChart` (c85f4fbf, +2026-10-03), `OnePoint.instContinuousConstSMul` (1e5cb7e8, 2026-10-23); Forster, as cited there, not retrieved. +This section adds an elementary Mathlib-only proof; credits in `ZeroParadox/Valuation/RiemannSphere.md`. -/ + +section General + +variable {K : Type*} [NormedField K] + +/-- `Statement:` inversion on `OnePoint K`: `∞ ↦ 0`, `0 ↦ ∞`, and `x ↦ x⁻¹` on the nonzero points. -/ +noncomputable def onePointInv : OnePoint K → OnePoint K + | (∞ : OnePoint K) => OnePoint.some 0 + | OnePoint.some x => if x = 0 then (∞ : OnePoint K) else OnePoint.some x⁻¹ + +/-- `Statement:` `onePointInv ∞ = 0`. -/ +@[simp] theorem onePointInv_infty : onePointInv (∞ : OnePoint K) = OnePoint.some 0 := rfl + +/-- `Statement:` `onePointInv 0 = ∞`. -/ +@[simp] theorem onePointInv_zero : onePointInv (OnePoint.some (0 : K)) = ∞ := by + simp only [onePointInv, if_pos] + +/-- `Statement:` on a nonzero point `x`, `onePointInv x = x⁻¹`. -/ +theorem onePointInv_coe_ne {x : K} (hx : x ≠ 0) : + onePointInv (OnePoint.some x) = OnePoint.some x⁻¹ := by + simp only [onePointInv, if_neg hx] + +/-- `Statement:` `onePointInv` is its own inverse. -/ +theorem onePointInv_involutive : Function.Involutive (onePointInv (K := K)) := by + intro s + induction s using OnePoint.rec with + | infty => simp + | coe x => + by_cases hx : x = 0 + · subst hx; simp + · rw [onePointInv_coe_ne hx, onePointInv_coe_ne (inv_ne_zero hx), inv_inv] + +/-- `Statement:` over a proper normed field, `onePointInv` is continuous. At `0` the image leaves + every compact set (`tendsto_inv₀_nhdsNE_zero`, with `Metric.cobounded_eq_cocompact`, which is where + `ProperSpace` is consumed); at `∞` it tends to `0` (`tendsto_inv₀_cobounded`). -/ +theorem continuous_onePointInv [ProperSpace K] : Continuous (onePointInv (K := K)) := by + rw [OnePoint.continuous_iff] + refine ⟨?_, ?_⟩ + · -- At ∞: as x leaves every compact, x⁻¹ → 0. + rw [onePointInv_infty, Filter.coclosedCompact_eq_cocompact, ← Metric.cobounded_eq_cocompact] + have hcong : (fun x : K => (OnePoint.some x⁻¹ : OnePoint K)) =ᶠ[Bornology.cobounded K] + (fun x : K => onePointInv (OnePoint.some x)) := by + filter_upwards [Bornology.isBounded_def.mp (Bornology.isBounded_singleton (x := (0 : K)))] + with x hx + have hx0 : x ≠ 0 := by simpa using hx + rw [onePointInv_coe_ne hx0] + exact ((OnePoint.continuous_coe.tendsto _).comp tendsto_inv₀_cobounded).congr' hcong + · rw [continuous_iff_continuousAt] + intro a + by_cases ha : a = 0 + · -- At 0: the image tends to ∞ on the punctured neighborhood and equals ∞ at 0. + subst ha + show Tendsto (fun x : K => onePointInv (OnePoint.some x)) (𝓝 0) + (𝓝 (onePointInv (OnePoint.some (0 : K)))) + rw [onePointInv_zero] + have hpunct : Tendsto (fun x : K => onePointInv (OnePoint.some x)) (𝓝[≠] 0) + (𝓝 (∞ : OnePoint K)) := by + have hcong : (fun x : K => (OnePoint.some x⁻¹ : OnePoint K)) =ᶠ[𝓝[≠] 0] + (fun x : K => onePointInv (OnePoint.some x)) := by + filter_upwards [self_mem_nhdsWithin] with x hx + rw [onePointInv_coe_ne hx] + have hto : Tendsto (Inv.inv : K → K) (𝓝[≠] 0) (Filter.coclosedCompact K) := by + rw [Filter.coclosedCompact_eq_cocompact, ← Metric.cobounded_eq_cocompact] + exact tendsto_inv₀_nhdsNE_zero + exact (OnePoint.tendsto_coe_infty.comp hto).congr' hcong + have hpure : Tendsto (fun x : K => onePointInv (OnePoint.some x)) (pure (0 : K)) + (𝓝 (∞ : OnePoint K)) := by + rw [Filter.tendsto_pure_left] + intro s hs + simpa using mem_of_mem_nhds hs + rw [← nhdsNE_sup_pure (0 : K)] + exact hpunct.sup hpure + · -- Away from 0: the map agrees with `x ↦ x⁻¹` near `a` (`continuousAt_inv₀`). + have hcong : (fun x : K => (OnePoint.some x⁻¹ : OnePoint K)) =ᶠ[𝓝 a] + (fun x : K => onePointInv (OnePoint.some x)) := by + filter_upwards [compl_singleton_mem_nhds ha] with x hx + have hx0 : x ≠ 0 := by simpa using hx + rw [onePointInv_coe_ne hx0] + exact (OnePoint.continuous_coe.continuousAt.comp (continuousAt_inv₀ ha)).congr hcong + +/-- `Statement:` over a proper normed field, `onePointInv` as a homeomorphism of `OnePoint K`. -/ +noncomputable def onePointInvHomeo [ProperSpace K] : OnePoint K ≃ₜ OnePoint K where + toFun := onePointInv + invFun := onePointInv + left_inv := onePointInv_involutive + right_inv := onePointInv_involutive + continuous_toFun := continuous_onePointInv + continuous_invFun := continuous_onePointInv + +/-- `Statement:` over a proper normed field, `onePointInvHomeo` sends `0` to `∞` and `∞` to `0`. -/ +theorem onePointInv_swaps [ProperSpace K] : + onePointInvHomeo (OnePoint.some (0 : K)) = ∞ ∧ + onePointInvHomeo (∞ : OnePoint K) = OnePoint.some 0 := + ⟨onePointInv_zero, onePointInv_infty⟩ + +end General + /-- The 2-adic Riemann sphere: the one-point compactification of ℚ₂. -/ abbrev Sphere : Type := OnePoint ℚ_[2] @@ -70,6 +178,13 @@ theorem rInv_coe_ne {x : ℚ_[2]} (hx : x ≠ 0) : rInv (OnePoint.some x) = OnePoint.some (x⁻¹ : ℚ_[2]) := by simp only [rInv, if_neg hx] +/-- `Statement:` `rInv` is `onePointInv` at `K = ℚ_[2]`. -/ +theorem rInv_eq_onePointInv : rInv = (onePointInv : Sphere → Sphere) := by + funext s + induction s using OnePoint.rec with + | infty => rfl + | coe x => rfl + /-- Inversion is its own inverse: `rInv (rInv s) = s`. -/ theorem rInv_involutive : Function.Involutive rInv := by intro s @@ -80,62 +195,11 @@ theorem rInv_involutive : Function.Involutive rInv := by · subst hx; simp [rInv] · rw [rInv_coe_ne hx, rInv_coe_ne (inv_ne_zero hx), inv_inv] -/-- Inversion is continuous on the sphere. The affine-nonzero part is `tendsto_inv₀`; the genuine work is - the two special points — at `0` the image leaves every compact (`‖x⁻¹‖ → ∞`), so it tends to `∞`, and - symmetrically at `∞`. Uses `OnePoint.nhds_infty_eq` and `ProperSpace ℚ_[2]`. -/ +/-- Inversion is continuous on the sphere: the ℚ₂ instance of `continuous_onePointInv` + (`ProperSpace ℚ_[2]`), through `rInv_eq_onePointInv`. -/ theorem continuous_rInv : Continuous rInv := by - rw [OnePoint.continuous_iff] - refine ⟨?_, ?_⟩ - · -- Tendsto at ∞: as x leaves every compact, x⁻¹ → 0, so rInv ↑x → ↑0. - rw [rInv_infty, Filter.coclosedCompact_eq_cocompact, - ← Metric.cobounded_eq_cocompact] - have hcong : (fun x : ℚ_[2] => (OnePoint.some (x⁻¹) : Sphere)) =ᶠ[Bornology.cobounded ℚ_[2]] - (fun x : ℚ_[2] => rInv ↑x) := by - filter_upwards [Bornology.isBounded_def.mp (Bornology.isBounded_singleton (x := (0 : ℚ_[2])))] - with x hx - have hx0 : x ≠ 0 := by simpa using hx - rw [rInv_coe_ne hx0] - refine Filter.Tendsto.congr' hcong ?_ - exact (OnePoint.continuous_coe.tendsto _).comp tendsto_inv₀_cobounded - · -- Continuity of g x = rInv ↑x everywhere. - rw [continuous_iff_continuousAt] - intro a - by_cases ha : a = 0 - · -- At 0: g 0 = ∞, and g → ∞ as x → 0. - subst ha - have hval : rInv (OnePoint.some (0 : ℚ_[2])) = ∞ := rInv_zero - show ContinuousAt (fun x : ℚ_[2] => rInv ↑x) 0 - rw [ContinuousAt, hval] - -- Tendsto (fun x => rInv ↑x) (𝓝 0) (𝓝 ∞). - have hpunct : Filter.Tendsto (fun x : ℚ_[2] => rInv ↑x) (𝓝[≠] 0) (𝓝 (∞ : Sphere)) := by - have hcong : (fun x : ℚ_[2] => (OnePoint.some (x⁻¹) : Sphere)) =ᶠ[𝓝[≠] 0] - (fun x : ℚ_[2] => rInv ↑x) := by - filter_upwards [self_mem_nhdsWithin] with x hx - have hx0 : x ≠ 0 := hx - rw [rInv_coe_ne hx0] - refine Filter.Tendsto.congr' hcong ?_ - have hto : Filter.Tendsto (Inv.inv : ℚ_[2] → ℚ_[2]) (𝓝[≠] 0) - (Filter.coclosedCompact ℚ_[2]) := by - rw [Filter.coclosedCompact_eq_cocompact, ← Metric.cobounded_eq_cocompact] - exact tendsto_inv₀_nhdsNE_zero - exact OnePoint.tendsto_coe_infty.comp hto - -- Combine punctured nhds with the point value (= ∞). - have hpure : Filter.Tendsto (fun x : ℚ_[2] => rInv ↑x) (pure (0 : ℚ_[2])) (𝓝 (∞ : Sphere)) := by - rw [Filter.tendsto_pure_left] - intro s hs - have : rInv (OnePoint.some (0 : ℚ_[2])) = ∞ := rInv_zero - simpa [this] using mem_of_mem_nhds hs - rw [← nhdsNE_sup_pure (0 : ℚ_[2])] - exact Filter.Tendsto.sup hpunct hpure - · -- Away from 0: g = ↑(·⁻¹) near a, continuous via continuousAt_inv₀. - have hcong : (fun x : ℚ_[2] => (OnePoint.some (x⁻¹) : Sphere)) =ᶠ[𝓝 a] - (fun x : ℚ_[2] => rInv ↑x) := by - filter_upwards [compl_singleton_mem_nhds ha] with x hx - have hx0 : x ≠ 0 := by simpa using hx - rw [rInv_coe_ne hx0] - have hca : ContinuousAt (fun x : ℚ_[2] => (OnePoint.some (x⁻¹) : Sphere)) a := - OnePoint.continuous_coe.continuousAt.comp (continuousAt_inv₀ ha) - exact hca.congr hcong + rw [rInv_eq_onePointInv] + exact continuous_onePointInv /-- The p-adic Riemann-sphere inversion as a homeomorphism (a continuous involution is its own continuous inverse). -/ @@ -153,18 +217,67 @@ theorem rInv_swaps : rInvHomeo (OnePoint.some (0 : ℚ_[2])) = ∞ ∧ rInvHomeo ∞ = OnePoint.some (0 : ℚ_[2]) := ⟨rInv_zero, rInv_infty⟩ --- Statement: `(0 : ℚ_[2])⁻¹ = 0` (Mathlib's junk value), `rInv` sends `0` of `ℚ_[2]` to `∞` of `Sphere` --- (`rInv_zero`), and in the wheel of fractions over `ℚ_[2]` at the trivial submonoid `wheelInf` differs --- from both `Wheel.wzero` (`wheelFrac_fork_open`) and `wheelBot` (`inf_ne_bot`). +-- Statement: Mathlib's field inversion on `ℚ_[2]` is not continuous at `0` +-- (`NormedField.continuousAt_inv` at `x = 0`). +example : ¬ ContinuousAt (Inv.inv : ℚ_[2] → ℚ_[2]) 0 := + fun h => NormedField.continuousAt_inv.mp h rfl + +-- Statement: `(0 : ℚ_[2])⁻¹ = 0` (Mathlib's junk value); `rInv` sends `0` of `ℚ_[2]` to `∞` of `Sphere` +-- (`rInv_zero`); and in the wheel of fractions over `ℚ_[2]` at its nonzero elements +-- (`nonZeroDivisors ℚ_[2]`), the wheel's `1/0`, that is `1·/0`, is `wheelInf`, `2/0` is the same class, +-- and `wheelInf` differs from `Wheel.wzero` (`wheelFrac_fork_open`) and from `wheelBot` +-- (`inf_ne_bot`). -- Reading: CARRIER — "what is 1/0" has three answers in three carriers: `0` in the field `ℚ_[2]`, `∞` --- of `Sphere`, and in `WheelFrac` a `wheelInf` plus a distinct `wheelBot` (0·/0) that `Sphere` lacks. +-- of `Sphere`, and `wheelInf` in `WheelFrac`. `wheelBot` (`0·/0`) answers `0/0`, not `1/0`; the wheel +-- has it and `Sphere` has no such element. example : (0 : ℚ_[2])⁻¹ = 0 ∧ rInv (OnePoint.some (0 : ℚ_[2])) = ∞ ∧ - (wheelInf : WheelFrac (⊥ : Submonoid ℚ_[2])) ≠ Wheel.wzero ∧ - (wheelInf : WheelFrac (⊥ : Submonoid ℚ_[2])) ≠ wheelBot := by - have h0 : (0 : ℚ_[2]) ∉ (⊥ : Submonoid ℚ_[2]) := by - rw [Submonoid.mem_bot]; exact zero_ne_one - exact ⟨inv_zero, rInv_zero, (wheelFrac_fork_open _ h0).symm, inf_ne_bot _ h0⟩ + Wheel.wmul Wheel.wone (Wheel.winv Wheel.wzero) = (wheelInf : WheelFrac (nonZeroDivisors ℚ_[2])) ∧ + mk (nonZeroDivisors ℚ_[2]) (2, 0) = wheelInf ∧ + (wheelInf : WheelFrac (nonZeroDivisors ℚ_[2])) ≠ Wheel.wzero ∧ + (wheelInf : WheelFrac (nonZeroDivisors ℚ_[2])) ≠ wheelBot := by + refine ⟨inv_zero, rInv_zero, by rw [Wheel.wmul_comm, Wheel.wmul_one]; rfl, ?_, + (wheelFrac_fork_open _ zero_notMem_nonZeroDivisors).symm, + inf_ne_bot _ zero_notMem_nonZeroDivisors⟩ + refine Quotient.sound ⟨1, one_mem _, 2, mem_nonZeroDivisors_of_ne_zero (by norm_num), ?_, ?_⟩ + · show (1 : ℚ_[2]) * 2 = 2 * 1; ring + · show (1 : ℚ_[2]) * 0 = 2 * 0; ring + +-- Statement: control, at the trivial submonoid `⊥` of `ℚ_[2]`, `2/0` and `1/0` (`wheelInf`) stay +-- distinct classes. +example : mk (⊥ : Submonoid ℚ_[2]) (2, 0) ≠ wheelInf := by + intro h + obtain ⟨s, hs, s', hs', e1, _⟩ := Quotient.exact h + rw [Submonoid.mem_bot] at hs hs' + subst hs; subst hs' + have : (1 : ℚ_[2]) * 2 = 1 * 1 := e1 + norm_num at this + +/-- `Statement:` inversion on `OnePoint ℝ` (`∞ ↦ 0`, `0 ↦ ∞`, `x ↦ x⁻¹` otherwise) is continuous: the + ℝ instance of `continuous_onePointInv`. -/ +theorem continuous_onePointInv_real : Continuous (onePointInv : OnePoint ℝ → OnePoint ℝ) := + continuous_onePointInv + +/-- `Statement:` the homeomorphism `onePointInvHomeo` of `OnePoint ℝ` sends `0` to `∞` and `∞` to `0`: + the ℝ instance of `onePointInv_swaps`, beside `rInv_swaps` for ℚ₂. -/ +theorem onePointInv_swaps_real : + onePointInvHomeo (OnePoint.some (0 : ℝ)) = ∞ ∧ + onePointInvHomeo (∞ : OnePoint ℝ) = OnePoint.some 0 := + onePointInv_swaps + +-- Statement: Mathlib's field inversion on `ℝ` is not continuous at `0`, as on `ℚ_[2]` above. +example : ¬ ContinuousAt (Inv.inv : ℝ → ℝ) 0 := + fun h => NormedField.continuousAt_inv.mp h rfl + +-- Statement: control, inversion on `OnePoint ℚ_[2]` and on `OnePoint ℝ` is continuous +-- (`continuous_rInv`, `continuous_onePointInv_real`; both swap `0` and `∞`: `rInv_swaps`, +-- `onePointInv_swaps_real`), `ℚ_[2]` is totally disconnected (`padic_snaps`) and `ℝ` is not +-- (`real_no_snap`). +-- Reading: CARRIER — the pole exchange holds in both carriers; total disconnectedness separates them. +example : + (Continuous rInv ∧ Continuous (onePointInv : OnePoint ℝ → OnePoint ℝ)) ∧ + TotallyDisconnectedSpace ℚ_[2] ∧ ¬ TotallyDisconnectedSpace ℝ := + ⟨⟨continuous_rInv, continuous_onePointInv_real⟩, padic_snaps 2, real_no_snap⟩ /-! ### § V. The maps that FIX the pole-pair, and why that makes it an AXIS @@ -172,9 +285,10 @@ example : pole-pair additively in `n`, which is what makes it an *axis* rather than a bare pair. ⭐ **PRIOR ART — these declarations INSTANTIATE `OnePoint.instGLAction`, they do not extend it.** The -two `example`s closing this section are the identification, elaborated rather than asserted. What is -ours is the TOPOLOGY, not the algebra. Prior art, the loxodromic vocabulary and the stabiliser fence -are in `ZeroParadox/Valuation/RiemannSphere.md`, beside this file. -/ +three `example`s closing this section are the identification, elaborated rather than asserted. The +topology has prior art too (TauCeti's `OnePoint.instContinuousConstSMul` covers these scalings); this +file adds an elementary Mathlib-only proof and the ℚ₂ application. Prior art, the loxodromic vocabulary +and the stabiliser fence: `ZeroParadox/Valuation/RiemannSphere.md`, beside this file. -/ /-- Scaling by `2 ^ n` on the sphere: `∞ ↦ ∞` and `x ↦ 2 ^ n * x`. -/ @@ -372,9 +486,9 @@ valuation shells (`unitDouble_mutual_iff`), ordered one way by valuation (`unitD every move fixes `0` of `ℚ_[2]`, its own one-point class (`unitDouble_zero_own_class`). Doubling raises valuation and halves the norm: down toward `0` of `ℚ_[2]` in the `sNorm` preorder (§ VII). -Standard frame, on nonzero points only: the value group of the valuation ring `ℤ_[2]` (Mathlib -`ValuationRing.ValueGroup`; Stacks 00ID); at `0` of `ℚ_[2]` the orders part. `example`s after -`unitDouble_zero_own_class`. -/ +Standard frame, on nonzero points only: the value group `ℚ_[2]ˣ / ℤ_[2]ˣ`. Reaching `y` from `x` is +`[y] ≤ [x]` in Mathlib's `ValuationRing.ValueGroup` (OPPOSITE) and `[y] ≥ [x]` in Stacks 00ID (`y / x` +from `ℤ_[2]`, SAME). At `0` of `ℚ_[2]` the orders part. `example`s after `unitDouble_zero_own_class`. -/ /-- `Statement:` one move multiplies by a unit (norm `1`) or by `2`. -/ def unitDoubleStep (x y : ℚ_[2]) : Prop := (∃ u : ℚ_[2], ‖u‖ = 1 ∧ y = u * x) ∨ y = 2 * x @@ -443,13 +557,34 @@ theorem unitDouble_zero_own_class (x : ℚ_[2]) : subst ih rcases hm with ⟨u, _, rfl⟩ | rfl <;> simp --- Statement: on nonzero points `x` reaches `y` iff `‖y / x‖ ≤ 1`, i.e. `y ∈ x · ℤ_[2]`: the order of --- `ValuationRing.ValueGroup`, whose unit orbits are the cells of `unitDouble_mutual_iff`. +-- Statement: on nonzero points `x` reaches `y` iff `‖y / x‖ ≤ 1`, i.e. `y ∈ x · ℤ_[2]`. example {x y : ℚ_[2]} (hx : x ≠ 0) (hy : y ≠ 0) : Relation.ReflTransGen unitDoubleStep x y ↔ ‖y / x‖ ≤ 1 := by rw [unitDouble_reach_iff hx hy, Padic.norm_le_one_iff_val_nonneg, div_eq_mul_inv, Padic.valuation_mul hy (inv_ne_zero hx), Padic.valuation_inv]; omega +-- Statement: on nonzero points `x` reaches `y` iff `[y] ≤ [x]` in Mathlib's +-- `ValuationRing.ValueGroup ℤ_[2] ℚ_[2]`: Mathlib's order runs opposite to reachability. Its unit +-- orbits are the cells of `unitDouble_mutual_iff`. +example {x y : ℚ_[2]} (hx : x ≠ 0) (hy : y ≠ 0) : + Relation.ReflTransGen unitDoubleStep x y ↔ + @LE.le (ValuationRing.ValueGroup ℤ_[2] ℚ_[2]) _ (Quotient.mk'' y) (Quotient.mk'' x) := by + show _ ↔ ∃ c : ℤ_[2], c • x = y + rw [unitDouble_reach_iff hx hy] + constructor + · intro h + have hn : ‖y / x‖ ≤ 1 := by + rw [Padic.norm_le_one_iff_val_nonneg, div_eq_mul_inv, + Padic.valuation_mul hy (inv_ne_zero hx), Padic.valuation_inv]; omega + exact ⟨Padic.lift (y / x) hn, by rw [Algebra.smul_def]; simp [div_mul_cancel₀ y hx]⟩ + · rintro ⟨c, rfl⟩ + rw [Algebra.smul_def] at hy ⊢ + have hc : (algebraMap ℤ_[2] ℚ_[2] c) ≠ 0 := left_ne_zero_of_mul hy + have hc1 : ‖algebraMap ℤ_[2] ℚ_[2] c‖ ≤ 1 := c.2 + rw [Padic.valuation_mul hc hx] + have := (Padic.norm_le_one_iff_val_nonneg _).1 hc1 + omega + -- Statement: control, at `0` of `ℚ_[2]` the orders part: `1` divides `0` in `ℤ_[2]` and `0 / 1` is a -- 2-adic integer, yet `1` does not reach `0`: divisibility puts `0` on top, reachability in its own -- class (`unitDouble_zero_own_class`). @@ -457,7 +592,9 @@ example : (1 : ℤ_[2]) ∣ 0 ∧ ‖(0 : ℚ_[2]) / 1‖ ≤ 1 ∧ ¬ Relation.ReflTransGen unitDoubleStep 1 0 := ⟨dvd_zero 1, by simp, (unitDouble_zero_own_class 1).1 one_ne_zero⟩ --- Statement: control, `x = 0`: `‖1 / 0‖ ≤ 1` (`1 / 0 = 0`, after `rInv_swaps`) yet `0 ∤ 1`, no reach. +-- Statement: control, `x = 0`: `‖1 / 0‖ ≤ 1` yet `0 ∤ 1` in `ℤ_[2]`, and `0` does not reach `1`. The +-- first conjunct holds only by Mathlib's junk value `1 / 0 = 0` in `ℚ_[2]` (`div_zero`); `rInv` on +-- `Sphere` sends `0` to `∞` instead (`rInv_zero`). example : ‖(1 : ℚ_[2]) / 0‖ ≤ 1 ∧ ¬ (0 : ℤ_[2]) ∣ 1 ∧ ¬ Relation.ReflTransGen unitDoubleStep 0 1 := ⟨by simp, by rw [zero_dvd_iff]; exact one_ne_zero, @@ -578,15 +715,8 @@ example (z : Sphere) : upV z = z ↔ example {x : ℚ_[2]} (hx : x ≠ 0) : ((2 : ℚ_[2]) ^ (x.valuation % 2) * x).valuation = 2 * ⌈(x.valuation : ℚ) / 2⌉ := by rw [rScale_valuation _ hx] - have : ⌈(x.valuation : ℚ) / 2⌉ = (x.valuation + 1) / 2 := by - rw [Int.ceil_eq_iff] - constructor - · rw [lt_div_iff₀ (by norm_num)] - have : (((x.valuation + 1) / 2 : ℤ) - 1) * 2 < x.valuation := by omega - exact_mod_cast this - · rw [div_le_iff₀ (by norm_num)] - have : x.valuation ≤ ((x.valuation + 1) / 2 : ℤ) * 2 := by omega - exact_mod_cast this + have := Rat.ceil_intCast_div_natCast x.valuation 2 + push_cast at this rw [this]; omega -- Statement: on nonzero `x`, DOWN sends the valuation `v` to `2 * ⌊v / 2⌋`, the floor onto the even @@ -594,15 +724,8 @@ example {x : ℚ_[2]} (hx : x ≠ 0) : example {x : ℚ_[2]} (hx : x ≠ 0) : ((2 : ℚ_[2]) ^ (-(x.valuation % 2)) * x).valuation = 2 * ⌊(x.valuation : ℚ) / 2⌋ := by rw [rScale_valuation _ hx] - have : ⌊(x.valuation : ℚ) / 2⌋ = x.valuation / 2 := by - rw [Int.floor_eq_iff] - constructor - · rw [le_div_iff₀ (by norm_num)] - have : ((x.valuation / 2 : ℤ)) * 2 ≤ x.valuation := by omega - exact_mod_cast this - · rw [div_lt_iff₀ (by norm_num)] - have : x.valuation < ((x.valuation / 2 : ℤ) + 1) * 2 := by omega - exact_mod_cast this + have := Rat.floor_intCast_div_natCast x.valuation 2 + push_cast at this rw [this]; omega -- Statement: for every integer `v`, `2 * ⌈-v / 2⌉ = -(2 * ⌊v / 2⌋)`: rounding up after negating is @@ -686,12 +809,16 @@ theorem sNorm_coe_le_iff {x y : ℚ_[2]} (hx : x ≠ 0) (hy : y ≠ 0) : /-- `Statement:` UP as a Mathlib `ClosureOperator` (monotone, extensive, idempotent) on the reverse of § VII's `sNorm` preorder, where `0` of `ℚ_[2]` is top and `∞` of `Sphere` bottom. On - valuations it is the closure of the ceiling Galois connection (`Int.gc_ceil_coe`) onto the even - integers; compare the ceiling `ClosureOperator ℝ` in `ZeroParadox/Order/UpAndOver.lean`. `Sphere` - is no `UpAndOver` member: that structure takes `[PartialOrder α]` and this is a preorder. + valuations it is `v ↦ 2 * ⌈v / 2⌉` (the second `example` after `downV`): the closure of the + ceiling Galois connection (`Int.gc_ceil_coe`), which lands on `ℤ`, rescaled by `2` onto the even + integers; + compare the ceiling `ClosureOperator ℝ` in `ZeroParadox/Order/UpAndOver.lean`. That `UpAndOver` + structure takes `[PartialOrder α]`, and this preorder is not antisymmetric (`1` and `-1` of + `ℚ_[2]`, the first `example` after this definition), so `upClosure` is not an `UpAndOver` instance as it + stands. `Reading:` **INVERSION** — `rInv` is an order isomorphism to the order dual, and `conjBy` along it carries `upClosure` to `downV`, the corpus's kernel form (`keepAboveKernel`, `pruneKernel`): - the `example` after this definition. -/ + the second `example` after this definition. -/ noncomputable def upClosure : @ClosureOperator Sphere (Preorder.lift (fun s => OrderDual.toDual (sNorm s))) := letI : Preorder Sphere := Preorder.lift (fun s => OrderDual.toDual (sNorm s)) @@ -735,6 +862,21 @@ noncomputable def upClosure : show upV (upV a) = upV a rw [← downV_upV a, upV_downV] } +-- Statement: the reverse `sNorm` preorder is not antisymmetric: `1` and `-1` of `ℚ_[2]` lie below each +-- other and are distinct points of `Sphere`. +example : + letI : Preorder Sphere := Preorder.lift (fun s => OrderDual.toDual (sNorm s)) + (OnePoint.some (1 : ℚ_[2]) : Sphere) ≤ OnePoint.some (-1) ∧ + (OnePoint.some (-1 : ℚ_[2]) : Sphere) ≤ OnePoint.some 1 ∧ + (OnePoint.some (1 : ℚ_[2]) : Sphere) ≠ OnePoint.some (-1) := by + letI : Preorder Sphere := Preorder.lift (fun s => OrderDual.toDual (sNorm s)) + refine ⟨?_, ?_, fun h => ?_⟩ + · show sNorm (OnePoint.some (-1)) ≤ sNorm (OnePoint.some 1); simp [sNorm] + · show sNorm (OnePoint.some 1) ≤ sNorm (OnePoint.some (-1)); simp [sNorm] + · have h1 : (1 : ℚ_[2]) = -1 := OnePoint.coe_injective h + have h2 : (2 : ℚ_[2]) = 0 := by linear_combination h1 + exact two_ne_zero h2 + -- Statement: on the reverse `sNorm` preorder, `rInv` is an order isomorphism `Sphere ≃o Sphereᵒᵈ`, and -- `upClosure.conjBy` along it is `downV` at every point of `Sphere`. example (z : Sphere) : @@ -835,6 +977,18 @@ end ZeroParadox /-! ## Axiom Purity Check (enable per theorem once proved) -/ section PurityCheck open ZeroParadox +-- § 0: inversion on the one-point compactification of a proper normed field, and its ℝ instances. +#print axioms onePointInv +#print axioms onePointInv_infty +#print axioms onePointInv_zero +#print axioms onePointInv_coe_ne +#print axioms onePointInv_involutive +#print axioms continuous_onePointInv +#print axioms onePointInvHomeo +#print axioms onePointInv_swaps +#print axioms rInv_eq_onePointInv +#print axioms continuous_onePointInv_real +#print axioms onePointInv_swaps_real #print axioms rInv_involutive #print axioms continuous_rInv #print axioms rInv_swaps diff --git a/ZeroParadox/Valuation/RiemannSphere.md b/ZeroParadox/Valuation/RiemannSphere.md index d4a78a7c..bcc4568e 100644 --- a/ZeroParadox/Valuation/RiemannSphere.md +++ b/ZeroParadox/Valuation/RiemannSphere.md @@ -28,17 +28,43 @@ They are `example`s deliberately: an anonymous declaration owes no `#print axiom `ssot.json` row, and it stops compiling if the identification ever fails. That makes the prior-art claim checkable rather than asserted, which is the whole point of stating it here. -## What IS ours: the topology +## The topology: prior art, and what this file adds -That file's own TODO, at line 21, reads: +That file's own TODO, at line 20, reads: > Add the extension of this equivalence to a homeomorphism in the case `K = ℝ`, where `OnePoint ℝ` > gets the topology of one-point compactification. -So the homeomorphism extension is absent from Mathlib **even for the reals**. `continuous_rInv`, -`rInvHomeo`, `rScaleHomeo` and `continuous_rScale` are the genuine contribution of this file. The -real work is `continuous_rInv`'s two special points: as `x → 0` the image leaves every compact set, -which needs `ProperSpace ℚ_[2]` and `OnePoint.nhds_infty_eq`. +The equivalence it names is `equivProjectivization : OnePoint K ≃ ℙ K (K × K)`, so the TODO asks for a +topology on the projectivization and a homeomorphism to it. It does not ask for the inversion map, and +`onePointInvHomeo` does not fill it: that is a self-homeomorphism of `OnePoint K`. + +Continuity of inversion on the one-point compactification of a proper normed field is a standard fact, +with prior art: + +- **Mathlib at the pin:** not located as of 2026-11-05, searched as follows: the § 0 search record in + `RiemannSphere.lean` (2026-11-04), and, on 2026-11-05, `infer_instance` and `exact?` on + `ContinuousConstSMul (GL (Fin 2) ℝ) (OnePoint ℝ)`, both failing. +- **TauCeti** (github.com/TauCetiProject/TauCeti) formalized it independently: + `OnePoint.invChart`, a chart for proper nontrivially normed fields (introduced at commit c85f4fbf, + 2026-10-03, PR #11176), and + `OnePoint.instContinuousConstSMul : ContinuousConstSMul (GL (Fin 2) 𝕜) (OnePoint 𝕜)` (commit + 1e5cb7e8, 2026-10-23, PR #19887), which makes + every Möbius map a homeomorphism and so also covers the scaling maps (`rScaleHomeo`, + `continuous_rScale`) and the inversions (`onePointInvHomeo`, `rInvHomeo`). Source read by the + 2026-11-05 prior-art gate; not elaborated here, being outside this project's dependency closure. +- **Algebraically**, `onePointInv` is the swap-matrix case `!![0, 1; 1, 0]` of Mathlib's + `OnePoint.instGLAction`; the `example`s closing § V state this for `rInv`. +- **Informal source:** Forster, *Lectures on Riemann Surfaces* (GTM 81), as cited by TauCeti: §§ 1–2 + at its `Moebius.lean`, § 1.5 (c) at `invChart` (`OnePoint/Basic.lean`); not retrieved. + +What this file adds is narrower: an elementary proof inside Mathlib alone, with no manifold structure, +under `[NormedField K] [ProperSpace K]` (`continuous_onePointInv`, `onePointInvHomeo`); the ℚ₂ +application (`continuous_rInv`, `rInvHomeo` on `Sphere`); and the ℝ-against-ℚ₂ comparison +(`continuous_onePointInv_real`, `onePointInv_swaps_real`, and the `Reading: CARRIER` control after +them: the pole exchange holds in both carriers, and total disconnectedness separates them). The proof's +work is at the two special points: as `x → 0` the image leaves every compact set, which needs +`ProperSpace K` and `Metric.cobounded_eq_cocompact`. ## The pole stabiliser is much bigger than the scalings diff --git a/ZeroParadox/Valuation/Scale.lean b/ZeroParadox/Valuation/Scale.lean index 32bc7260..0e6c3f35 100644 --- a/ZeroParadox/Valuation/Scale.lean +++ b/ZeroParadox/Valuation/Scale.lean @@ -32,7 +32,8 @@ open ZeroParadox (3) val x = ⊤ → x = ⊥ (uniqueness of infinite valuation) (4) val (scale x) = val x + 1 for x ≠ ⊥ (scale strictly increases valuation) - In ℚ_[2]: scale = ×2, val = 2-adic valuation. All four hold. + In ℤ_[2]: scale = ×2, val = the 2-adic valuation; all four hold (§ V). In ℚ_[2] no `val` into + ℕ∞ meets them with scale = ×2, whatever the semilattice (the last `example` of § V). In ZPSemilattice: abstract encoding of the same structure. -/ -- [ZP-CUSTOM] replaces: Valued (Mathlib/Topology/Algebra/Valued/ValuationTopology.lean) | reason: Mathlib's Valued typeclass requires ring/field structure (it formalizes algebraic valuations over rings). ZPSemilattice has join only — no ring. ValuationStructure uses val : L → ℕ∞ (not a GroupWithZero target) and four axioms (§ I lists them). The fixed-point uniqueness argument consumes TWO of them — val_unique and val_scale; scale_bot and val_bot appear in none of the three proof terms on that chain, measured 2026-08-30. ⚠ val_scale alone does NOT suffice, measured 2026-08-30: on Bool with bot = false, scale = id and val everywhere ⊤, scale_bot/val_bot/val_scale all hold and true is a fixed point of scale that is not the bottom. val_unique supplies the FINITENESS that makes val_scale bite. ⚠ THE NEARER NEIGHBOUR IS `AddValuation`, NOT `Valued`, and this reason answered the wrong one until 2026-09-01: `AddValuation R ℕ∞` targets a `LinearOrderedAddCommMonoidWithTop`, which is exactly this class's target, so "not a `GroupWithZero` target" rebuts `Valuation` and says nothing about it. The real discriminator is the CARRIER: `AddValuation` requires `[Ring R]` and a `ZPSemilattice` has only a join — the same discriminator `ZeroParadox/Algebra/Wheel.lean` recorded for `AddValuation A ℕ∞` on 2026-08-01, which this tag had not picked up. ⚠ `AddValuation.top_iff` IS NOT THE NAME FOR THE `val_bot` + `val_unique` PAIR HERE, and this tag said it was until 2026-09-01: `top_iff` is stated over a `[DivisionRing K]` (Mathlib/RingTheory/Valuation/Basic.lean:71, and its own docstring says "on a division ring"), and ℤ_[2] is a DVR, not a division ring — 2 is not invertible. On ℤ_[2] the stock route to `val_unique` is `emultiplicity_eq_top` together with `FiniteMultiplicity.of_prime_left`: x ≠ 0 with 2 prime gives finite multiplicity, hence val x ≠ ⊤. Found by both prose gates independently, one of which compiled the failure. ⚠ On a RING carrier there is no gap at all: `multiplicity_addValuation PadicInt.prime_p` discharges all four axioms on ℤ_[2] from stock API with an unguarded `val_scale` — see § V. class ValuationStructure (L : Type*) [ZPSemilattice L] where @@ -152,8 +153,8 @@ theorem val_quine_unique (x y : L) (hx : selfMemFromVal x) (hy : selfMemFromVal y) : x = y := by rw [scale_unique_fp x hx, scale_unique_fp y hy] -/-- {x | selfMemFromVal x} = {⊥}. Carries Classical.choice; the `[ValuationStructure L]` assumption - alone suffices for that, since a trivial statement under it already carries choice. -/ +/-- {x | selfMemFromVal x} = {⊥}. Footprint: the PurityCheck below, where `ValuationStructure` + itself measures no axioms. -/ theorem val_selfMem_singleton : {x : L | selfMemFromVal x} = ({bot} : Set L) := singleton_from_unique_witness @@ -201,10 +202,14 @@ theorem q2Val_unique (x : ℤ_[2]) (h : q2Val x = ⊤) : x = 0 := by /-- scale = ×2 fixes 0. -/ theorem q2Scale_bot : (2 : ℤ_[2]) * 0 = 0 := by ring +-- Statement: at the pinned Mathlib, `PadicInt.valuation_p` closes the numeral goal with no rewrite. +example : (2 : ℤ_[2]).valuation = 1 := PadicInt.valuation_p + /-- v₂(2x) = v₂(x) + 1 for x ≠ 0 in ℤ_[2]. Proof: valuation_mul gives v(2x) = v(2) + v(x); valuation_p gives v(2) = 1. - Note: valuation_p expects the cast form ((2:ℕ) : ℤ_[2]), so we rewrite the - numeral (2 : ℤ_[2]) via Nat.cast_ofNat.symm before applying valuation_p. -/ + valuation_p is stated over the cast form ((2:ℕ) : ℤ_[2]); the proof rewrites the + numeral (2 : ℤ_[2]) via Nat.cast_ofNat.symm first, a rewrite the pinned Mathlib does + not need (the `example` before this docstring). -/ theorem q2Val_scale (x : ℤ_[2]) (hx : x ≠ 0) : q2Val (2 * x) = q2Val x + 1 := by have h2x : 2 * x ≠ 0 := mul_ne_zero two_ne_zero hx @@ -286,15 +291,15 @@ theorem z2_two_views : re-founded 2-adic type would change the question is separate and not addressed. ⚠ `ZPSemilattice` itself is clean — it is this carrier, not that class. `PadicInt` is the evidence and `q2Scale_bot` is the consequence — a theorem with no ℕ∞ and no equality test in it, tainted - anyway. ⚠ The class's own numeral is a SEPARATE cost, and an ACCIDENTAL one in the sense - `ZeroParadox/Category/ChoiceCannotBe.lean` defines and sources: respelling the successor as a - cast from ℕ clears the class outright. ⚠ The numeral half is pin-relative; its routes, its - dated measurements and the Brasca–Clemente prior art are in - `ZeroParadox/Valuation/PricedPadicInterface.lean` § I (`enat_add_choice`). The CARRIER half is - not pin-relative in the same way — it follows from the printer walking the TYPE, so it holds of any statement mentioning - `ℤ_[2]` for as long as `PadicInt` is built with choice. ⚠ The two counterfactual PAIRS below emit exactly that — carrier, - then numeral. ⚠ The footprint UNIVERSAL here (ruled out for every spelling) is not emitted and - cannot be — a footprint list settles instances, never universals. The printer's own type-walk + anyway. ⚠ The class adds no cost of its own: `ValuationStructure`, and both transcriptions of + its fields below (`_VSlit`, successor `+ 1`; `_VScast`, successor `+ ((1 : ℕ) : ℕ∞)`), measure + no axioms at the pin. The numeral's routes and the Brasca–Clemente prior art on numeral + footprints are in `ZeroParadox/Valuation/PricedPadicInterface.lean` § I (`enat_add_choice`). The + CARRIER's cost follows from the printer walking the TYPE, so it holds of any statement + mentioning `ℤ_[2]` for as long as `PadicInt` is built with choice. ⚠ The two counterfactual + PAIRS below emit both — the carrier, then the class. + ⚠ The footprint UNIVERSAL here (ruled out for every spelling) is not emitted and cannot be — + a footprint list settles instances, never universals. The printer's own type-walk IS emitted, by `_trivialAboutZ2` / `_trivialAboutNat` below. -/ example : ∃ h : ZPSemilattice ℤ_[2], @ZPSemilattice.bot _ h = 0 ∧ ∃ v : @ValuationStructure ℤ_[2] h, v.val = q2Val ∧ v.scale = (2 * ·) ∧ @@ -332,6 +337,36 @@ example (h : ZPSemilattice ℤ_[2]) (hb : @ZPSemilattice.bot _ h = 0) : (by rw [hb]; exact q2Val_bot) (fun x hx => hb ▸ q2Val_unique x hx) (fun x hx => q2Val_scale x (hb ▸ hx))⟩ +-- Statement: on ℚ_[2] no `ValuationStructure` has scale `×2`, whatever the `ZPSemilattice`: +-- `scale_bot` forces `bot = 0`, `val_scale` along `(2 ^ n)⁻¹` gives `val 1 ≥ n` for every `n`, so +-- `val 1 = ⊤`, and `val_unique` would make `1 = 0`. +example (h : ZPSemilattice ℚ_[2]) (v : @ValuationStructure ℚ_[2] h) + (hs : v.scale = (2 * ·)) : False := by + have hb : @ZPSemilattice.bot _ h = 0 := by + have := v.scale_bot; rw [hs] at this + linear_combination this + have key : ∀ n : ℕ, v.val 1 = v.val ((2 : ℚ_[2]) ^ n)⁻¹ + n := by + intro n + induction n with + | zero => simp + | succ k ih => + have hne : ((2 : ℚ_[2]) ^ (k + 1))⁻¹ ≠ @ZPSemilattice.bot _ h := by + rw [hb]; exact inv_ne_zero (pow_ne_zero _ two_ne_zero) + have hsc := v.val_scale _ hne + rw [hs] at hsc + have h2 : (2 : ℚ_[2]) * ((2 : ℚ_[2]) ^ (k + 1))⁻¹ = ((2 : ℚ_[2]) ^ k)⁻¹ := by + rw [pow_succ, mul_inv, ← mul_assoc, mul_comm (2 : ℚ_[2]), mul_assoc, + mul_inv_cancel₀ (two_ne_zero), mul_one] + simp only at hsc + rw [h2] at hsc + rw [ih, hsc, add_assoc]; push_cast; ring + have htop : v.val 1 = ⊤ := by + refine ENat.eq_top_iff_forall_ge.2 fun n => ?_ + rw [key n]; exact le_add_self + have := v.val_unique 1 htop + rw [hb] at this + exact one_ne_zero this + end PadicParallel end ZeroParadox @@ -376,9 +411,9 @@ private theorem _trivialAboutNat : ∀ _ : ℕ, (0 : ℕ) = 0 := fun _ => rfl -- Carrier, not class: same class, two carriers, opposite answers. private def _zpsZ2 : Type := ZPSemilattice ℤ_[2] private def _zpsN : Type := ZPSemilattice ℕ --- Numeral, and ACCIDENTAL: `ValuationStructure`'s six fields transcribed TWICE (§ I), differing --- only in how the successor is spelled. Stated at the class, not at a bare ℕ∞ value, because --- that is the level the claim is about. +-- Numeral: `ValuationStructure`'s six fields transcribed TWICE (§ I), differing only in how the +-- successor is spelled; both measure no axioms (printed below). Stated at the class, not at a bare +-- ℕ∞ value, because that is the level the claim is about. private class _VSlit (L : Type*) [ZPSemilattice L] where scale : L → L val : L → ℕ∞ @@ -400,9 +435,10 @@ private class _VScast (L : Type*) [ZPSemilattice L] where -- (1) a field added WITH a default -- build green, both guards silent, footprints unchanged, -- and the transcription is then short by one field; -- (2) a field RETYPED to something DEFEQ -- respelling the canonical `val_scale` as --- `+ ((1 : ℕ) : ℕ∞)` elaborates through every example unchanged, exit 0, while the --- footprints flip. Elaboration preserves definitional equality; `#print axioms` does not, --- and that difference is precisely what this block measures. +-- `+ ((1 : ℕ) : ℕ∞)` elaborates through every example unchanged, exit 0, whatever the +-- footprints do. Elaboration preserves definitional equality; `#print axioms` does not +-- (a defeq pair with opposite footprints: `ZeroParadox/Category/ChoiceCannotBe.lean` § III, +-- the `WithTop` entry), and that difference is precisely what this block measures. -- So build-breaks implies the field lists diverged; build-passes does NOT imply they agree. -- Anonymous, so nothing is owed. example {L : Type*} [ZPSemilattice L] (v : ValuationStructure L) : _VSlit L := @@ -422,9 +458,9 @@ example {L : Type*} [ZPSemilattice L] (b : _VScast L) : _VSlit L := #print axioms _zpsN #print axioms _VSlit #print axioms _VScast --- The class TYPE carries choice, and the numeral in `val_scale` is THE route, not merely one --- of several: `_VScast` above respells that numeral and NOTHING else, and comes out clean, so --- no other constituent of the class is tainted. Both lines below are carrier-free. +-- The class TYPE measures no axioms, as both transcriptions above do, while the +-- `AddMonoidWithOne ℕ∞` bundle carries choice, so the class does not reach that bundle. Both +-- lines below are carrier-free. #print axioms ValuationStructure #print axioms instAddMonoidWithOneENat diff --git a/ZeroParadox/Valuation/Scale.md b/ZeroParadox/Valuation/Scale.md index aff425d6..3e8491ef 100644 --- a/ZeroParadox/Valuation/Scale.md +++ b/ZeroParadox/Valuation/Scale.md @@ -41,7 +41,7 @@ ZeroParadox/Valuation/ScaleBridge.lean resolves this by defining ValBridge — t with bot as a plain field — and builds a formal ℤ_[2] instance using the standalone theorems in `ZeroParadox/Valuation/Scale.lean` § V. A toValBridge instance makes any ZPSemilattice+ValuationStructure type also a ValBridge instance, unifying both tracks under a common ancestor. -The formal gap described in `ZeroParadox/Valuation/Scale.lean` § V is closed. +The gap once recorded at `ZeroParadox/Valuation/Scale.lean` § V is closed (§ V below). ## § V — the 2-adic parallel: what holds, what is registered, and the prior art @@ -53,7 +53,9 @@ REGISTERED, and whether one EXISTS, are not the same question, and only the firs instance synthesis reports. Both are measured: `#synth` fails, because no such instance is declared; and the existential is provable, because § V's closing example supplies a semilattice with bottom 0 and discharges all four axioms over it. ⚠ So "ℤ_[2] cannot be a ValuationStructure -instance" is true only in the not-registered reading and false read modally (both readings measured 2026-08-30). The related gap +instance" is true only in the not-registered reading and false read modally (both readings measured +2026-11-03: `#synth ZPSemilattice ℤ_[2]` fails in a scratch file importing +`ZeroParadox.Valuation.Scale`, run with `lake env lean`, and § V's semilattice `example` elaborates). The related gap once recorded at `ZeroParadox/Valuation/Scale.lean` § V — "a ZPSemilattice instance for a concrete type carrying a ValuationStructure" — is CLOSED in two independent ways: ℕ∞ carries both structures (`instNatInfZPS` and `instNatInfVal` in `ZeroParadox/Settheory/Model.lean`, which imports Scale.lean), and @@ -61,8 +63,9 @@ type carrying a ValuationStructure" — is CLOSED in two independent ways: ℕ **Why ℤ_[2] and not ℚ_[2].** `PadicInt.valuation : ℤ_[2] → ℕ` is ℕ-valued, which is what makes `q2Val_scale` provable. In ℚ_[2], `valuation : ℚ_[2] → ℤ` can be negative, and the `.toNat` -truncation makes the key identity false (take x = 2⁻¹). ⚠ That is a fact about a ℕ∞-TARGETED -valuation built by truncation — the only kind this class admits — and NOT a fact about ℚ_[2]. +truncation makes the key identity false (take x = 2⁻¹). ⚠ That concerns ℕ∞-TARGETED +valuations, the only kind this class admits: no ℕ∞-valued `val` meets the four axioms on ℚ_[2] +with scale ×2 (the last `example` of `Scale.lean` § V). With another target ℚ_[2] carries it: `Padic.addValuation : AddValuation ℚ_[2] (WithTop ℤ)` has no truncation, satisfies the same identity, and is already used at `ZeroParadox/Valuation/ValuationAFA_Padic.lean`. The obstruction is this class's ℕ∞ target, a design choice, not the field. diff --git a/ZeroParadox/Valuation/ScaleBridge.lean b/ZeroParadox/Valuation/ScaleBridge.lean index 16c12a66..0abd8aa8 100644 --- a/ZeroParadox/Valuation/ScaleBridge.lean +++ b/ZeroParadox/Valuation/ScaleBridge.lean @@ -33,7 +33,7 @@ open ZeroParadox /-- Same four axioms as ValuationStructure, but `bot` is a plain field. No ZPSemilattice required — the join operation ⊔ never appears in any axiom. -/ --- [ZP-CUSTOM] replaces: ValuationStructure (ZeroParadox/Valuation/Scale.lean) | reason: ValuationStructure required [ZPSemilattice L] but the join operation ⊔ never appears in any of its four axioms — the constraint was an encoding artefact. ValBridge carries the same four axioms with bot as a plain field, allowing ℤ_[2] (for which no ZPSemilattice is defined) to be a formal instance. Unifies both tracks under one ancestor. +-- [ZP-CUSTOM] replaces: ValuationStructure (ZeroParadox/Valuation/Scale.lean) | reason: ValuationStructure required [ZPSemilattice L] but the join operation ⊔ never appears in any of its four axioms — the constraint was an encoding artefact. ValBridge carries the same four axioms with bot as a plain field, allowing ℤ_[2] (for which no ZPSemilattice is registered as an instance; one is built inside an `example` of ZeroParadox/Valuation/Scale.lean § V) to be a formal instance. Unifies both tracks under one ancestor. class ValBridge (L : Type*) where bot : L scale : L → L @@ -80,14 +80,15 @@ theorem selfMem_eq_singleton_free : /-! ## § III. ℤ_[2] Instance — The Formal Bridge -/ /-- ℤ_[2] with scale = ×2 and val = v₂ is a ValBridge. - bot = 0. All four proved as standalone theorems in ZeroParadox/Valuation/Scale.lean: q2Val_bot, --- q2Val_unique, q2Scale_bot, q2Scale_unique_fp. + bot = 0. All four proved as standalone theorems in ZeroParadox/Valuation/Scale.lean: + q2Scale_bot, q2Val_bot, q2Val_unique, q2Val_scale. This is the formal instance that ZeroParadox/Valuation/Scale.lean did not build, - because no ZPSemilattice ℤ_[2] is defined — showing the ZPSemilattice constraint - was an encoding artefact, not a mathematical requirement. ⚠ "not defined", never - "not possible": ℤ_[2] is INFINITE, so `nonempty_valBridge_of_infinite` (§ VI) gives - the instance outright. -/ --- [ZP-CUSTOM] instance: ValBridge ℤ_[2] | reason: no ZPSemilattice ℤ_[2] is defined — its ring structure supplies no natural join with 0 as bottom — so ℤ_[2] does not satisfy ValuationStructure, which requires one. (A fact about what is DEFINED, never about what is POSSIBLE. ⚠ Inhabitation is the sole obstruction to ZPSemilattice ALONE, not to this class: valBridge_nonempty_iff (§ VI) settles membership exactly — infinite, or inhabited and trivial — and Bool is inhabited yet admits none. ℤ_[2] qualifies by being INFINITE. Being a ring is not the obstruction either, and ZPSemilattice ℕ exists. What has NOT been located as of 2026-08-30 is a NATURAL join, searched over every registered ZPSemilattice instance in this corpus.) ValBridge's bot-as-plain-field design drops the requirement, which the four axioms never used anyway. All four delegate directly to q2Scale_bot, q2Val_bot, q2Val_unique and q2Val_scale, proved in ZeroParadox/Valuation/Scale.lean. + because no ZPSemilattice ℤ_[2] is registered as an instance (one is built, unregistered, + inside the proof of the `example` in ZeroParadox/Valuation/Scale.lean § V) — showing the + ZPSemilattice constraint was an encoding artefact, not a mathematical requirement. + ⚠ "not registered", never "not possible": ℤ_[2] is INFINITE, so + `nonempty_valBridge_of_infinite` (§ VI) gives the instance outright. -/ +-- [ZP-CUSTOM] instance: ValBridge ℤ_[2] | reason: no ZPSemilattice ℤ_[2] is registered as an instance — a natural join with 0 as bottom was not located (dated search below) — so no ValuationStructure on ℤ_[2], which requires one, is registered either. One of each is built inside a proof and not registered (the `example` in ZeroParadox/Valuation/Scale.lean § V: some ZPSemilattice ℤ_[2] with 0 as bot carries a ValuationStructure). (A fact about what is REGISTERED, never about what is POSSIBLE. ⚠ Inhabitation is the sole obstruction to ZPSemilattice ALONE, not to this class: valBridge_nonempty_iff (§ VI) settles membership exactly — infinite, or inhabited and trivial — and Bool is inhabited yet admits none. ℤ_[2] qualifies by being INFINITE. Being a ring is not the obstruction either, and ZPSemilattice ℕ exists. What has NOT been located as of 2026-08-30 is a NATURAL join, searched over every registered ZPSemilattice instance in this corpus.) ValBridge's bot-as-plain-field design drops the requirement, which the four axioms never used anyway. All four delegate directly to q2Scale_bot, q2Val_bot, q2Val_unique and q2Val_scale, proved in ZeroParadox/Valuation/Scale.lean. noncomputable instance instZ2ValBridge : ValBridge ℤ_[2] where bot := 0 scale := (2 * ·) @@ -351,7 +352,9 @@ theorem valBridge_scale_not_injective : -- Statement: infinitude ALONE suffices — no property of ℤ_[2] beyond its cardinality is used. -- (`instZ2ValBridge` above is a separate, sharper witness with the actual 2-adic scale and val.) -example : Nonempty (ValBridge ℤ_[2]) := nonempty_valBridge_of_infinite _ +example : Nonempty (ValBridge ℤ_[2]) := + haveI : Infinite ℤ_[2] := Infinite.of_injective ((↑) : ℕ → ℤ_[2]) Nat.cast_injective + nonempty_valBridge_of_infinite _ -- Statement: the two-element carrier is excluded. `Nontrivial` is supplied here rather than -- registered, so this example adds no declaration. diff --git a/ZeroParadox/Valuation/ScaleBridge.md b/ZeroParadox/Valuation/ScaleBridge.md index 9fc7cd31..25883de9 100644 --- a/ZeroParadox/Valuation/ScaleBridge.md +++ b/ZeroParadox/Valuation/ScaleBridge.md @@ -8,8 +8,8 @@ the declarations, the Engineer's Take and the per-declaration glosses. `ZeroParadox/Valuation/Scale.lean` defines `ValuationStructure` over `[ZPSemilattice L]`, but the four axioms (`scale_bot`, `val_bot`, `val_unique`, `val_scale`) only ever use `bot` — the join `⊔` never appears. So `ZPSemilattice` is an over-strong constraint, and no `ValuationStructure` `ℤ_[2]` is -DEFINED even though all four axioms hold (proved as standalone theorems in -`ZeroParadox/Valuation/Scale.lean` § V). +registered as an instance even though all four axioms hold (proved as standalone theorems in +`ZeroParadox/Valuation/Scale.lean` § V; one is built inside an `example` there, not registered). ⚠⚠ **Not defined is not the same as not possible, and here the difference decides the answer.** `Nonempty (ValuationStructure ℤ_[2])` fails to elaborate only because no `ZPSemilattice ℤ_[2]` @@ -71,13 +71,12 @@ membership — **do not cite membership as evidence that a witness is non-degene ## Prior art **In this corpus, and it is the general form:** `orbit_dichotomy` -(`ZeroParadox/Order/OrbitDichotomy.lean`), whose file header already names the framework's scale map as -the checkable branch of exactly this argument. Cite that for the general pattern. +(`ZeroParadox/Order/OrbitDichotomy.lean`), whose header notes that the framework's scale map runs the +same argument (`valBridge_forces_infinite`). Cite that for the general pattern. ⚠ **`valBridge_forces_infinite` is NOT an instance of it.** That theorem assumes `Function.Injective s`; -`ValBridge` does not supply it — take `L = {bot} ⊎ (ℕ × Bool)` with `val (n, b) = n` and -`scale (n, b) = (n+1, false)`, which satisfies all four axioms and collapses `(0, true)` with -`(0, false)`. `val_scale` buys injectivity *along an orbit*, which is all the argument consumes. +`ValBridge` does not supply it: the counter-model is `valBridge_scale_not_injective` +(`ZeroParadox/Valuation/ScaleBridge.lean`). `val_scale` buys injectivity *along an orbit*, which is all the argument consumes. The two-element case is older still: `ZeroParadox/Settheory/OntBridge.lean` records that `OntologicalStates` admits no `ValuationStructure`, by `valuationStructure_forces_infinite` — the @@ -93,8 +92,9 @@ says nothing about it. Credit points outward. For the degenerate half, the reason a non-degeneracy condition must be an inequation rather than a further equation is cited from Burris & Sankappanavar, *A Course in Universal Algebra*, each passage -with its own page, in `ZeroParadox/Valuation/InfinitudeFloor.md` § *Prior art*. ⚠ Their p. 250 remark -"trivial algebras satisfy any quasi-identity" does **not** apply here: `val_scale`'s antecedent +with its own page, in `ZeroParadox/Valuation/InfinitudeFloor.md` § *Prior art*. ⚠ The clause +"trivial algebras satisfy any quasi-identity", in the proof of their Thm 2.25 (p. 250), does **not** +apply here: `val_scale`'s antecedent `x ≠ bot` is a negated atom, and a quasi-identity admits only positive ones. Standard names, for searching: `(L, scale)` is a **mono-unary algebra** (a **unar**), and the mechanism diff --git a/ZeroParadox/Valuation/SemilatticeInstance.lean b/ZeroParadox/Valuation/SemilatticeInstance.lean index a4caebf5..1a4a1362 100644 --- a/ZeroParadox/Valuation/SemilatticeInstance.lean +++ b/ZeroParadox/Valuation/SemilatticeInstance.lean @@ -69,8 +69,12 @@ I defer to my AI assistant on how the internals are put together. --- -T-IZ proves convergence to 0 in Q₂; reading it as an occupant of the ⊥ role, and that occupant as -a successor null, are further COMMITMENTS. Overview and fences: `SemilatticeInstance.md`. +`Reading:` once a join on Q₂ is chosen, the role half is a theorem (`t_iz_limit_is_new_null`); the corpus calls +that reading a choice of join, and only the successor reading (C-DA2) a commitment. + +T-IZ proves convergence to 0 in Q₂; reading it as an occupant of the ⊥ role takes a choice of join +(which point fills the role depends on the join chosen), and reading that occupant as a successor +null is a COMMITMENT (C-DA2). Overview and fences: `SemilatticeInstance.md`. Key results: t_iz_cauchy (topological core; inherits Classical.choice from Mathlib analysis), t_iz_complete (all steps formal). -/ @@ -319,16 +323,16 @@ example {L : Type*} [ZPSemilattice L] (x : L) : /-! ## II. Valuation-Complexity Bridge — REFUTED -The informal route v₂(Sₙ) → ∞ ⟹ K(Sₙ|n)/|Sₙ| → 1 is refuted (counterexample Sₙ = 2ⁿ); T-IZ never -depended on it (it goes through `t_iz_cauchy`). Counterexample: ZP-I § II.B; its valuation half is -`scaleChain_isDepthChain` (`ZeroParadox/Valuation/ScaleDepthWitness.lean`); its complexity half is outside Lean scope. +The informal route v₂(Sₙ) → ∞ ⟹ K(Sₙ|n)/|Sₙ| → 1 is refuted by a counterexample (Sₙ = 2ⁿ); its status, +the counterexample and its Lean valuation half are recorded in the R-BRIDGE row of `CLAIMS.md`. T-IZ +never depended on it (it goes through `t_iz_cauchy`). Why `t_iz_complete` computes no K either, and the `da1_paths_unified` fence: `SemilatticeInstance.md`. -/ /-! ## III. T-IZ — Inside Zero Theorem -/ /-- T-IZ (convergence): this IS `t_iz_cauchy`, with an unused start guard. Six-step outline: - ZP-I § III. Step 2, the valuation-complexity bridge, is refuted (counterexample Sₙ = 2ⁿ, - ZP-I § II.B); T-IZ never depended on it. Step 6 cites `da2_bottom_characterization` for the + ZP-I § III. Step 2, the valuation-complexity bridge, is refuted (status: `CLAIMS.md`); + T-IZ never depended on it. Step 6 cites `da2_bottom_characterization` for the role half only: what plays the ⊥ role of a `ZPSemilattice` is that ⊥. That the return is to a NEW bottom is a commitment (C-DA2), not a theorem; in ℤ_[2] the arc tends back to the same 0 (`snap_arc_z2_loop`). Conjunction form: `t_iz_complete`. -/ @@ -338,7 +342,8 @@ theorem t_inside_zero (h_bound : ∀ n : ℕ, ‖S n‖ ≤ (2⁻¹ : ℝ) ^ n) : Filter.Tendsto S Filter.atTop (nhds 0) := -- _h_start: semantic guard — chain begins away from 0 (unused in convergence proof) - -- h_bound: v₂(Sₙ) ≥ n — the ascending chain has unbounded valuation + -- h_bound: ‖Sₙ‖ ≤ 2⁻ⁿ, i.e. v₂(Sₙ) ≥ n — along the ℚ₂ sequence S the valuation climbs while the + -- norm falls; S is linked to a chain's depths only by IsDepthChain / TracksDepth -- Conjunction form: t_iz_complete (§ III-B); it does not link the limit to the ⊥ role. t_iz_cauchy S h_bound @@ -348,7 +353,8 @@ theorem t_inside_zero is the bottom element of its semilattice — the structural role of ⊥. ⚠ The role property is the HYPOTHESIS, never the conclusion, and this says nothing about Q₂: `ZPSemilattice ℚ_[2]` does not synthesize, so the join-identity is not - statable of `0 : ℚ₂`. Nor is novelty (this theorem's gloss in SnapCannotBe.lean). See CLAIMS.md's T-IZ row. -/ + statable of `0 : ℚ₂` until a join is chosen (the `example`s after `c_t_iz_null_balance`). + Nor is novelty (this theorem's gloss in SnapCannotBe.lean). See CLAIMS.md's T-IZ row. -/ theorem t_iz_limit_is_new_null {L : Type*} [ZPSemilattice L] (terminal : L) @@ -358,10 +364,13 @@ theorem t_iz_limit_is_new_null /-- C-T-IZ (Null Balance). `Statement:` a non-bottom state cannot satisfy the join-identity role — the role is EXCLUSIVE to ⊥, one direction, inside one semilattice. - `Reading:` occupancy of that role by the 2-adic limit is a COMMITMENT, not a theorem — - `ZPSemilattice ℚ_[2]` does not synthesize, so the condition is not statable of that limit; - successor-hood is a further commitment (C-DA2). The additive balance is NOT carried here: - a `ZPSemilattice` has `join` and `bot` and no additive inverse. See `SemilatticeInstance.md`. -/ + `Statement:` the `example`s below state: some chosen join makes any point its ⊥; under doubling + only 0 occupies `Motion.SelfOnlyAt`; under squaring 1 does too. + `Reading:` that the 2-adic limit occupies THIS role takes a choice of join on ℚ₂, and which point + fills it depends on the join chosen (the CONTROL below); + in a fixed semilattice the occupant is its ⊥ by theorem (above); an identity with ⊥ of another + semilattice is ill-typed (MC-1). Successor-hood is a commitment, C-DA2. + No additive balance here (no inverse in a `ZPSemilattice`). See `SemilatticeInstance.md`. -/ theorem c_t_iz_null_balance {L : Type*} [ZPSemilattice L] (S : L) @@ -369,6 +378,39 @@ theorem c_t_iz_null_balance ¬(∀ x : L, join S x = x) := c_da2_novelty S h_not_bot +-- Statement: CONTROL: every point `p` of ℚ₂ is ⊥ of some `ZPSemilattice ℚ_[2]` (`max` in an order +-- with `p` least, built through a well-ordering), so the join-identity role holds of any point under +-- some chosen join. +example (p : Q₂) : ∃ h : ZPSemilattice Q₂, ∀ x, @ZPSemilattice.join _ h p x = x := by + classical + letI : LinearOrder Q₂ := IsWellOrder.linearOrder (WellOrderingRel (α := Q₂)) + let f : Q₂ → Lex (Bool × Q₂) := fun x => toLex (decide (x ≠ p), x) + have hinj : Function.Injective f := fun x y h => by + simpa [f] using congrArg (fun q => (ofLex q).2) h + obtain ⟨R, hR⟩ : ∃ R : Q₂ → Q₂ → Prop, ∀ x y, R x y ↔ f x ≤ f y := ⟨_, fun _ _ => Iff.rfl⟩ + have hf : ∀ x, f p ≤ f x := fun x => by + by_cases hx : x = p + · rw [hx] + · exact Prod.Lex.toLex_le_toLex.mpr (Or.inl (by simp [hx])) + obtain ⟨LO, hLO⟩ : ∃ LO : LinearOrder Q₂, ∀ x y, LO.le x y ↔ R x y := + ⟨LinearOrder.lift' f hinj, fun x y => (hR x y).symm⟩ + have hbot : ∀ x, @LE.le Q₂ LO.toLE p x := fun x => (hLO p x).2 ((hR p x).2 (hf x)) + let SL : ZPSemilattice Q₂ := + { join := @max Q₂ LO.toMax, bot := p, join_assoc := @max_assoc Q₂ LO + join_comm := @max_comm Q₂ LO, join_idem := @max_self Q₂ LO + bot_join := fun x => @max_eq_right Q₂ LO _ _ (hbot x) } + exact ⟨SL, fun x => @max_eq_right Q₂ LO _ _ (hbot x)⟩ +-- Statement: doubling on ℚ₂: a point steps to itself and to nothing else iff it is 0; both directions +-- (`Motion.SelfOnlyAt`; the ℤ_[2] form is `z2_double_selfOnlyAt_iff`). +example (y : Q₂) : (Motion.ofFun (fun x : Q₂ => 2 * x)).SelfOnlyAt y ↔ y = 0 := + (Motion.selfOnlyAt_ofFun_iff _ y).trans + ⟨fun h => by linear_combination h, fun h => by rw [h, mul_zero]⟩ + +-- Statement: CONTROL: under squaring on ℚ₂, also ring structure, a point steps to itself only iff it +-- is 0 or 1, so which point occupies `Motion.SelfOnlyAt` depends on the chosen step. +example (y : Q₂) : (Motion.ofFun (fun x : Q₂ => x * x)).SelfOnlyAt y ↔ y = 0 ∨ y = 1 := + (Motion.selfOnlyAt_ofFun_iff _ y).trans IsIdempotentElem.iff_eq_zero_or_one + /-- T-IZ (C3 compatible): Cauchy sequence convergence and continuous-path irreversibility are distinct structures. C3 (ZP-B) closes every continuous path from x ≠ 0 to 0. T-IZ uses Cauchy sequence convergence — a sequence (Sₙ)_{n∈ℕ} tending to 0, @@ -385,11 +427,12 @@ theorem t_iz_c3_compatible : The § II Kolmogorov bridge is not needed here: this route discharges step 4 from `AFAStructure` fields and never computes K. That is a fact about this proof, not evidence the AFA and K/AIT paths are one property — ZP-K's `da1_paths_unified` is a conjunction of -witnesses and fences the identity reading as a commitment. +witnesses, and reading the two paths as one fact is the framework's reading, not proved by it. `t_iz_complete` carries the four steps as a CONJUNCTION, not a chain; its type is the step list. `ZPSemilattice ℚ_[2]` does not synthesize, so the role condition is not statable of the -2-adic limit — the two are distinct MEMBERS of the bottom family, not one object (MC-1). -/ +2-adic limit until a join is chosen (§ IV); the limit and `terminal` are members of the bottom +family, and an identity between them is ill-typed (MC-1). -/ /-- T-IZ: all four formal steps in one theorem — a CONJUNCTION, not a chain. L' carries a KleeneStructure; the terminal element's join-identity is a HYPOTHESIS diff --git a/ZeroParadox/Valuation/SemilatticeInstance.md b/ZeroParadox/Valuation/SemilatticeInstance.md index 1bdaa87a..a9bb4422 100644 --- a/ZeroParadox/Valuation/SemilatticeInstance.md +++ b/ZeroParadox/Valuation/SemilatticeInstance.md @@ -4,20 +4,41 @@ Ride-along companion to `ZeroParadox/Valuation/SemilatticeInstance.lean`. ## Theorem T-IZ, stated exactly -Every maximal ascending chain in the Zero Paradox framework is a Cauchy sequence that -**converges to 0 in Q₂**. That is the whole of what is proved about the chain. - -⚠ **Two further readings, both commitments, neither part of the statement:** - -1. **Occupancy** — reading that limit as an OCCUPANT of the ⊥ role. This is not merely - unproved. `ZPSemilattice ℚ_[2]` does not synthesize, so the join-identity is **not statable** - of the limit: a type error, not a missing lemma. +A sequence `S : ℕ → Q₂` with `‖Sₙ‖ ≤ 2⁻ⁿ` **converges to 0 in Q₂** (`t_iz_cauchy`, whose +conclusion is the convergence; Cauchy follows from it; `t_inside_zero` is the same with an unused +guard `S 0 ≠ 0`). That convergence is the whole of what `t_iz_cauchy` states; it is the first conjunct of +`t_iz_complete`, the T-IZ that `CLAIMS.md` ratifies. In this file `S` is linked to a +depth index `depths : ℕ → ℕ` (a strict state sequence in `ℕ`, in `h_strict_from_r1_t3`) only by the +modelling hypothesis `IsDepthChain`, or its weaker form `TracksDepth`; no theorem in this file takes a +chain in any other `ZPSemilattice`. `ZeroParadox/Valuation/ScaleRealization.lean` reaches strict +valuation ascent along a realized orbit `n ↦ ρ (scale^[n] x)` from equivariance and a nonzero start +`ρ x ≠ 0` (`realized_strict`). + +⚠ **Two further readings, neither part of the statement: occupancy takes a choice of join, novelty is a commitment:** + +1. **Occupancy** — reading that limit as an OCCUPANT of the ⊥ role, the join-identity of a + `ZPSemilattice`. This is not merely unproved. `ZPSemilattice ℚ_[2]` does not synthesize, so + the join-identity is **not statable** of the limit: a type error, not a missing lemma. A join + on ℚ₂ can be chosen, through a well-ordering, and then its ⊥ fills the role, and any point can + be that ⊥ (the CONTROL `example` after `c_t_iz_null_balance`): that SOME join makes the limit + its ⊥ is proved, and reading the limit as the occupant takes a choice of a particular join; which + point fills the role depends on the join chosen. An identity between the limit and + ⊥ of another semilattice is ill-typed (MC-1). Under doubling, a step defined from ℚ₂'s ring + operations with no join picked, the die's role `Motion.SelfOnlyAt` (`ZeroParadox/Die.lean`, a + point that steps to itself and to nothing else) has 0 as its only occupant (the `example` after + the CONTROL); under squaring, also defined from the ring operations, 1 occupies it as well (the + CONTROL after that), so the occupant follows the step. All three statements carry + `Classical.choice`, from Mathlib's ℚ₂ itself (measured 2026-11-03: any statement over ℚ_[2], + even `x = x`, prints `Classical.choice`; the first CONTROL also uses a well-ordering), so the contrast between doubling + and the chosen join is one of which structure is picked, not of the axiom footprint. 2. **Novelty** — reading that occupant as the chain's own *successor* null. This is C-DA2, and the `t_iz_limit_is_new_null` gloss in `Order/SnapCannotBe.lean` forbids citing that theorem as its witness. So there are three tiers, and `CLAIMS.md`'s T-IZ row is the ratified statement of them: -**convergence PROVED · role-recognition PROVED as an implication · occupancy a COMMITMENT · -novelty a further COMMITMENT.** +**convergence PROVED · role-recognition PROVED as an implication · occupancy takes a CHOICE of +join (which point fills the join-identity role depends on the join chosen) · novelty a COMMITMENT +(C-DA2).** Beside them, the die +role under doubling is occupied by 0 alone, PROVED (and occupied by 0 and 1 under squaring). ## What `t_iz_complete` is, and what it is not @@ -84,14 +105,15 @@ It does **not** carry the additive balance `0 + x + (−x) = 0`, and that identi Nor does it establish that the 2-adic limit *occupies* the role. `#synth ZPSemilattice ℚ_[2]` fails (verified by running), so `∀ x, join S x = x` is not a well-formed proposition of that limit — a type -error, not a missing lemma. Occupancy is a commitment; reading the occupant as a successor ⊥′ is a -further one (C-DA2). +error, not a missing lemma — until a join is chosen, and a chosen join makes any point its ⊥ (the +CONTROL `example` after the theorem). Occupancy takes a choice of join, and which point fills the +role depends on the join chosen; reading the occupant as a successor ⊥′ is a commitment (C-DA2). ## The layer's components - **§ I** Cauchy convergence — the topological core (inherits `Classical.choice` from Mathlib analysis) - **§ Ib** `h_strict` from `IsDepthChain` + `IsStrictStateSequence` — closes R-IZ-A (proved) -- **§ II** Valuation-complexity bridge — refuted (counterexample Sₙ = 2ⁿ, ZP-I § II.B); T-IZ never +- **§ II** Valuation-complexity bridge — refuted (status and counterexample: `CLAIMS.md`); T-IZ never depended on it (it goes through `t_iz_cauchy`) - **§ III** The T-IZ theorem and the ⊥ role, role half only (`t_iz_limit_is_new_null`), proved; that the return is to a NEW bottom is C-DA2, a commitment @@ -103,7 +125,7 @@ further one (C-DA2). ## The Kolmogorov bridge is refuted, and T-IZ never used it -**Refuted (counterexample Sₙ = 2ⁿ, ZP-I § II.B); T-IZ never depended on it (it goes through +**Refuted (status and counterexample: `CLAIMS.md`); T-IZ never depended on it (it goes through `t_iz_cauchy`).** `t_iz_complete` computes no Kolmogorov complexity either: its step 4 is `IsQuineAtom (bot : L')`, discharged from class fields alone. That is a fact about this proof route, not a demonstration that the AFA/Kleene path and the K/AIT path are one property: diff --git a/ZeroParadox/Vendored/CorpusAudit/Audit.lean b/ZeroParadox/Vendored/CorpusAudit/Audit.lean index 64e4e464..2d07b071 100644 --- a/ZeroParadox/Vendored/CorpusAudit/Audit.lean +++ b/ZeroParadox/Vendored/CorpusAudit/Audit.lean @@ -8,7 +8,7 @@ Upstream : https://github.com/GuardianEngineAI/corpus (branch main) Commit : 89d2876275ca7e9b935442b4cb20a0e1833225ea, 2026-09-08 (blob ids of all three files verified against that commit's tree, 2026-10-23) Upstream pin: leanprover/lean4:v4.28.0, no package dependencies (core Lean only) -Ported to : leanprover/lean4:v4.30.0-rc2 (this repository's pin) +Ported to : leanprover/lean4:v4.35.0 (this repository's pin) Author : Larsen James Close, 2026 (copyright header retained verbatim below) License : Apache 2.0 (unchanged); full text in `LICENSE` beside this file Namespace : upstream's `Corpus.*`, kept so a local edit diffs cleanly against upstream. No @@ -26,7 +26,7 @@ WHY THIS FILE IS VENDORED CHANGES FROM UPSTREAM (port-probe numbering; marked inline with `-- [ZP port Pn]`) 1. Relation.lean gains the Apache-2.0 header its siblings carry. (local edit; candidate to offer upstream) - 2. Data split from machinery: no `import Corpus`, no hard-coded `ledger`, no `#eval audit`. (local edit; candidate to offer upstream) + 2. Data split from machinery: no `import Corpus`, no hard-coded `ledger`, no `#eval audit`; `stock`'s docstring re-pointed to the consumer's ledger accordingly. (local edit; candidate to offer upstream) 3. Coverage scope is an argument (`inScope`, `inModulesOrMain`), not the `Corpus` prefix. (local edit; candidate to offer upstream) 4. `ProfileRow`: a declared profile for a definition or a theorem that replaces nothing. (local edit; candidate to offer upstream) 5. `coverageModules`: coverage over named modules' constants, 12 ms against 121 s for the whole-environment walk under Mathlib. (local edit; candidate to offer upstream) @@ -34,10 +34,11 @@ CHANGES FROM UPSTREAM (port-probe numbering; marked inline with `-- [ZP port Pn] 6. Declared profiles compare as ordered lists: the right set in the wrong order fails. 7. A failed relation check throws, so it hides every later row's findings. 8. `isAux` exempts by spelling, so a hand-written `foo.proof_1` escapes coverage; upstream - PR #7 replaces it. + PR #7 proposes replacing it (open, not merged, as of 2026-11-01). Local only, not for upstream: import paths renamed to this folder (`-- [ZP port]`). Upstream's v4.28.0 sources compiled and ran unchanged on v4.30.0-rc2 (probe, 2026-10-23). - Full account: `.claude-local/notes/auditor_port_probe_2026-10-23.md` (private). + Port to v4.35.0: Relation.lean's `kernelAccepts` passes the `maxRecDepth` option to + `addDeclCore`, which takes it as an argument there (Relation.lean header, item 2). ================================================================================ -/ @@ -92,7 +93,9 @@ structure Row where predecessor : Name predecessorProfile : List String -/-- The stock profile shared by every predecessor below. -/ +-- [ZP port P2] docstring re-pointed: the predecessors are now in the consumer's ledger. +/-- The stock profile shared by every predecessor in the consumer's ledger +(`ZeroParadox/Meta/AxiomLedger.lean`). -/ def stock : List String := ["Classical.choice", "Quot.sound", "propext"] -- [ZP port P2] upstream's hard-coded `ledger` stood here; the consumer supplies it. diff --git a/ZeroParadox/Vendored/CorpusAudit/AuditChecks.lean b/ZeroParadox/Vendored/CorpusAudit/AuditChecks.lean index 3744808c..2a5fe8e4 100644 --- a/ZeroParadox/Vendored/CorpusAudit/AuditChecks.lean +++ b/ZeroParadox/Vendored/CorpusAudit/AuditChecks.lean @@ -5,7 +5,7 @@ VENDORED FROM GuardianEngineAI/corpus - provenance (Zero Paradox project) Source : Corpus/AuditChecks.lean Upstream : https://github.com/GuardianEngineAI/corpus (branch main) Commit : 89d2876275ca7e9b935442b4cb20a0e1833225ea (blob 1c5b78bc, verified 2026-10-23) -Upstream pin: leanprover/lean4:v4.28.0; ported to this repository's v4.30.0-rc2 +Upstream pin: leanprover/lean4:v4.28.0; ported to this repository's v4.35.0 Author : Larsen James Close License : Apache 2.0 (unchanged; header retained verbatim below); full text in `LICENSE` diff --git a/ZeroParadox/Vendored/CorpusAudit/Relation.lean b/ZeroParadox/Vendored/CorpusAudit/Relation.lean index e6c9de83..e93dc6f7 100644 --- a/ZeroParadox/Vendored/CorpusAudit/Relation.lean +++ b/ZeroParadox/Vendored/CorpusAudit/Relation.lean @@ -5,7 +5,7 @@ VENDORED FROM GuardianEngineAI/corpus - provenance (Zero Paradox project) Source : Corpus/Relation.lean Upstream : https://github.com/GuardianEngineAI/corpus (branch main) Commit : 89d2876275ca7e9b935442b4cb20a0e1833225ea (blob 71dfda33, verified 2026-10-23) -Upstream pin: leanprover/lean4:v4.28.0; ported to this repository's v4.30.0-rc2 +Upstream pin: leanprover/lean4:v4.28.0; ported to this repository's v4.35.0 Author : Larsen James Close License : Apache 2.0; full text in `LICENSE` beside this file @@ -13,7 +13,8 @@ Why vendored, and the full list of changes: the provenance block of `Audit.lean` Changes to THIS file: 1. The Apache-2.0 header below was added; upstream's copy of this file carries none, so it is copied from its siblings and the repository LICENSE. (local edit; candidate to offer upstream) - The body below the header is upstream's, unchanged. + 2. `kernelAccepts`: v4.35's `addDeclCore` takes a `maxRecDepth` argument; passes the option's value. (port) + The body below the header is otherwise upstream's, unchanged. ================================================================================ -/ @@ -61,7 +62,7 @@ private def kernelAccepts (levels : List Name) (type value : Expr) : CoreM Bool let name ← mkFreshUserName `Corpus.Relation.probe let decl := Declaration.thmDecl { name, levelParams := levels, type, value } let env := (← getEnv).toKernelEnv - match env.addDeclCore 200000 decl none with + match env.addDeclCore 200000 (maxRecDepth.get (← getOptions)).toUSize decl none with | .ok _ => return true | .error (.declTypeMismatch ..) | .error (.exprTypeMismatch ..) | .error (.appTypeMismatch ..) => return false diff --git a/ZeroParadox/Vendored/NaturalOps.lean b/ZeroParadox/Vendored/NaturalOps.lean index f1eb9a7e..9ac93fea 100644 --- a/ZeroParadox/Vendored/NaturalOps.lean +++ b/ZeroParadox/Vendored/NaturalOps.lean @@ -13,7 +13,7 @@ WHY THIS FILE IS VENDORED `NatOrdinal` type synonym. It was DEPRECATED upstream (2025-08-06, PR #28063) and REMOVED from Mathlib entirely on 2026-02-20 (PR #35550, commit 08657ed7f), as part of relocating all Combinatorial Game Theory material to the external repository - `vihdzp/combinatorial-games`. Our Mathlib pin is `v4.30.0-rc2`, which is AFTER the + `vihdzp/combinatorial-games`. Our Mathlib pin is `v4.35.0`, which is AFTER the removal, so `Ordinal.nadd` / `NatOrdinal` are not available from Mathlib on our toolchain, and the external CGT repo is on an older toolchain (v4.18). Vendoring the last-good Mathlib copy and porting it forward is the cleanest way to recover the @@ -27,12 +27,11 @@ CHANGES FROM THE UPSTREAM v4.28.0 SOURCE (kept minimal, mechanical, NON-semantic * removed `@[expose] public section` (declarations are public by default here). - Removed the `deprecated_module "…"` block and its `Mathlib.Tactic.Linter.DeprecatedModule` import (we do NOT want the deprecation warning; this is an intentional revival). - - No mathematical content, definitions, statements, or proofs were altered. + - No mathematical content, definitions, or statements were altered; proof bodies were adjusted only for upstream API changes, each marked `[ZP port]`. Any further edits below this header are porting fixes for Mathlib API drift between - v4.28.0 and v4.30.0-rc2 and are marked inline with `-- [ZP port]`. + v4.28.0 and v4.35.0 and are marked inline with `-- [ZP port]`. This is library code, not Zero Paradox original work. Credit is upstream Mathlib. -See `.claude-local/notes/kirby_paris_nadd_absent_2026-06-29.md` for the full account. ================================================================================ -/ @@ -45,11 +44,6 @@ Authors: Violeta Hernández Palacios import Mathlib.SetTheory.Ordinal.Family import Mathlib.Tactic.Abel --- [ZP port] This is a v4.28.0 Mathlib snapshot built against v4.30.0-rc2; several lemmas it uses have --- since been deprecated upstream (the aliases still function). We suppress the deprecation linter rather --- than rewrite upstream proofs, to keep this file a faithful, verbatim vendored copy. -set_option linter.deprecated false - /-! # Natural operations on ordinals @@ -83,6 +77,11 @@ between both types, we attempt to prove and state most results on `Ordinal`. form. -/ +-- [ZP port] This is a v4.28.0 Mathlib snapshot built against v4.35.0; several lemmas it uses have +-- since been deprecated upstream (the aliases still function). We suppress the deprecation linter rather +-- than rewrite upstream proofs, to keep this file a faithful, verbatim vendored copy. +set_option linter.deprecated false + universe u v @@ -126,7 +125,7 @@ theorem lt_wf : @WellFounded NatOrdinal (· < ·) := Ordinal.lt_wf instance : WellFoundedLT NatOrdinal := - Ordinal.wellFoundedLT + Ordinal.lt_wf -- [ZP port] renamed (v4.35) instance : ConditionallyCompleteLinearOrderBot NatOrdinal := WellFoundedLT.conditionallyCompleteLinearOrderBot _ @@ -152,14 +151,14 @@ theorem succ_def (a : NatOrdinal) : succ a = toNatOrdinal (toOrdinal a + 1) := @[simp] protected theorem zero_le (o : NatOrdinal) : 0 ≤ o := - _root_.zero_le (α := Ordinal) o + _root_.zero_le (α := Ordinal) (a := o) -- [ZP port] arg now implicit (v4.35) theorem not_lt_zero (o : NatOrdinal) : ¬ o < 0 := _root_.not_lt_zero (α := Ordinal) @[simp] theorem lt_one_iff_zero {o : NatOrdinal} : o < 1 ↔ o = 0 := - Ordinal.lt_one_iff_zero + Order.lt_one_iff (α := Ordinal) -- [ZP port] Ordinal alias removed (v4.35) /-- A recursor for `NatOrdinal`. Use as `induction x`. -/ @[elab_as_elim, cases_eliminator, induction_eliminator] @@ -168,7 +167,7 @@ protected def rec {β : NatOrdinal → Sort*} (h : ∀ a, β (toNatOrdinal a)) : /-- `Ordinal.induction` but for `NatOrdinal`. -/ theorem induction {p : NatOrdinal → Prop} : ∀ (i) (_ : ∀ j, (∀ k, k < j → p k) → p j), p i := - Ordinal.induction + WellFoundedLT.induction (α := Ordinal) -- [ZP port] Ordinal alias removed (v4.35) instance small_Iio (a : NatOrdinal.{u}) : Small.{u} (Set.Iio a) := Ordinal.small_Iio a instance small_Iic (a : NatOrdinal.{u}) : Small.{u} (Set.Iic a) := Ordinal.small_Iic a @@ -324,7 +323,7 @@ theorem succ_nadd : succ a ♯ b = succ (a ♯ b) := by rw [← one_nadd (a ♯ theorem nadd_nat (n : ℕ) : a ♯ n = a + n := by induction n with | zero => simp - | succ n hn => rw [Nat.cast_succ, add_one_eq_succ, nadd_succ, add_succ, hn] + | succ n hn => rw [Nat.cast_succ, ← add_assoc, ← succ_eq_add_one, ← succ_eq_add_one, nadd_succ, hn] -- [ZP port] add_one_eq_succ, add_succ removed (v4.35) @[simp] theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat] @@ -332,8 +331,8 @@ theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat] theorem add_le_nadd : a + b ≤ a ♯ b := by induction b using limitRecOn with | zero => simp - | succ c h => - rwa [add_succ, nadd_succ, succ_le_succ_iff] + | add_one c h => -- [ZP port] limitRecOn case renamed (v4.35) + rwa [← add_assoc, ← succ_eq_add_one, ← succ_eq_add_one, nadd_succ, succ_le_succ_iff] | limit c hc H => rw [(isNormal_add_right a).apply_of_isSuccLimit hc, Ordinal.iSup_le_iff] rintro ⟨i, hi⟩ @@ -363,7 +362,7 @@ instance : AddLeftMono NatOrdinal.{u} := ⟨fun a _ _ h => nadd_le_nadd_left h a⟩ instance : AddLeftReflectLE NatOrdinal.{u} := - ⟨fun a b c h => by by_contra! h'; exact h.not_gt (by gcongr)⟩ + ⟨fun h => by by_contra! h'; exact h.not_gt (by gcongr)⟩ -- [ZP port] binders now implicit (v4.35) instance : AddCommMonoid NatOrdinal := { add_assoc := nadd_assoc @@ -409,24 +408,24 @@ theorem toNatOrdinal_natCast (n : ℕ) : toNatOrdinal n = n := by rfl theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c := - @lt_of_add_lt_add_left NatOrdinal _ _ _ + lt_of_add_lt_add_left (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem lt_of_nadd_lt_nadd_right : ∀ {a b c}, b ♯ a < c ♯ a → b < c := - @lt_of_add_lt_add_right NatOrdinal _ _ _ + lt_of_add_lt_add_right (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem le_of_nadd_le_nadd_left : ∀ {a b c}, a ♯ b ≤ a ♯ c → b ≤ c := - @le_of_add_le_add_left NatOrdinal _ _ _ + le_of_add_le_add_left (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem le_of_nadd_le_nadd_right : ∀ {a b c}, b ♯ a ≤ c ♯ a → b ≤ c := - @le_of_add_le_add_right NatOrdinal _ _ _ + le_of_add_le_add_right (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) @[simp] theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c := - @add_lt_add_iff_left NatOrdinal _ _ _ _ + fun a => add_lt_add_iff_left (α := NatOrdinal) a -- [ZP port] implicit args now precede instances (v4.35) @[simp] theorem nadd_lt_nadd_iff_right : ∀ (a) {b c}, b ♯ a < c ♯ a ↔ b < c := - @add_lt_add_iff_right NatOrdinal _ _ _ _ + fun a => add_lt_add_iff_right (α := NatOrdinal) a -- [ZP port] implicit args now precede instances (v4.35) @[simp] theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c := @@ -434,19 +433,19 @@ theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c : @[simp] theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c := - @_root_.add_le_add_iff_right NatOrdinal _ _ _ _ + fun a => _root_.add_le_add_iff_right (α := NatOrdinal) a -- [ZP port] implicit args now precede instances (v4.35) theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d := - @add_le_add NatOrdinal _ _ _ _ + add_le_add (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d := - @add_lt_add NatOrdinal _ _ _ _ + add_lt_add (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d := - @add_lt_add_of_lt_of_le NatOrdinal _ _ _ _ + add_lt_add_of_lt_of_le (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d := - @add_lt_add_of_le_of_lt NatOrdinal _ _ _ _ + add_lt_add_of_le_of_lt (α := NatOrdinal) -- [ZP port] implicit args now precede instances (v4.35) theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c := @_root_.add_left_cancel NatOrdinal _ _ @@ -462,12 +461,12 @@ theorem nadd_left_cancel_iff : ∀ {a b c}, a ♯ b = a ♯ c ↔ b = c := theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c := @add_right_cancel_iff NatOrdinal _ _ -theorem le_nadd_self {a b} : a ≤ b ♯ a := by simpa using nadd_le_nadd_right (zero_le _) a +theorem le_nadd_self {a b} : a ≤ b ♯ a := by simpa using nadd_le_nadd_right zero_le a -- [ZP port] theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c := le_nadd_self.trans (nadd_le_nadd_left h b) -theorem le_self_nadd {a b} : a ≤ a ♯ b := by simpa using nadd_le_nadd_left (zero_le _) a +theorem le_self_nadd {a b} : a ≤ a ♯ b := by simpa using nadd_le_nadd_left zero_le a -- [ZP port] theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c := le_self_nadd.trans (nadd_le_nadd_right h c) @@ -726,7 +725,7 @@ theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b := by refine b.limitRecOn ?_ ?_ ?_ · simp · intro c h - rw [mul_succ, nmul_succ] + rw [← succ_eq_add_one, mul_succ, nmul_succ] -- [ZP port] limitRecOn now states c + 1 (v4.35) exact (add_le_nadd _ a).trans (nadd_le_nadd_right h a) · intro c hc H rcases eq_zero_or_pos a with (rfl | ha) diff --git a/Zero_Paradox_Foreword.pdf b/Zero_Paradox_Foreword.pdf index fdd20d99..d0f8cdfb 100644 Binary files a/Zero_Paradox_Foreword.pdf and b/Zero_Paradox_Foreword.pdf differ diff --git a/fmc.md b/fmc.md index 143f1549..ee6682c6 100644 --- a/fmc.md +++ b/fmc.md @@ -12,9 +12,7 @@ FMC is a disciplined, falsifiable form of the "intrinsic justification" of axiom ## How and Why We Use It -We try to avoid project-specific vernacular. FMC names a status the framework genuinely needs. - -It is stronger than a free modeling choice (the alternatives are argued away, not merely declined). By definition it is weaker than a theorem: the ruling-out is a metatheoretic "squeeze" argument, not a derivation in the formal system. As such, it sits between a Conditional Claim and a Theorem. +We try to avoid project-specific vernacular, and coin this term anyway because FMC names a status the framework genuinely needs. It is stronger than a free modeling choice (the alternatives are argued away, not merely declined). By definition it is weaker than a theorem: the ruling-out is a metatheoretic "squeeze" argument, not a derivation in the formal system. As such, it sits between a Conditional Claim and a Theorem. Naming it honestly keeps the foundations legible: a reader sees exactly how much is established, and how. diff --git a/lake-manifest.json b/lake-manifest.json index 87d10999..cb29190e 100644 --- a/lake-manifest.json +++ b/lake-manifest.json @@ -1,21 +1,31 @@ -{"version": "1.2.0", +{"version": "1.3.0", "packagesDir": ".lake/packages", "packages": - [{"url": "https://github.com/leanprover-community/mathlib4", + [{"url": "https://github.com/AlexeyMilovanov/kolmogorov-complexity-lean", + "type": "git", + "subDir": null, + "scope": "", + "rev": "7e7111685355e3e7925c32621788e977ca53108f", + "name": "kolmogorov_complexity", + "manifestFile": "lake-manifest.json", + "inputRev": "7e7111685355e3e7925c32621788e977ca53108f", + "inherited": false, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/mathlib4", "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "5450b53e5ddc75d46418fabb605edbf36bd0beb6", + "rev": "56a005855ea17e0b0958f73ec801ae140b0a1679", "name": "mathlib", "manifestFile": "lake-manifest.json", - "inputRev": "v4.30.0-rc2", + "inputRev": "v4.35.0", "inherited": false, "configFile": "lakefile.lean"}, {"url": "https://github.com/leanprover-community/plausible", "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "86210d4ad1b08b086d0bd638637a75246523dbb8", + "rev": "dfa4f38190d07c37e315953e08b90fe2d95b3c24", "name": "plausible", "manifestFile": "lake-manifest.json", "inputRev": "main", @@ -25,7 +35,7 @@ "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", + "rev": "d6b4c7be5be75ec4917c873ac50c756dc1436372", "name": "LeanSearchClient", "manifestFile": "lake-manifest.json", "inputRev": "main", @@ -35,7 +45,7 @@ "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "cdab3938ccabbdb044be6896e251b5814bec932e", + "rev": "a41f0e9a4dea23188ea9cc1c41ac9f8bbafe0b93", "name": "importGraph", "manifestFile": "lake-manifest.json", "inputRev": "main", @@ -45,50 +55,50 @@ "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "2db6054a44326f8c0230ee0570e2ddb894816511", + "rev": "df72b022e558978a1c50264cfc4d7fec86fa8e04", "name": "proofwidgets", "manifestFile": "lake-manifest.json", - "inputRev": "v0.0.98", + "inputRev": "main", "inherited": true, "configFile": "lakefile.lean"}, {"url": "https://github.com/leanprover-community/aesop", "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "f0c6e183ea26531e82773feb4b73ab6595ca17a5", + "rev": "4a174c490d8707121c4a9290800489f105d85e07", "name": "aesop", "manifestFile": "lake-manifest.json", - "inputRev": "v4.30.0-rc2", + "inputRev": "master", "inherited": true, "configFile": "lakefile.toml"}, {"url": "https://github.com/leanprover-community/quote4", "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "1cc7e819b9b9bc1e87c9edcccb62e0269e00a809", + "rev": "dce0ad79c486cb1fb504af04f953c3466b0c6db8", "name": "Qq", "manifestFile": "lake-manifest.json", - "inputRev": "v4.30.0-rc2", + "inputRev": "master", "inherited": true, "configFile": "lakefile.toml"}, {"url": "https://github.com/leanprover-community/batteries", "type": "git", "subDir": null, "scope": "leanprover-community", - "rev": "5c57f3857ba81924a88b2cdf4f062e34ec04ff11", + "rev": "66e469188fe07963e5cf666c7d4433f45b8131c5", "name": "batteries", "manifestFile": "lake-manifest.json", - "inputRev": "v4.30.0-rc2", + "inputRev": "main", "inherited": true, "configFile": "lakefile.toml"}, {"url": "https://github.com/leanprover/lean4-cli", "type": "git", "subDir": null, "scope": "leanprover", - "rev": "13567aed1ac4f12aea9484178e07e51f8c9f7658", + "rev": "c24fe6078c630e89b489bffe59b3e20ac30d12c8", "name": "Cli", "manifestFile": "lake-manifest.json", - "inputRev": "v4.30.0-rc2", + "inputRev": "v4.35.0", "inherited": true, "configFile": "lakefile.toml"}], "name": "zero_paradox", diff --git a/lakefile.toml b/lakefile.toml index f7b96ffe..4cd81dfa 100644 --- a/lakefile.toml +++ b/lakefile.toml @@ -19,7 +19,12 @@ weak.linter.dupNamespace = false # e.g. ZeroParadox.APG.APG — harmless; r [[require]] name = "mathlib" scope = "leanprover-community" -rev = "v4.30.0-rc2" +rev = "v4.35.0" + +[[require]] +name = "kolmogorov_complexity" +git = "https://github.com/AlexeyMilovanov/kolmogorov-complexity-lean" +rev = "7e7111685355e3e7925c32621788e977ca53108f" [[lean_lib]] name = "ZeroParadox" diff --git a/lean-toolchain b/lean-toolchain index 6c7e31ff..a6aff065 100644 --- a/lean-toolchain +++ b/lean-toolchain @@ -1 +1 @@ -leanprover/lean4:v4.30.0-rc2 +leanprover/lean4:v4.35.0 diff --git a/register.md b/register.md index 6abed848..1646a4d0 100644 --- a/register.md +++ b/register.md @@ -4,31 +4,31 @@ Update this file first on any version bump. README.md Framework table is verifie | Document | Formal Version | Filename | Companion Version | Comp AR | Notes | |----------|---------------|----------|-------------------|---------|-------| -| ZP-A Lattice Algebra | v1.33 | ZP-A_Lattice_Algebra.pdf | v1.12 | N/— | formal:f6478f2b comp:aa71c65d | -| ZP-B p-Adic Topology | v1.30 | ZP-B_pAdic_Topology.pdf | v1.21 | N/— | formal:6080b209 comp:4d3ce35e | -| ZP-F The Counterexamples | v1.20 | ZP-F_The_Counterexamples.pdf | v1.19 | N/— | formal:b99fbdbb comp:dee59dce | -| ZP-C Information Theory | v1.26 | ZP-C_Information_Theory.pdf | v2.11 | N/— | formal:7ba26d82 comp:51d4a5bc | -| ZP-D State Layer | v1.19 | ZP-D_State_Layer.pdf | v1.18 | N/— | formal:339590dd comp:6be72c57 | -| ZP-E Bridge Document | v3.61 | ZP-E_Bridge_Document.pdf | v1.27 | Y/Y | formal:7e3ca909 comp:3a25f240 | -| ZP-G Category Theory | v1.23 | ZP-G_Category_Theory.pdf | v1.14 | N/— | formal:7b23b058 comp:c39d201c | -| ZP-H Categorical Bridge | v1.27 | ZP-H_Categorical_Bridge.pdf | v1.21 | N/— | formal:ac557a4e comp:b85ebaf7 | -| ZP-H Native Categories Addendum | v1.7 | ZP-H_Native_Categories_Addendum.pdf | N/A | N/— | formal:6055c8d4 | -| ZP-I Inside Zero | v1.28 | ZP-I_Inside_Zero.pdf | v1.34 | N/— | formal:37707b03 comp:8e589905 | -| ZP-J Self-Reference | v2.13 | ZP-J_Self_Reference.pdf | v1.34 | N/— | formal:265f043a comp:795e47b1 | -| ZP-J AFA Addendum | v1.19 | ZP-J_AFA_Addendum.pdf | N/A | N/— | formal:2919b9d3 | -| ZP-J Wheel Addendum | v1.8 | ZP-J_Wheel_Addendum.pdf | v1.6 | N/— | formal:1711b209 comp:feb49592 | -| ZP-J Keystone Addendum | v1.26 | ZP-J_Keystone_Addendum.pdf | N/A | N/— | formal:4f3bf1da | -| ZP-K Computational Grounding | v1.27 | ZP-K_Computational_Grounding.pdf | v1.25 | N/— | formal:c4f1633e comp:7ecb1d32 | -| ZP-L Incomputability Convergence | v1.30 | ZP-L_Incomputability_Convergence.pdf | v1.18 | N/— | formal:e9597380 comp:c273dc84 | -| ZP-M Kleene-Ordinal Bridge | v1.13 | ZP-M_Kleene_Ordinal_Bridge.pdf | v1.8 | N/— | formal:e7f71e6d comp:139f50be | -| ZP-N The Constructive Snap | v2.5 | ZP-N_The_Constructive_Snap.pdf | N/A | N/— | formal:5bb204ce | -| ZP-P The Fixed-Point Fork | v1.26 | ZP-P_The_Fixed_Point_Fork.pdf | N/A | N/— | formal:ee630188 | -| ZP-R Cross-Category Fixed Point | v1.20 | ZP-R_Cross_Category_Fixed_Point.pdf | N/A | N/— | formal:b73d52ec | -| ZP-R Diagonal Family Addendum | v1.18 | ZP-R_Diagonal_Family_Addendum.pdf | N/A | N/— | formal:386d90ea | -| ZP-Q The Frame-Change | v1.13 | ZP-Q_The_Frame_Change.pdf | N/A | N/— | formal:bcbee63b | -| Zero Paradox Foreword | v2.36 | Zero_Paradox_Foreword.pdf | N/A | N/A | formal:ce7e929a | -| ZP Tools | N/A | ZP_Tools_and_Methods.pdf | N/A | N/A | formal:e6eb108d | -| ZP Choice-Free Core Addendum | v1.13 | ZP_Choice_Free_Core_Addendum.pdf | N/A | N/A | formal:e357360d | +| ZP-A Lattice Algebra | v1.37 | ZP-A_Lattice_Algebra.pdf | v1.23 | N/— | formal:8ac90a09 comp:3d18bb87 | +| ZP-B p-Adic Topology | v1.33 | ZP-B_pAdic_Topology.pdf | v1.21 | N/— | formal:f932756c comp:4d3ce35e | +| ZP-F The Counterexamples | v1.26 | ZP-F_The_Counterexamples.pdf | v1.24 | N/— | formal:ed9832ca comp:43e4294e | +| ZP-C Information Theory | v1.39 | ZP-C_Information_Theory.pdf | v2.14 | N/— | formal:4a46b049 comp:10cbc861 | +| ZP-D State Layer | v1.21 | ZP-D_State_Layer.pdf | v1.18 | N/— | formal:af01d656 comp:6be72c57 | +| ZP-E Bridge Document | v3.80 | ZP-E_Bridge_Document.pdf | v1.41 | Y/Y | formal:6042e5ce comp:a95ace57 | +| ZP-G Category Theory | v1.27 | ZP-G_Category_Theory.pdf | v1.16 | N/— | formal:e901301e comp:668a9008 | +| ZP-H Categorical Bridge | v1.35 | ZP-H_Categorical_Bridge.pdf | v1.26 | N/— | formal:95dad22c comp:7d801305 | +| ZP-H Native Categories Addendum | v1.14 | ZP-H_Native_Categories_Addendum.pdf | N/A | N/— | formal:b961348b | +| ZP-I Inside Zero | v1.44 | ZP-I_Inside_Zero.pdf | v1.49 | N/— | formal:e7223686 comp:c5105dc3 | +| ZP-J Self-Reference | v2.19 | ZP-J_Self_Reference.pdf | v1.42 | N/— | formal:c802922a comp:ab3e7a27 | +| ZP-J AFA Addendum | v1.22 | ZP-J_AFA_Addendum.pdf | N/A | N/— | formal:5bb92504 | +| ZP-J Wheel Addendum | v1.11 | ZP-J_Wheel_Addendum.pdf | v1.15 | N/— | formal:849e279d comp:7812acd4 | +| ZP-J Keystone Addendum | v1.31 | ZP-J_Keystone_Addendum.pdf | N/A | N/— | formal:f97b62dd | +| ZP-K Computational Grounding | v1.38 | ZP-K_Computational_Grounding.pdf | v1.34 | N/— | formal:45418ad4 comp:8180bfc8 | +| ZP-L Incomputability Convergence | v1.38 | ZP-L_Incomputability_Convergence.pdf | v1.23 | N/— | formal:f9a872b7 comp:a0e059df | +| ZP-M Kleene-Ordinal Bridge | v1.20 | ZP-M_Kleene_Ordinal_Bridge.pdf | v1.14 | N/— | formal:502353c3 comp:9888babd | +| ZP-N The Constructive Snap | v2.9 | ZP-N_The_Constructive_Snap.pdf | N/A | N/— | formal:625a4d4e | +| ZP-P The Fixed-Point Fork | v1.37 | ZP-P_The_Fixed_Point_Fork.pdf | N/A | N/— | formal:794df5a8 | +| ZP-R Cross-Category Fixed Point | v1.27 | ZP-R_Cross_Category_Fixed_Point.pdf | N/A | N/— | formal:b2c9513f | +| ZP-R Diagonal Family Addendum | v1.25 | ZP-R_Diagonal_Family_Addendum.pdf | N/A | N/— | formal:126a51c7 | +| ZP-Q The Frame-Change | v1.25 | ZP-Q_The_Frame_Change.pdf | N/A | N/— | formal:355f4257 | +| Zero Paradox Foreword | v2.47 | Zero_Paradox_Foreword.pdf | N/A | N/A | formal:f4f5c8d2 | +| ZP Tools | N/A | ZP_Tools_and_Methods.pdf | N/A | N/A | formal:7d101f1d | +| ZP Choice-Free Core Addendum | v1.19 | ZP_Choice_Free_Core_Addendum.pdf | N/A | N/A | formal:825920cd | **Comp AR column key:** `Y/Y` = current comp hash adversary-reviewed + remediated (or confirmed clean). `Y/N` = reviewed, fixes identified but not yet applied. `N/—` = not yet reviewed. @@ -42,7 +42,7 @@ The `formal:XXXXXXXX comp:XXXXXXXX` tokens in the Notes column above are SHA-256 ``` python tools/verify/check_hashes.py ``` -A hash `MISMATCH` means a script was modified without a version bump and PDF rebuild. An AR status of `STALE` means the companion script changed since its last adversary review — re-review required before merge. +A hash `MISMATCH` means a script was modified without a version bump and PDF rebuild. An AR status (`STALE` included) comes from a legacy per-document tracker that gates nothing: review coverage is a verdict in the ledger, and `check_hashes.py` prints that these columns are to be ignored. **Post-fix workflow** — after applying adversary-review fixes, rebuilding the PDF, and updating the hash in register.md, run one command to close the loop: ``` diff --git a/scripts/README.md b/scripts/README.md index 7b179b84..2f3bd78a 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -23,14 +23,15 @@ If you are primarily interested in the mathematical content, the PDF documents t Unlike everything else in this folder, these three are **primary and executed** — GitHub Actions runs `corpus_verification_report.py` on every build; `minimal_core_report.py` is `workflow_dispatch` so it can be fired by hand against any branch, **and also runs automatically when `Miniature.lean`, the report script, or the workflow changes**; `axiom_ledger_report.py` is the same shape for `.github/workflows/axiom_ledger.yml`, which also fires on a `lean-toolchain` or `lake-manifest.json` change. All three publish their output to the run summary, so they -are not copies of anything and they are not PDF tooling. Each reads a Lean log plus the -build's own exit code and reports what the machine actually checked. +are not copies of anything and they are not PDF tooling. Each reads a Lean log plus the exit +code of the Lean run that wrote it (`lake build` for the corpus report, `lake env lean` on one file +for the other two) and reports what the machine actually checked. | File | Purpose | |------|---------| | [corpus_verification_report.py](corpus_verification_report.py) | Whole-corpus report: build status and the axiom footprint of every declaration recorded in the run. Exits non-zero if the build failed, anything depends on `sorryAx`, or the log carries no evidence at all | | [minimal_core_report.py](minimal_core_report.py) | The same for `ZeroParadox/Miniature.lean` alone, written for both a layman and a specialist — the "prove it yourself" gate | -| [axiom_ledger_report.py](axiom_ledger_report.py) | Per-row table for `ZeroParadox/Meta/AxiomLedger.lean`: each ledgered declaration's declared and recomputed axiom profile, the predecessor's for replacement rows, and the coverage row. Exits non-zero if Lean failed, a row printed FAIL, anything uses `sorry`, or the log carries no ledger rows or no audit result | +| [axiom_ledger_report.py](axiom_ledger_report.py) | Per-row table for `ZeroParadox/Meta/AxiomLedger.lean`: each ledgered declaration's declared and recomputed axiom profile, the predecessor's for replacement rows, and the coverage row. Exits non-zero if Lean failed, a row printed FAIL, the log carries Lean's "declaration uses `sorry`" warning, or the log carries no ledger rows or no audit result | ### Shared utilities diff --git a/scripts/axiom_ledger_report.py b/scripts/axiom_ledger_report.py index 3318b905..c04c9a29 100644 --- a/scripts/axiom_ledger_report.py +++ b/scripts/axiom_ledger_report.py @@ -86,8 +86,9 @@ if ok: out.append( "Lean recomputed the axioms each ledgered declaration reaches and compared them with what " - "the ledger declares. Every row matched, every replacement has its predecessor's exact " - "statement and a strictly smaller axiom set, and every theorem in scope has a row.") + "the ledger declares. Every row matched, every replacement's statement type is definitionally " + "equal to its predecessor's (kernel-checked) with a strictly smaller axiom set, and every " + "non-auxiliary theorem in scope has a row.") elif lean_rc == 0 and no_evidence and not has_sorry: out.append( "**Nothing was verified here.** Lean reported no failure, and the log carries no ledger " diff --git a/scripts/build_bottom_matrix.py b/scripts/build_bottom_matrix.py index a8dc59e5..4f5363ee 100644 --- a/scripts/build_bottom_matrix.py +++ b/scripts/build_bottom_matrix.py @@ -134,17 +134,16 @@ def dyn_glyph(v): "MEAS": "na: the empty type carries no distribution at all, so no scalar exists to diverge. ⚠ `IsEmpty (PMF (Fin 0))` elaborates, so the stronger mark - a proved obstruction (✗) rather than a category error - is AVAILABLE and unbuilt as of 2026-08-29. Upgrading it costs one theorem; the mark stays ∅ until that theorem exists, because a cell may not cite a witness the corpus does not contain", "INV": "IsInitial.op (Mathlib)", "CONC": "na: DEGENERATE on an empty carrier - there are no points, so every endomorphism fixes every " - "point vacuously and CONC carries no content here. ⚠ This cell previously cited " - "`kleisli_bottom_not_zero` as a refutation; that theorem proves the Kleisli bottom is " - "not a ZERO OBJECT (not terminal), which is a mu/nu DIRECTION fact and belongs to DYN. " - "It addresses neither of CONC's two propositions", + "point vacuously and CONC carries no content here. ⚠ kleisli_bottom_not_zero is not a " + "refutation of CONC: it proves the Kleisli bottom is not a ZERO OBJECT (not terminal), " + "which is a mu/nu DIRECTION fact and belongs to DYN, and it addresses neither of CONC's " + "two propositions", "SELF": "na: DEGENERATE, and that is the finding. `Fin 0` is EMPTY, so the Kleisli endomorphism " "`Fin 0 -> PMF (Fin 0)` is the unique empty map and every diagonal/self-application " "statement about it holds VACUOUSLY, carrying no content about this bottom. " - "⚠ Not that no self-map exists - the same correction the TopCat cells took " - "2026-08-29. No ZP witness is cited because none is owed for a degeneracy", + "⚠ Not that no self-map exists; the TopCat cells say the same. No ZP witness is cited because none is owed for a degeneracy", "GEN": "node4_generates_nat", - "DYN": "out fC_no_return (initial source; nothing returns to ⊥ - μ)", + "DYN": "out fC_no_return (initial source; no later stage n > 0 returns to KleisliCat PMF's floor Fin 0 - μ)", }, "#5 Hilbert (zero obj/seam)": { "CANT": "seam_not_mu_colimit_apex", @@ -194,6 +193,13 @@ def dyn_glyph(v): "CONC": "unique_fp", "SELF": "derived_bot_self_mem", "GEN": "na: self-coincident (μ=ν seam, ⊥ = the least fixed point) - carries SELF/CONC, not GEN", "DYN": "out* t_snap_derived (inherited; the static seam-point does not itself move)", + # NOTE is not a slot: build_dictionary_map.py prints it as a closing line under the cell's + # slots, and nothing that iterates SLOTS reads it. + "NOTE": "Control: every ZPSemilattice carries an AbstractSelfApp, trivialSelfApp, whose map is " + "the constant map to ⊥ of that ZPSemilattice; there ⊥ still occupies the Quine-atom role " + "(the CONTROL example after selfApp_quine_role_iff in " + "ZeroParadox/Settheory/QuineDichotomy.lean), so that occupancy comes from the class " + "fields, whatever the map is", }, } diff --git a/scripts/build_dictionary_map.py b/scripts/build_dictionary_map.py index d73aa214..fed09981 100644 --- a/scripts/build_dictionary_map.py +++ b/scripts/build_dictionary_map.py @@ -566,6 +566,10 @@ def link_in_text(text): """Auto-link any decl-shaped token that resolves against the Lean source; leave prose untouched.""" def repl(m): name = m.group(0) + # A claim code (`CC-2`, `DA-1`, `AX-1`) is a label, never a declaration: its letter prefix + # resolved externally and rendered as "`CC`-2". + if re.match(r"-\d", m.string[m.end():m.end() + 2]): + return name if _decl_shaped(name) and _entry(name) is not None: return link_witness(name) # a MENTION in prose - no kind note; see annotate_witness return name @@ -651,6 +655,8 @@ def render_cell_details(): txt = annotate_witness(txt) body = f" - {link_in_text(txt)}" if txt else "" out.append(f"- `{k}` {g}{body}") + if d.get("NOTE"): + out.append(f"- {link_in_text(d['NOTE'])}") out.append("") out.append("") return "\n".join(out) @@ -671,13 +677,13 @@ def render_rosetta(): One self-referential structure - a thing that is its own fixed point - keeps turning up in fields that do not expect to meet. Here is each coincidence, ordered by how sure we are of it. Everything provable is checkable: clone the repo and run `#print axioms `. -**Proved - the same element (three names); and one commitment - the same role (the fourth).** In any ZP lattice carrying an AFA structure, the *Quine atom* (a set that is its own only member, set theory / AFA), the *order-bottom* ⊥ of that lattice, and the *algebraic join-identity* are proved to be the **same element** - the three-name core, **axiom-free** (t_exec_triple_iff). The fourth, the *Kleene fixed point* (a program equal to its own transform up to evaluation, computability), names no element of the lattice; it fills the same **role** by an explicit structural commitment: the KleeneStructure typeclass nominates its field botCode as the computational witness of the lattice's bottom role - the motivating commitment, not a derived theorem. No equation between the code and the set is well-formed: botCode is a Code and ⊥ is an element of the lattice, so neither side can be stated equal or unequal to the other. The computational witness rests on Mathlib's recursion theorem, which carries `Classical.choice`; the three-name core needs none. +**Proved - the same element (three names); and the fourth compared through a role.** In any ZP lattice carrying an AFA structure, the *Quine atom* (a set that is its own only member, set theory / AFA), the *order-bottom* ⊥ of that lattice, and the *algebraic join-identity* are proved to be the **same element** - the three-name core, **axiom-free** (t_exec_triple_iff). The fourth, the *Kleene fixed point* (a program equal to its own transform up to evaluation, computability), names no element of the lattice, and no code is equated with ⊥. The KleeneStructure typeclass was motivated by reading its field botCode as the computational witness of the lattice's bottom role; that reading's identity half is retired. The fourth is compared with the three through the die's Quine-atom **role** (Motion.SelfOnlyAt): under the eval step no single code occupies it (evalStepMotion_not_selfOnlyAt), and for a computable map respecting equal output a class of codes up to equal output does (codes_vs_classes). What stays a commitment is the running half: that ⊥ actually executes is the occurrence commitment. No equation between the code and the set is well-formed: botCode is a Code and ⊥ is an element of the lattice, so neither side can be stated equal or unequal to the other. The code side rests on Mathlib's recursion theorem, which carries `Classical.choice`; the three-name core needs none. -**Proved - each field's own floor.** 0 in the 2-adics, where v₂(0) = ∞ (padic_addVal_bot); unbounded surprisal, the state with no finite description (t2_diverges); the categorical bottom of each real Mathlib category, an inverse limit or initial object (fD_zero_isInitial, fC_zero_isInitial and fB_bottom_is_limit, collected in mc1_correspondence); and the case where the coincidence *fails*, ℝ vs ℚ₂ by Ostrowski (completions_exhaustive, real_not_equiv_padic). They share a SHAPE (`Statement:` COINCIDENCE, per field's own witness above) - one object carrying both extremal characterisations at once - and a shared shape across distinct structures is a type boundary, never a common theorem. (The order-theoretic form of that shape is fork_collapse_iff, choice-free, but none of these satisfies its hypotheses of a complete lattice and a monotone map, so none is an instance of it.) ε₀ is co-witnessed with the 2-adic limit and the machine snap (zpm_triangle). +**Proved - each field's own floor.** 0 in the 2-adics, where v₂(0) = ∞ (padic_addVal_bot); unbounded surprisal, the state with no finite description (t2_diverges); a categorical characterization in each real Mathlib category, differing by category, the three full positions stated together in floor_positions_full (a zero object; initial and not terminal; terminal and not initial), with every half cited per category: a zero object, initial and terminal, in ModuleCat ℂ (fD_zero_isInitial, hilbert_bottom_isZero); initial and not terminal in KleisliCat PMF (fC_zero_isInitial, kleisli_bottom_not_terminal); in TopCat terminal, since it has one point (padic_bottom_isTerminal), not initial (padic_bottom_not_initial), and separately the limit of the ball tower (floorConeIsLimit); mc1_correspondence collects the two initial-object witnesses with the no-return fact fC_no_return and the set equation fB_bottom_is_limit; and the case where the coincidence *fails*, ℝ vs ℚ₂ by Ostrowski (completions_exhaustive, real_not_equiv_padic). They share a SHAPE (`Statement:` COINCIDENCE, per field's own witness above) - one object carrying both extremal characterisations at once - and a shared shape across distinct structures is a type boundary, never a common theorem. (The order-theoretic form of that shape is fork_collapse_iff, choice-free, but none of these satisfies its hypotheses of a complete lattice and a monotone map, so none is an instance of it.) ε₀ is co-witnessed with the 2-adic limit and the machine snap (zpm_triangle). -**Mostly proved - a narrow residue argued.** The framework's set-theoretic *commitment* is not *AFA specifically* but a fragment it assumes of its host theory: a unique Quine atom ⊥ = {⊥}, ⊥'s only member being ⊥ and no other set its own only member. That is AFA's profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). The fragment is a checkable object, the QuineAtomHost typeclass. Foundation-freeness is *forced* by ⊥ ∈ ⊥ (quineAtomHost_not_wellFounded, axiom-free - a self-loop cannot live in a well-founded world); ordinary set theory (Foundation) is excluded in-kernel about the real theory (zfSet_no_singleton_bottom - no set is its own sole member under Foundation); Boffa's BA₁ is set aside because its reflexive sets form a proper class rather than one (Aczel 1988, Prop. 5.1, p. 57), a gap a toy model makes concrete (boffa_fails_reflexive_unique) rather than an in-kernel fact about Boffa's axiom; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older QuineHost typeclass asks for ⊥ ∈ ⊥ with no other self-membered element, which AFA's membership fails (0* = {∅, 0*} is self-membered, Aczel 1988, Example 1.5, p. 7); the two classes are incomparable. What remains argued is only that a Quine atom and its uniqueness are the right two requirements - a Forced Metatheoretic Commitment with a named falsifier, stronger than a free choice and weaker than a theorem. The set-membership face ⊥ ∈ ⊥ stays metatheoretic; the structural fixed point is machine-checked and axiom-free (t_exec). +**Mostly proved - a narrow residue argued.** The framework's set-theoretic *commitment* (CC-2) is adopting AFA; what the Lean abstracts of it is a fragment it assumes of its host theory: a unique Quine atom, a bottom b = {b} whose only member is itself, and no other set its own only member. That is AFA's profile: AFA allows at most one solution of x = {x} (Aczel 1988, p. 19). The fragment is a checkable object, the QuineAtomHost typeclass. Foundation-freeness is *forced* by the host bottom's self-membership, b ∈ b (quineAtomHost_not_wellFounded, axiom-free - a self-loop cannot live in a well-founded world); ordinary set theory (Foundation) is excluded in-kernel about the real theory (zfSet_no_singleton_bottom - no set is its own sole member under Foundation); Boffa's BA₁ is set aside because its reflexive sets form a proper class rather than one (Aczel 1988, Prop. 5.1, p. 57), a gap a toy model makes concrete (boffa_fails_reflexive_unique) rather than an in-kernel fact about Boffa's axiom; and AFA's pattern meets both requirements in a finite toy with real membership, a model of the pattern and not of AFA. The older QuineHost typeclass asks for a self-membered bottom with no other self-membered element, which AFA's membership fails (0* = {∅, 0*} is self-membered, Aczel 1988, Example 1.5, p. 7); the two classes are incomparable. That a Quine atom and its uniqueness are the right two requirements is argued - a Forced Metatheoretic Commitment with a named falsifier ([CLAIMS.md](CLAIMS.md) Tier 4, the row "Host-theory requirements (R-AFA, ZP-E)"), stronger than a free choice and weaker than a theorem. In the die the Quine atom is a role, a point that steps to itself and to nothing else (Motion.SelfOnlyAt), whose occupancy is settled chart by chart: in a QuineAtomHost with membership as the step, the host's own bottom is its only occupant (quineAtomHost_quine_role_iff), so ⊥ of a ZPSemilattice occupies it exactly when the host's bottom is ⊥ (the examples after quineAtomHost_quine_role_iff in ZeroParadox/Settheory/QuineDichotomy.lean); in a ZPSemilattice with the AbstractSelfApp map as the step, ⊥ is its only occupant (selfApp_quine_role_iff); and no ZFSet occupies it (zfset_quine_role_unoccupied). Every inhabited type carries a QuineAtomHost (trivialQuineAtomHost) and every ZPSemilattice an AbstractSelfApp (trivialSelfApp), so an occupancy says something only with the step named. No equation across charts is stated: ⊥ of a ZPSemilattice is not asserted to be a set. The structural fixed point is machine-checked and axiom-free (t_exec). -**The family - MC-1.** MC-1 names not one object but one **family**. Each of these floors is a member: it satisfies the shared criteria mapped in the slots below, with per-domain membership machine-verified where marked (the categorical criterion is carried by the per-domain witnesses fD_zero_isInitial, fC_zero_isInitial and fB_bottom_is_limit, collected in mc1_correspondence). The *choice* of criteria is a design principle; that they characterize the family is an argument. The cross-category numerical identity - that the bottoms are *one and the same object* - is **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, for the named bottoms, in a lattice with no top). What survives is the proved leaves and the proved walls; the only oneness is the shared self-referential *shape* - the diagonal fixed point - which lives in the apophatic register, never as a formal identity. Within-frame identities stand: the three-name core above (t_exec_triple_iff, axiom-free), and in ℚ₂ the equality v₂(0) = ∞ (padic_addVal_bot) - an equality of *values* in the value monoid, not of points of ℚ₂. The 2-adic **pole** is a claim of a different kind: 0 and ∞ are provably distinct points of the sphere which inversion *exchanges* (`Statement:` INVERSION, point_and_field_at_the_poles), so calling the two one pole is a chart claim rather than an identity of points.""" +**The family - MC-1.** MC-1 names not one object but one **family**. Each of these floors is a member: it satisfies the shared criteria mapped in the slots below, with per-domain membership machine-verified where marked (the categorical criterion differs by category: a zero object, initial and terminal, in ModuleCat ℂ; initial and not terminal in KleisliCat PMF; in TopCat terminal, since it has one point, and not initial, and 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), and the TopCat limit is floorConeIsLimit; mc1_correspondence collects the initial-object witnesses fD_zero_isInitial and fC_zero_isInitial with the no-return fact fC_no_return and the set equation fB_bottom_is_limit). The *choice* of criteria is a design principle; that they characterize the family is an argument. The cross-category numerical identity - that the bottoms are *one and the same object* - is **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, for the named bottoms, in a lattice with no top). What survives is the proved leaves and the proved walls; the only oneness is the shared self-referential *shape* - the diagonal fixed point - which lives in the apophatic register, never as a formal identity. Within-frame identities stand: the three-name core above (t_exec_triple_iff, axiom-free), and in ℚ₂ the equality v₂(0) = ∞ (padic_addVal_bot) - an equality of *values* in the value monoid, not of points of ℚ₂. The 2-adic **pole** is a claim of a different kind: 0 and ∞ are provably distinct points of the sphere which inversion *exchanges* (`Statement:` INVERSION, point_and_field_at_the_poles), so calling the two one pole is a chart claim rather than an identity of points.""" return link_in_text(body) # --- The diagonal family: the self-reference arguments as one fixed point (ZP-R) --- @@ -691,9 +697,9 @@ def render_rosetta(): ("Tarski", "μ wall", "no internal truth predicate - the liar sentence has no witness", "tarski_no_internal_truth", "(none)"), ("Curry", "μ wall", "no naming surjection - Curry's paradox forces any conclusion", "curry_no_bottom", "(none)"), ("the wall", "μ", "no well-founded relation admits a self-loop (a host verdict, not an engine face)", "wf_no_selfloop", "(none)"), - ("Quine atom", "ν floor", "⊥ = {⊥}: ⊥ of a ZPSemilattice in the Quine-atom role, from the class fields", "t_exec", "(none)"), + ("Quine atom", "ν floor", "the Quine atom (CC-2): every Quine atom (IsQuineAtom) of a ZPSemilattice with an AFAStructure is ⊥, from the class fields; no set is equated with ⊥", "t_exec", "(none)"), ("Löb", "ν floor", "given a Löb diagonal ψ (hypotheses hfix1, hfix2), ⊢ □A → A yields ⊢ A", "loeb", "(none)"), - ("Gödel 2nd", "ν floor", "given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum", "godel_two", "(none)"), + ("Gödel 2nd", "ν floor", "given a Löb diagonal for falsum, a consistent system does not prove □falsum → falsum (Gödel's second theorem when the class is instantiated at a theory of arithmetic and falsum is its falsum; in the class, falsum may be any sentence)", "godel_two", "(none)"), ("Kleene quine", "ν floor", "every computable self-map on codes has a fixed point up to eval (Rogers' form of the recursion theorem)", "computability_face_fixedPoint", "`[propext, Classical.choice, Quot.sound]`"), ("Rice", "ν floor", "a fixed point up to eval exists; every non-trivial semantic property is undecidable over all codes", "rice_face_has_bottom, quine_exists_yet_rice","`[propext, Classical.choice, Quot.sound]`"), ] diff --git a/scripts/build_foreword.py b/scripts/build_foreword.py index 72946eb5..666969e2 100644 --- a/scripts/build_foreword.py +++ b/scripts/build_foreword.py @@ -1,5 +1,5 @@ """ -Zero Paradox — Foreword PDF Builder (v2.36, revised October 2026) +Zero Paradox — Foreword PDF Builder (v2.47, revised November 2026) Follows all rules in pdf rendering standards.md: - All table cells are Paragraph objects - No unicode subscripts — use sub/super tags @@ -9,7 +9,7 @@ import os from zp_utils import * -VERSION = '2.36' +VERSION = '2.47' FIRST_RELEASED = 'April 2026' # ── fix() and prose_check() guard on every Paragraph ── @@ -83,7 +83,9 @@ def commitments_table(): 'not a continuum of partial existence. This is the framework’s one substantive modeling ' 'commitment: the decide proof (ax_b1_distinct) verifies the two states are distinct given the ' 'two-element type, but the choice of a discrete alphabet over a continuum is the commitment ' - 'itself, not what decide checks (the snap provably fails in the reals, f_snap_impossible).'), + 'itself, not what decide checks (in the reals 0 has no first step above it, AX-B1’s form: ' + 'f_snap_impossible, which, despite its name, states that no linearly ordered field has a least ' + 'positive element).'), ('AX-G1', 'Axiom', 'Initial Object Exists, and No Terminal Object. There is a starting point that reaches every object in exactly one way, ' 'and no end point that every object reaches in exactly one way. ' @@ -111,7 +113,11 @@ def commitments_table(): ('AX-1', 'Retired: shape → Theorem T-SNAP; the snap occurs given the occurrence commitment and DA-1', 'Binary Snap Causality. Previously an axiom, now retired. Its content was split in two: the shape of the Snap ' 'is proved, as Theorem T-SNAP (from L-RUN, TQ-IH and the bottom law, with no Lean axioms), and that the Snap occurs ' - 'is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). ' + 'is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). ' + 'The occurrence commitment is stated in two charts, execution and slot, in the header of ' + 'ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), ' + 'the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape ' + '(ZeroParadox/Information/CrossingTrials.lean § VIII). ' '(tsnap_holds_but_nothing_moves shows T-SNAP does not carry occurrence.)'), ('MC-1', 'The bottom family (not a commitment)', 'The four domain bottoms (ZP-A semilattice, ZP-B p-adic topology, ZP-C information theory, ' @@ -128,9 +134,16 @@ def commitments_table(): 'lattice a sequence starts at a Quine atom exactly when it starts at ⊥ (cc1_derived, t_exec_iff; ' 'axiom-free, Lean), so the choice of starting point is expressed through the Quine-atom role, not removed.'), ('CC-2', 'Forced Metatheoretic Commitment', - '⊥ = {⊥}. The bottom element is self-containing, read under ZF+AFA as a Quine atom. ' - 'Foundation cannot host it: ⊥ = {⊥} is a member of itself, which Foundation (the Axiom of ' - 'Regularity) forbids (no_quine_atom). That half is forced, and it runs one way: a host whose ' + 'The Quine atom, a role: a point that steps to itself and to nothing else (the die, ' + 'ZeroParadox/Die.lean; Aczel 1988, Example 1.3, pictures Ω = {Ω} as one node with a loop), whose occupancy each chart settles by its own theorem, with no equation ' + 'across charts. ⊥ of the state semilattice occupies it under a self-application map that fixes ⊥ ' + 'and nothing else (selfApp_quine_role_iff); in a membership host whose distinguished ' + 'element is its own only member and the only element so placed, the profile AFA gives, that ' + 'element occupies it (quineAtomHost_quine_role_iff). ' + 'In Lean’s model of sets with Foundation, where the role reads ' + 'x = {x}, no set occupies it, since such a set would be a member of itself, which Foundation (the ' + 'Axiom of Regularity) forbids (zfset_quine_role_unoccupied, from no_quine_atom). That half is ' + 'forced, and it runs one way: a host whose ' 'bottom is its own only member is not well-founded (quineAtomHost_not_wellFounded). Run backwards it selects no ' 'theory: which anti-foundation axiom to adopt is a further choice, and the framework adopts AFA as ' 'the canonical host (ZP-E Remark R-AFA). What remains a commitment is that a unique Quine atom is the ' @@ -218,7 +231,9 @@ def build(): story.append(box( 'The central claim is this: zero is not the absence of mathematical structure. It is ' 'the unique minimal element of the induced partial order — the element below which ' - 'no other state exists.' + 'no other state exists. The central theorem built on it is the Binary Snap, T-SNAP, ' + 'proved with no Lean axioms (t_snap_derived, Section V); alongside it, the layers share one ' + 'role, each layer supplying its own occupant (Section IV).' )) story.append(sp(6)) @@ -252,8 +267,8 @@ def build(): 'From the single axiom that the foundational distinction is binary, together with ' 'a minimality principle, it derives that the appropriate field is Q₂, the ' '2-adic numbers. The field Q₂ forces every ball to be clopen, which forces ' - 'total disconnectedness, which makes the transition from zero to the first state ' - 'topologically irreversible. This is proven, not assumed.', + 'total disconnectedness, which makes a return from any nonzero point to zero ' + 'impossible along a continuous path (c3_irreversible, a case of Mathlib’s TotallyDisconnectedSpace.eq_of_continuous: in Q₂ no continuous path joins any two distinct points, so the step out from 0 is blocked as well). This is proven, not assumed.', S['body']), Paragraph( 'The information-theoretic layer (ZP-C) works within algorithmic information ' @@ -296,9 +311,10 @@ def build(): Paragraph( 'The closure layer (ZP-I) proves T-IZ — the Inside Zero theorem: every ' 'maximal ascending chain in the state space converges, at its limit, to zero. ' - 'Reading that limit as something filling the bottom role again is a commitment ' - 'rather than a consequence; what is proved is the other half, that anything ' - 'filling that role IS the bottom already there. ' + 'Reading that limit as something filling the bottom role again takes a choice of ' + 'join on Q₂, and then the role half is a theorem (t_iz_limit_is_new_null): anything ' + 'filling that role IS the bottom already there (that semilattice’s ⊥; which point ' + 'fills the role depends on the join chosen). ' 'Read as a closed cycle, the Snap produces states, states accumulate, and the ' 'accumulation returns to the bottom. Whether the bottom it returns to is a NEW one, ' 'rather than the one it began at, is a modelling commitment (C-DA2) and not part of ' @@ -306,11 +322,14 @@ def build(): S['body']), Paragraph( 'The counterexample layer (ZP-F) establishes the negative boundary: ' - 'the Binary Snap cannot occur in any densely ordered field — ' - 'structures where zero is a limit point of the nonzero elements. ' - 'ℝ and ℚ are canonical instances. The proof is self-contained — ' - 'no dependencies on the other layers — and answers the question of why Q₂ ' - 'is structurally necessary by showing precisely where snap-geometry fails.', + 'in an ordered field, ℝ and ℚ among them, 0 has no first step above it, AX-B1’s form ' + '(f_snap_impossible, which, despite its name, states that no linearly ordered field has a ' + 'least positive element). T-SNAP’s shape does not need a first step: t_snap_given ' + 'holds at a step taken in a densely ordered join-semilattice (ℚ≥0 under max, whose ⊥ is 0; ZeroParadox/Order/Snap.lean). ZP-F’s proof is self-contained — ' + 'no dependencies on the other layers. Q₂ does not restore the step: it is totally ' + 'disconnected (padic_snaps, an instance Mathlib already supplies), which removes the topological obstruction to an irreversible step (c3_irreversible: no continuous path in Q₂ from a nonzero point to 0) and supplies no first ' + 'step, since under the norm preorder its 0 is least and has no first step ' + '(ZeroParadox/BottomCannotBe.lean § ROLE).', S['body']), Paragraph( 'The self-reference layer (ZP-J) proves T-EXEC: in any ZP-A lattice carrying the ' @@ -361,10 +380,11 @@ def build(): '(Zermelo–Fraenkel set theory with Aczel\'s Anti-Foundation Axiom), ' 'not standard ZFC. AFA permits self-containing sets — in particular, sets x ' 'satisfying x = {x}. This matters only for CC-2 in the table below; ' - 'every other result in this framework holds in standard ZF. Standard ZFC (with ' - 'Foundation) is incompatible with CC-2: ⊥ = {⊥} is a member of itself, which the Axiom of ' - 'Regularity forbids (no set is self-membered, no_quine_atom), so a Foundation universe ' - 'cannot host it. The Axiom of Choice is not assumed ' + 'every other result in this framework holds in standard ZF. Lean’s model of sets ' + 'with Foundation cannot host CC-2’s set chart: there the Quine-atom role reads x = {x}, such ' + 'a set would be a member of itself, which the Axiom of Regularity forbids (no set is ' + 'self-membered, no_quine_atom), so no set occupies the role (zfset_quine_role_unoccupied). ' + 'The Axiom of Choice is not assumed ' 'as a framework commitment, and the core does not use it: T-SNAP (t_snap_derived) ' 'depends on no Lean axioms at all (#print axioms is empty). Classical.choice does reach the realization ' 'layers, and not only by inheritance from Mathlib — the category-theory layer spends a ' @@ -414,8 +434,11 @@ def build(): Paragraph( 'There is a deeper unity here than shared position. In each layer ⊥ plays the same ' 'role, beyond being the starting element: the role of the element that refers to ' - 'itself, with its occupant supplied per layer. In set theory it is the Quine atom, the set whose only member is itself ' - '(⊥ = {⊥}). In computation the role is filled by a code from the Rogers / Kleene ' + 'itself, with its occupant supplied per layer. In set theory under AFA it is the Quine atom, the ' + 'role a set x = {x} plays, a set whose only member is itself (in the die, a point that steps to ' + 'itself and to nothing else, Section VII); in Lean’s model of sets with Foundation, a setting that cannot host CC-2’s set chart ' + '(Section III) and not one of the framework’s layers, the role has no occupant ' + '(zfset_quine_role_unoccupied, Section VII). In computation the role is filled by a code from the Rogers / Kleene ' 'fixed-point theorem: for every computable transform f of codes there is a code c with ' 'eval (f c) = eval c (Rogers\' form, computability_face_fixedPoint, ' 'ZeroParadox/Category/Lawvere.lean). Such a code is a term of another type than ⊥ of the ' @@ -477,14 +500,31 @@ def build(): Paragraph( 'The framework lives at that boundary intentionally. ' 'Each layer arrives at the same boundary ' - 'from its own direction. That convergence is the framework\'s central result.', + 'from its own direction. That convergence is the framework\'s central result. ' + 'Alongside that convergence, the layers share one role, each layer supplying its own ' + 'occupant (Section IV), and that sharing is not one theorem. The framework\'s central theorem is the ' + 'Binary Snap, T-SNAP: in the two-state carrier MachinePhase, the step from its bottom ' + 'element c₀ to c₁ is a valid join step to a different state, proved with no Lean axioms ' + 'at all (t_snap_derived, ZeroParadox/Order/Snap.lean; the general form, which takes the ' + 'start at ⊥ and the occurrence, a first transition to a different state (S 1 ≠ S 0), as hypotheses, is t_snap_given). ' + 'Density rules out a first step, AX-B1’s form: an order is dense exactly when no element has ' + 'one (axb1_fails_everywhere_iff_dense, ZeroParadox/Reals/OrderedField.lean, the corpus restatement of ' + 'Mathlib’s denselyOrdered_iff_forall_not_covBy). In MachinePhase, c₁ is a first step ' + 'above c₀ (t_snap_derived_cover, ZeroParadox/Order/Snap.lean); in an ordered field, ℝ and ℚ among ' + 'them, no first step above 0 exists (f_snap_impossible, which, despite its name, states that no ' + 'linearly ordered field has a least positive element); one element without a first step does not ' + 'make an order dense. ' + 'T-SNAP’s shape does not need it: t_snap_given holds at a step taken in a densely ordered ' + 'join-semilattice too. That ' + 'the step occurs is the occurrence commitment (with DA-1, Section III), not something ' + 'the theorem proves (t_snap_given takes it as a hypothesis).', S['body']), ] story.append(box( - 'Zero, the bottom element ⊥ of the state semilattice, remains indescribable by smooth calculus. It becomes fully ' - 'characterised by discrete calculus. The paradox is the precise boundary between ' - 'these two regimes.' + 'In a densely ordered field such as ℝ, the field’s 0 has no first step above it ' + '(f_snap_impossible). In the two-state carrier MachinePhase it does: ' + 'c₁ is a first step above c₀ (t_snap_derived_cover).' )) story.append(sp(6)) @@ -515,14 +555,81 @@ def build(): 'AX-B1 — binary existence — is the framework’s one substantive modeling commitment: ' 'that existence is discrete rather than a continuum of partial states. The decide proof ' '(ax_b1_distinct) checks only that the two states are distinct given the two-element type; ' - 'the discreteness choice itself is the commitment, and the snap provably fails on a ' - 'continuum (f_snap_impossible). The theorems stand on their own axioms regardless.', + 'the discreteness choice itself is the commitment, and in an ordered field, ℝ among them, 0 ' + 'has no first step above it (f_snap_impossible: no linearly ordered field has a least positive ' + 'element), while T-SNAP’s shape does not need one (t_snap_given). The theorems stand on their own axioms regardless.', S['body']), ] - # ── VII. A NOTE ON READING THE DOCUMENTS ────────────────────────────────── + # ── VII. HOW THE ROLE READING GREW (retrospective; Tim's ruled exception, 2026-11-01) ── story += [ - Paragraph('VII. A NOTE ON READING THE DOCUMENTS', S['h1']), + Paragraph('VII. HOW THE ROLE READING GREW', S['h1']), + Paragraph( + 'The first paragraph of this Foreword says that the word zero does not name a single ' + 'object, and that it names a role filled differently depending on the framework. That ' + 'sentence has been in the Foreword since 19 April 2026, three days after the Foreword was ' + 'first committed, and it has been in the Foreword of every release since the first, in May ' + '2026. It is the earliest place we have found in this repository where zero itself is called ' + 'a role, and at the time it was a plain-language observation. Two days later, on 21 April ' + '2026, the Lean for ZP-E already characterised the ⊥ role inside one semilattice: ⊥ is the ' + 'one element whose join with any element returns that other element unchanged ' + '(da2_bottom_characterization, now in ZeroParadox/Order/Snap.lean).', + S['body']), + Paragraph( + 'The formal corpus took up the general form of the reading later, in three steps; the third, ' + 'chart by chart, ran from October to 1 November 2026. In October 2026 the framework ' + 'stated the general form in Lean: a bottom is a position in an ordered ' + 'structure, a structure has at most one occupant of it and may have none, and one carrier ' + 'with two different orders can have two different occupants (ZeroParadox/BottomCannotBe.lean, ' + 'its ROLE section; for epsilon-zero, ε₀, ZeroParadox/Ordinal/Epsilon0CannotBe.lean, ' + 'sections I-b and I-c). Later that month the die (ZeroParadox/Die.lean), a small common ' + 'language of points and the steps between them, gave these roles one shared vocabulary. ' + 'In it the self-referential role of Section IV is a point that steps to itself and to ' + 'nothing else (in Markov-chain language, an absorbing state), and each setting, called a ' + 'chart, answers by its own theorem whether some point fills that role. Some charts had such ' + 'theorems in October; on 1 November 2026 the set-theoretic, lattice and coalgebra ' + 'charts named next gained theirs. In Lean’s model of sets, where a set steps to its members and ' + 'Foundation holds, no set occupies the role (zfset_quine_role_unoccupied, ' + 'ZeroParadox/Settheory/Wall.lean). In the final coalgebra of the identity functor, a ' + 'one-element set (Rutten 2000, Example 10.2(1)), a point does (cofix_quine_role_occupied, ' + 'ZeroParadox/Settheory/Coalgebra.lean); since the set has only one element, there the ' + 'theorem restates the carrier rather than separating anything. On a join-semilattice whose ' + 'self-application map is assumed to fix its least element ⊥ and nothing else, exactly one ' + 'point occupies the role (selfApp_seam_role_unique, ZeroParadox/Order/SeamSchema.lean), and ' + 'that point is ⊥ because the map fixes ⊥. For a coalgebra of a polynomial functor, under its ' + 'next-time operator exactly one subset of the carrier occupies the role exactly when the ' + 'coalgebra is well-founded (seam_role_unique_iff_wellFounded, ' + 'ZeroParadox/Category/RootCutDegeneracy.lean); that is how Adámek, Milius and Moss (2020, ' + 'arXiv:1910.09401v2, Definition 4.3, after Taylor) define a well-founded coalgebra, so in that chart the theorem ' + 'restates the definition.', + S['body']), + Paragraph( + 'The project’s releases record the earlier stages of the same reading. A release of ' + '10 June 2026 described ⊥ as the same self-referential fixed point in every layer, presented ' + 'as an identification; the next release, that same week, kept the literal cross-category identity as ' + 'a chosen commitment; a release in July 2026 fenced the cross-domain identity as a type ' + 'boundary (in ZP-Q). Each of ' + 'those statements had to be written and kept consistent by hand. Stated as a role, there is no ' + 'equation across charts left to fence: an equation between objects of different types does ' + 'not typecheck, and each chart named above answers by a theorem that Lean checks; the ' + 'computational face stays a commitment (Section IV). Each published release is a ' + 'Zenodo snapshot with a permanent DOI, so every stage stays readable as it was published, and ' + 'each correction reaches readers in a later release while the earlier statement stays on the ' + 'record. That self-correction is part of what the releases record.', + S['body']), + Paragraph( + 'The role reading retires identity claims across charts, and only those. It does not retire ' + 'the framework’s commitments about the world. AX-B1, that existence is discrete rather ' + 'than a continuum of partial states, remains the one substantive modeling commitment, and ' + 'that the Binary Snap occurs remains the occurrence commitment (with DA-1, Section III). Whether the ' + 'bottom element of the state space that an ascending chain returns to is a new one also ' + 'remains a commitment (C-DA2, Section II).', + S['body']), + ] + + # ── VIII. A NOTE ON READING THE DOCUMENTS ───────────────────────────────── + story += [ + Paragraph('VIII. A NOTE ON READING THE DOCUMENTS', S['h1']), Paragraph( 'The technical documents ZP-A through ZP-M are formatted as ontologies, not as ' 'discursive mathematical writing. Each claim appears in a labeled box with its ' @@ -548,7 +655,7 @@ def build(): 'category theory — these are established structures with well-understood ' 'properties. What is new is the conjunction: the claim that these structures, ' 'independently developed within their own disciplines, converge on the same ' - 'foundational point, characterise the same transition, and illuminate the same ' + 'foundational role, each with its own occupant, characterise the same transition, and illuminate the same ' 'paradox from different directions.', S['body']), Paragraph( diff --git a/scripts/build_manifest.py b/scripts/build_manifest.py index 3e9fd1a7..99255924 100644 --- a/scripts/build_manifest.py +++ b/scripts/build_manifest.py @@ -39,7 +39,9 @@ **On the central claim (read this first).** The organizing thesis is that the bottom element recurs in the same structural role across several domains. What is **proved** is the *membership* and the *recurrence of the slot structure*. The reading that the various bottoms are *one object* is retired as ill-typed (object -equality across categories does not typecheck and is not invariant under equivalence); what separates the members +equality across categories does not typecheck and is not invariant under equivalence; for the equivalence +principle see Ahrens and North, "Univalent foundations and the equivalence principle", arXiv:2202.01892, +§ 2, as `CLAIMS.md` cites it); what separates the members is proved property by property (seam_unique_among_named, for the named bottoms, in a lattice with no top). The index above is where the precise line between proved and conjectural is kept. """ diff --git a/scripts/build_snap_map.py b/scripts/build_snap_map.py index c59a479e..79bd9935 100644 --- a/scripts/build_snap_map.py +++ b/scripts/build_snap_map.py @@ -88,9 +88,9 @@ def repl(m): IS_FACES = [ ("theorem", "the *derived* (not assumed) transition off c₀, ⊥ of MachinePhase, into c₁ (in that two-state carrier c₁ covers c₀: `ZeroParadox/Order/SnapCannotBe.lean` § II) - derived, which is a claim about its provenance and not that it is taken: the join c₀ ∨ c₁ = c₁ is a valid transition, and c₀, c₁ are provably distinct in both directions. AX-1 (the Binary Snap) is retired: its shape 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)", ["t_snap_derived"]), - ("verb", "*one-way*: the departure from ⊥ does not reverse. No join can return to a strictly lower state (algebraic form), and the 2-adic and Kleisli faces prove the same irreversibility topologically and categorically", + ("verb", "*one-way*: the departure from ⊥ does not reverse. No join can return to a strictly lower state (algebraic form, and the direction is the order's), and the Kleisli face proves the no-return categorically. The 2-adic face proves no continuous path from a nonzero point back to 0 topologically, and that fact is symmetric: it holds between any two distinct points of Q₂, either way round (the `example` restating c3_irreversible for any two distinct endpoints, in ZeroParadox/Valuation/Padic.lean), so the one-way direction comes from the order and categorical charts, not the topology", ["t_snap_irreversible", "c3_irreversible", "fC_no_return"]), - ("verb", "a chart-reading of the LIMIT - `Statement:` INVERSION, `Reading:` INVERSION and conjectural, since no snap transition appears in the statement - valuation face: the same ω-tower's encodings descend to the 2-adic floor 0 = ⊥ (the ascent to ε₀ resolving back onto the floor - the SAME 0 it started from, `snap_arc_z2_loop`; reading it as a new bottom ⊥ₙ₊₁ is C-DA2, a commitment) and, through the Riemann-sphere inversion that swaps 0 ↔ ∞, rise to ∞. The inversion is the passage between the two charts", + ("verb", "a chart-reading of the LIMIT - `Statement:` INVERSION, `Reading:` INVERSION and conjectural, since no snap transition appears in the statement - valuation face: the same ω-tower's encodings descend to ℤ_[2]'s 0, least under the 2-adic norm preorder (the ascent to ε₀ resolving back onto the floor - the SAME 0 it started from, `snap_arc_z2_loop`; reading it as a new bottom ⊥ₙ₊₁ is C-DA2, a commitment) and, through the Riemann-sphere inversion that swaps 0 ↔ ∞, rise to ∞. The inversion is the passage between the two charts", ["snap_is_frameflip", "snap_frameflip_tower_tendsto_infty"]), ("verb", "a chart-reading of the SEAM (the seam is what the frame-flip FIXES, not a flip, and no snap appears), category face: the categorical seam is an op-self-dual zero object of the module category ModuleCat ℂ - initial and terminal at once, with the op-duality frame-change swapping the two", ["catseam_is_frameflip"]), @@ -116,7 +116,7 @@ def repl(m): []), ("*dependent on a snap-specific axiom*. T-SNAP is derived from the bottom axiom A4 (the join identity ∀ x, ⊥ ∨ x = x) and the framework's commitments; `t_snap_given` states two of them, the start at ⊥ and occurrence at the first step, as its hypotheses. No snap axiom appears anywhere in the development: AX-1 is retired, and that the snap occurs follows from the occurrence commitment together with DA-1, neither of them an axiom", ["t_snap_derived", "t_snap_given"]), - ("*proved to be a choice-free least fixed point*. Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); a choice-free proof of it on a well-founded carrier was not located as of 2026-10-08. The choice is carried by the statement, through Mathlib's `Ordinal` order instance and operations, so no re-routing of the proof can remove it; only a restatement whose own statement is choice-free can (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The from-below ascent on notations is choice-free (`tower_strictMono`)", + ("*proved to be a choice-free least fixed point*. Leastness is proved on `Ordinal` (`epsilon0_min_eq_max`, with choice); the choice is carried by the statement, through Mathlib's `Ordinal` order instance and operations, so no proof of the statement as written can drop it; restated on a carrier whose statements are choice-free, it has two readings: a defined one, in Lean on `E0Note`, where the fixed point is unique by theorem and exists by definition (`e0OmegaPow_fixedpoint_iff`), and a derived one, on a well-founded Lean carrier with leastness derived, not located as of 2026-10-13 (both, with the search record: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint; the same-carrier respelling: `ZeroParadox/Category/ChoiceCannotBe.md`, STATEMENT-CARRIED). The from-below ascent on notations is choice-free (`tower_strictMono`)", ["epsilon0_min_eq_max", "epsilonZero_eq_nfp"]), ] @@ -146,8 +146,8 @@ def repl(m): "the initial object has a unique morphism out to every object and none back; ⊥ is a pure source, not a round trip", ["t2_universal_constituent", "t4_chains_forward_only"]), ("order / set theory", "**Available** (choice-free spine)", - "the fork collapses to the diagonal fixed point exactly when the map has a unique fixed point, and the self-containing ⊥ = {⊥} realizes it. The field snaps form one family (MC-1); the reading that they are numerically one object is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence)", - ["fork_collapse_iff", "selfMem_eq_singleton_bot"]), + "the fork collapses to the diagonal fixed point exactly when the map has a unique fixed point, and the Quine atom (CC-2) realizes it: in the die, under a self-application map supplied by AbstractSelfApp, ⊥ of a ZP-A semilattice is the only point that steps to itself and to nothing else, by that class's own fields (selfApp_quine_role_iff), which the constant map onto ⊥ also meets; the set-theoretic content sits in the host: adopting AFA is CC-2's commitment, the host requirements (QuineAtomHost) are its Lean abstraction, and that any such host gives up Foundation is forced (quineAtomHost_not_wellFounded). The field snaps form one family (MC-1); the reading that they are numerically one object is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence)", + ["fork_collapse_iff", "selfMem_eq_singleton_bot", "selfApp_quine_role_iff", "quineAtomHost_not_wellFounded"]), ("real numbers", "**Walled - the snap fails**", "two global properties, each a separate fence. Order: the field order is dense, and an order is dense exactly when no element has a first step (Mathlib's denselyOrdered_iff_forall_not_covBy, restated as axb1_fails_everywhere_iff_dense), so 0 has none either, in every ordered field (axb1_fails_in_ordered_field). Topology: ℝ is connected while ℚ₂ is totally disconnected (place_topological_signature). Lacking a first step at 0 is not the wall on its own: ℚ₂'s 0 lacks one too in its norm preorder, which is nonetheless not dense (ZeroParadox/BottomCannotBe.lean § ROLE), and the first step the snap takes is AX-B1's cover of ⊥ on the state carrier, a commitment rather than a property of ℚ₂. The one row of this map where the transition provably cannot happen, and that impossibility is itself a theorem: the order fence is proved for every ordered field, ℝ among them. Statement: CARRIER, for the topology fence", ["axb1_fails_everywhere_iff_dense", "axb1_fails_in_ordered_field", "place_topological_signature", "f_snap_impossible"]), @@ -176,17 +176,17 @@ def render_rosetta(): **Proved - the snap is DERIVED rather than assumed, and adds no axiom.** T-SNAP (t_snap_derived): the transition ⊥ → ε₀ (in the discrete state chart, ε₀ names c₁, which covers c₀, ⊥ of MachinePhase, because that carrier has two states, `ZeroParadox/Order/SnapCannotBe.lean` § II; the ordinal ε₀ is a different chart, at once the least fixed point of α ↦ ω^α and the supremum of its tower, epsilon0_min_eq_max, indexed in `ZeroParadox/Ordinal/Epsilon0CannotBe.lean`) is a derived consequence of the bottom axiom A4 and the framework's computational commitments, not an assumption. **"Derived" is a claim about where the transition comes from, not that it is taken:** T-SNAP constrains the SHAPE of the transition and the same file's tsnap_holds_but_nothing_moves proves it holds where nothing moves. That the snap occurs is not a theorem. Earlier layers posited the Binary Snap as AX-1. AX-1 is retired: its content was split in two, the shape proved as Theorem T-SNAP, and that the snap occurs stated separately, following from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2); no snap-specific axiom appears anywhere. -**Proved - the snap is one-way.** It does not reverse: no join returns to a strictly lower state (t_snap_irreversible, algebraic), and the same irreversibility is proved topologically in the 2-adics (c3_irreversible) and categorically in the probability functor (fC_no_return). ⊥ is a source, not a round trip. +**Proved - the snap is one-way.** It does not reverse: no join returns to a strictly lower state (t_snap_irreversible, algebraic; the order chart carries a one-way direction), no return is proved categorically in the probability functor (fC_no_return; that chart is one-way too: the floor's initial maps run out to every stage (fC_zero_isInitial) and no later stage maps back), and topologically the 2-adics admit no continuous path from a nonzero point back to 0 (c3_irreversible), a symmetric fact that holds between any two distinct points of Q₂ in either direction (the `example` restating c3_irreversible for any two distinct endpoints, in ZeroParadox/Valuation/Padic.lean), so the topology supplies no direction of its own. ⊥ is a source, not a round trip. -**Proved - a frame-change in each domain, and an order-theoretic universal.** Over any complete lattice the order-duality frame-change swaps the fork's two closures and the fork collapses at the diagonal fixed point (fork_is_frameflip); this is the standard lfp/gfp duality, choice-free, claimed as no novelty. It is realized concretely in the valuation face (snap_is_frameflip: one ω-tower's encodings converge to ⊥ in the encoding chart and diverge to ∞ through the 0 ↔ ∞ inversion) and the category face (catseam_is_frameflip). (The abstract cross-domain reading - that these are one and the same frame-change - stays a conjecture; see below.) +**Proved - a frame-change in each domain, and an order-theoretic universal.** Over any complete lattice the order-duality frame-change swaps the fork's two closures and the fork collapses at the diagonal fixed point (fork_is_frameflip); this is the standard lfp/gfp duality, choice-free, claimed as no novelty. It is realized concretely in the valuation face (snap_is_frameflip: one ω-tower's encodings converge to ⊥ in the encoding chart and diverge to ∞ through the 0 ↔ ∞ inversion) and the category face (catseam_is_frameflip). (`Statement:` CARRIER - each domain's frame-flip is proved in its own carrier; see below.) **Proved - the first fixed point of ω^· above ⊥ of `Ordinal`, approached choice-free from below.** ε₀ is the least fixed point of omega-to-the-power reached from 0 (epsilonZero_eq_nfp); on ordinal notations the tower climbs from below with no choice (exp_lt_term, omegaPow_no_fixedpoint, tower_strictMono; footprints printed in `ZeroParadox/Ordinal/ConstructiveOrdinals.lean` § PurityCheck) and never reaches ε₀ there, since no notation bounds the tower (tower_no_upper_bound); ε₀ is co-witnessed with the 2-adic limit and the machine snap (zpm_triangle). (That ε₀ *is* the least fixed point is proved on `Ordinal`, with choice carried by the statement, epsilon0_min_eq_max; the open item is below.) **Proved - a wall: the snap is not one mechanism across categories.** The per-domain frame-flips share a shape, not a single categorical map. In Set (all endofunctions) no nontrivial total type carries a Lawvere fixed-point witness - Cantor forbids it - so the lattice and 2-adic faces are provably not Set-level Lawvere instances (nontrivial_lattice_no_witness, q2_no_witness); their ⊥ is a proved fixed point of its own self-map (q2_unique_fp, selfApp_fp_set_eq_singleton), carrying the diagonal shape but not a genuine Set-level Lawvere instance. The computability face, by contrast, IS a genuine recursion fixed point (computability_face_fixedPoint, Kleene / Rogers) - but it lives in the effective category, where the fixed-point-free DIAGONAL CONSTRUCTION is not admissible. `Reading:` CARRIER - the verdict is category-relative, not a property of the object: the same diagonal shape is refuted in Set and available in the effective setting. That is not the claim that no fixed-point-free computable endomap exists - c |-> Code.pair c c is one - and the fixed point it gets is Rogers', up to eval. Heterogeneous categories, heterogeneous verdicts: what unifies them is the diagonal shape, not one mechanism. The universality that holds is order-theoretic (the fork), not categorical - a proved obstruction. -**The family (proved), the identity (retired), choice-free minimality (open).** The domain snaps form one **family** (MC-1): per-domain membership is proved, the reading that they are *numerically one* transition is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). Separately, leastness is proved on `Ordinal` (epsilon0_min_eq_max, with choice); a choice-free proof of it on a well-founded carrier was not located as of 2026-10-08. The choice is carried by the statement, so no re-routing of the proof can remove it; only a restatement whose own statement is choice-free can (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). +**The family (proved), the identity (retired), choice-free minimality (open).** The domain snaps form one **family** (MC-1): per-domain membership is proved, the reading that they are *numerically one* transition is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). Separately, leastness is proved on `Ordinal` (epsilon0_min_eq_max, with choice); the choice is carried by the statement, so no proof of the statement as written can drop it; restated on a carrier whose statements are choice-free, it has two readings: a defined one, in Lean on E0Note, where the fixed point is unique by theorem and exists by definition (e0OmegaPow_fixedpoint_iff), and a derived one, on a well-founded Lean carrier with leastness derived, not located as of 2026-10-13 (both, with the search record: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint; the same-carrier respelling: `ZeroParadox/Category/ChoiceCannotBe.md`, STATEMENT-CARRIED). -**A note on the frame-change faces.** snap_is_frameflip, catseam_is_frameflip, and fork_is_frameflip are proved theorems that compose known results (no novelty is claimed); the per-domain frame-flips and the order-theoretic universal hold. What remains a conjecture is only the abstract cross-domain statement "the snap ⊥ → ε₀ IS the change of point of view" - that the faces are literally one change of frame (a type boundary). The formal write-up is the finalized document [ZP-Q The Frame-Change](ZP-Q_The_Frame_Change.pdf) (see register.md for the current version). Note the scope: the DOCUMENT is finalized; the three Lean files above are still marked experimental probes in their own headers, and `SnapFrameChange.lean` carries the cross-domain claim as an explicit open conjecture. "Finalized" refers to the write-up, not to the Lean support.""" +**A note on the frame-change faces.** snap_is_frameflip, catseam_is_frameflip, and fork_is_frameflip are proved theorems that compose known results (no novelty is claimed); the per-domain frame-flips and the order-theoretic universal hold. Two different statements are kept apart. That the faces are literally one change of frame is not stated: an equation across the domains is ill-typed (a type boundary, MC-1), and each domain's frame-flip is proved in its own chart. That "the snap ⊥ → ε₀ IS the change of point of view" is ZP-Q's open conjecture. The formal write-up is the finalized document [ZP-Q The Frame-Change](ZP-Q_The_Frame_Change.pdf) (see register.md for the current version). Note the scope: the DOCUMENT is finalized; the three Lean files above are still marked experimental probes in their own headers, and `SnapFrameChange.lean` carries the snap-as-instance reading as an explicit open conjecture. "Finalized" refers to the write-up, not to the Lean support.""" return link_in_text(body) PAGE = """# The Binary Snap (⊥ → ε₀) - Dictionary and Map @@ -203,7 +203,7 @@ def render_rosetta(): This is a **reference** for the framework's central transition, the **snap** - the one-way move off the bottom element ⊥ into the first structured state, ε₀. It is the companion to [The Bottom Element](BOTTOMELEMENT.md): that page maps the *object* ⊥ (the noun); this page maps the *transition* off it (the verb). Where the bottom dictionary is mostly nouns, this one is mostly verbs - the snap is an action. -It is a **beginning, not a resolution.** What is *proved* is that the snap's shape is derived rather than assumed (that it occurs follows from the occurrence commitment together with DA-1, closed given DP-2), one-way, takes its first step from below, and that the domain snaps form one **family** (MC-1, membership proved per domain); what is *retired* is the reading that they are numerically one object (ill-typed: object equality across categories does not typecheck and is not invariant under equivalence); and what stays *open* is a choice-free proof of ε₀'s leastness on a well-founded carrier, not located as of 2026-10-08 (`ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The frame-change faces are proved theorems that compose known results, so no new theorem is claimed there; what stays a conjecture is only the abstract cross-domain reading (`Reading:` INVERSION, conjectural) - that they are literally one change of frame (a type boundary) - written up in [ZP-Q](ZP-Q_The_Frame_Change.pdf). +It is a **beginning, not a resolution.** What is *proved* is that the snap's shape is derived rather than assumed (that it occurs follows from the occurrence commitment together with DA-1, closed given DP-2), one-way, takes its first step from below, and that the domain snaps form one **family** (MC-1, membership proved per domain); what is *retired* is the reading that they are numerically one object (ill-typed: object equality across categories does not typecheck and is not invariant under equivalence); and what stays *open* is the derived reading of the choice-free restatement: ε₀'s fixed point, leastness included, derived on a well-founded Lean carrier whose statements are choice-free, not located as of 2026-10-13 (the defined reading, on E0Note, is in Lean; both: `ZeroParadox/Ordinal/SnapNucleus.md` § Axiom footprint). The frame-change faces are proved theorems that compose known results, so no new theorem is claimed there; no identity across the domains is stated - an equation across them is ill-typed (a type boundary, MC-1) - so "the faces are literally one change of frame" is not a well-formed statement; each domain's frame-flip is proved in its own chart. Whether the snap is an instance of the frame-change is a separate question, ZP-Q's open conjecture (`Reading:` INVERSION, conjectural), written up in [ZP-Q](ZP-Q_The_Frame_Change.pdf). --- @@ -215,7 +215,7 @@ def render_rosetta(): ### The snap is (positive handles, with witnesses) -The handles sort by **aspect**: what the snap *is* (**noun** - the endpoints it joins) or what the snap *does* (**verb** - the action itself). Most are verbs; that is the point. *(The frame-change is the POLE EXCHANGE - the bottom read as both 0 and infinity. Whether the snap is an instance of that exchange is ZP-Q's open conjecture, not a settled identification either way; see ZP-Q and the declaration docstrings.)* *The per-domain frame-flips and the order-theoretic universal are proved theorems, written up in ZP-Q (The Frame-Change); they compose known results, so no new theorem is claimed. Only the abstract cross-domain reading - that these are literally one change of frame - is a conjecture (a type boundary).* +The handles sort by **aspect**: what the snap *is* (**noun** - the endpoints it joins) or what the snap *does* (**verb** - the action itself). Most are verbs; that is the point. *(The frame-change is the POLE EXCHANGE - the bottom read as both 0 and infinity. Whether the snap is an instance of that exchange is ZP-Q's open conjecture, not a settled identification either way; see ZP-Q and the declaration docstrings.)* *The per-domain frame-flips and the order-theoretic universal are proved theorems, written up in ZP-Q (The Frame-Change); they compose known results, so no new theorem is claimed. That they are literally one change of frame is not stated: an equation across the domains is ill-typed (a type boundary, MC-1).* {is_faces} diff --git a/scripts/build_tools.py b/scripts/build_tools.py index 0fefeb57..a8e32cb0 100644 --- a/scripts/build_tools.py +++ b/scripts/build_tools.py @@ -1,8 +1,5 @@ """ Build ZP Tools and Methods document. -Updated May 2026 (adversary-review pass): repo URL added to reproducibility section; -key result box updated to acknowledge ZP-F as a non-Lean-verified layer and correct layer count. -Updated April 2026: Lean 4 formal verification now complete for all layers. """ import os @@ -67,8 +64,8 @@ def key_result_box(title, body_text, bg=BLUE, hdr_bg=BLUE_DARK): def tool_stack_diagram(): """Stacked rectangles showing tool layers.""" - # dh = 2.2 in + 8 pt: content top = caption cap height at dh - 10.5, bottom = lowest box at 10 pt - dw, dh = TW, 2.2 * inch + 8 + # dh = 2.1 in (151.2 pt): content top = first box top at 139.2 pt, bottom = lowest box at 10 pt + dw, dh = TW, 2.1 * inch d = Drawing(dw, dh) layers = [ @@ -83,14 +80,10 @@ def tool_stack_diagram(): bw = dw - 2 * margin bh = (2.2*inch - 0.35*inch) / n # fixed box height, independent of dh gap = 4 - - caption_y = dh - 18 - d.add(String(margin, caption_y, - 'Claude acts as reasoning layer; all formal tools are standard open software.', - fontSize=7.5, fontName='DV-I', fillColor=GREY)) + top_y = 141.2 # fixed: top of the box stack, independent of dh (R-DIAGRAM) for i, (label, fill, text_col) in enumerate(layers): - by = dh - 0.35*inch - (i+1)*bh + gap/2 + by = top_y - (i+1)*bh + gap/2 d.add(Rect(margin, by, bw, bh - gap, fillColor=fill, strokeColor=colors.HexColor('#FFFFFF'), strokeWidth=1, rx=3, ry=3)) @@ -196,8 +189,12 @@ def footer_cb(canvas, doc): 'Mathlib categories TopCat, KleisliCat PMF and ModuleCat ℂ, which close OQ-G3; ' 'domain theorems (C3, T1b, T4) ground the snap in each stand-in category. ' 'ZP-E/G/H: sorry-free proofs for key results. Source on illustrated branch. ' - 'Note: CC-2 (⊥ = {⊥}, ZF+AFA) is a metatheoretic commitment; ' - 'Lean\'s bot is a structural proxy, not a Quine atom in Lean\'s type theory.'], + 'Note: the Quine atom (CC-2) is a role, a point that steps to itself and to ' + 'nothing else, which Lean measures chart by chart: bot of a ZPSemilattice ' + 'occupies it under a self-application map (AbstractSelfApp; ' + 'selfApp_quine_role_iff), no set in Mathlib\'s ZFSet does ' + '(zfset_quine_role_unoccupied). Adopting ZF+AFA as the set chart\'s host is ' + 'the metatheoretic commitment.'], ['Isabelle/HOL', 'No', 'Not used.'], ['Agda', 'No', 'Not used.'], ['Mizar', 'No', 'Not used.'], @@ -215,24 +212,33 @@ def footer_cb(canvas, doc): E.append(key_result_box( 'Key Result: What formal verification does and does not change', 'Formal verification in Lean 4 operates at two levels. (1) Full algebraic verification: ' - 'ZP-A\'s algebraic layer (A1-A4 and all derived results) is fully machine-checked via NatSLat; ' - 'each proof\'s axiom footprint is the #print axioms output in ZeroParadox/Order/Lattice.lean ' - '(the A1-A4 theorems) and ZeroParadox/Multihomed/CategoricalBridge.lean (NatSLat). ' + 'ZP-A\'s algebraic layer is machine-checked: A1-A4 are the fields of the class ZPSemilattice, ' + 'the derived results are theorems over it, and NatSLat (natZPSemilattice, ' + 'ZeroParadox/Multihomed/CategoricalBridge.lean) is a concrete instance. Footprints are printed ' + 'declaration by declaration in each file\'s PurityCheck section: ZeroParadox/Order/Lattice.lean ' + 'prints the order laws, state_transition_iff, state_sequence_monotone and cc1; ' + 'ZeroParadox/Order/Snap.lean prints further derived results such as ' + 'da2_bottom_characterization; CategoricalBridge.lean\'s NatSLat block prints ' + 'natSLat_initial_grounding. ' '(2) Functor-level verification: for ZP-B, ZP-C, and ZP-D, ' 'sorry-free Lean functors land in ℕ-indexed stand-in categories and in the standard Mathlib ' 'categories TopCat, KleisliCat PMF and ModuleCat ℂ, which close OQ-G3; the domain theorems ' '(C3, T1b, T4) ground the snap in each stand-in category. ' - 'Neither level formalizes CC-2 (⊥ = {⊥}). CC-2 is a metatheoretic commitment ' - 'over ZF + AFA. In Lean the two charts split: Mathlib\'s ZFSet, a model of ZFC, contains no ' - 'set that is a member of itself (no_quine_atom), while outside ZFSet Lean hosts a one-atom ' - 'model whose distinguished element is its own unique self-member (the QuineHost instance on ' - 'OneAtom, ZeroParadox/Settheory/QuineHost.lean § V). The Lean bot is the structural proxy ' - 'for the algebraic role of ⊥; that it is a set equal to its own singleton, CC-2\'s ' - 'set-theoretic self-containment, is a prose-level commitment. ' - 'The stated axioms (AX-B1, AX-G1, AX-G2) and modeling commitments (CC-1, CC-2) remain ' - 'as stated. The derived results are confirmed as derived. The framework\'s epistemic ' - 'status has improved — the algebraic core is machine-checked; the metatheoretic ' - 'commitment CC-2 is explicitly outside that scope.')) + 'The Quine atom (CC-2) is a role, a point that steps to itself and to nothing else ' + '(Motion.SelfOnlyAt, ZeroParadox/Die.lean), measured chart by chart with no equation across ' + 'charts: ⊥ of a ZPSemilattice occupies it under a self-application map supplied by ' + 'AbstractSelfApp (selfApp_quine_role_iff); in Mathlib\'s ZFSet, a model of ZFC, where the role reads x = {x} ' + '(zfset_selfOnlyAt_mem_iff), no set occupies it (zfset_quine_role_unoccupied, from ' + 'no_quine_atom); and outside ZFSet Lean hosts a one-atom model whose distinguished element is ' + 'its own unique self-member (the QuineHost instance on OneAtom, ' + 'ZeroParadox/Settheory/QuineHost.lean § V). Wherever membership hosts the role, ' + 'Foundation fails (quineAtomHost_not_wellFounded; for any well-founded membership relation, ' + 'the example citing wf_no_selfloop in ZeroParadox/Settheory/QuineDichotomy.lean); adopting ZF + AFA as the set chart\'s host ' + 'is the metatheoretic commitment (ZP-E, R-AFA). ' + 'The stated axioms (AX-B1, AX-G1, AX-G2) and modeling commitments (CC-1, and CC-2\'s adoption ' + 'of AFA) remain as stated. The derived results are confirmed as derived. The framework\'s ' + 'epistemic status has improved — the algebraic core is machine-checked; the metatheoretic ' + 'commitment, adopting AFA, is explicitly outside that scope.')) E.append(sp(8)) # Section 3: Computational Tools @@ -246,10 +252,12 @@ def footer_cb(canvas, doc): ['Python 3', 'General scripting', 'All PDF build scripts. Environment: Windows 11 with system Python.'], ['ReportLab', 'PDF generation', - 'All technical PDFs (ZP-A through ZP-K plus ZP-F, companions, foreword, this document). ' + 'All technical PDFs (the formal layers listed in register.md, with their companions ' + 'and addenda, the foreword, this document). ' 'Used for Paragraph layout, Table construction, and Drawing (vector diagrams).'], ['Lean 4 + Mathlib', 'Formal proof verification', - 'Machine-checked proofs for all eleven layers (ZP-A through ZP-K, plus ZP-F). ' + 'Machine-checked proofs for the formal layers\' Lean results (ZeroParadox/, indexed by ' + 'ZeroParadox/MANIFEST.md). ' 'Source on illustrated branch. Built with lake build. Purity checks via #print axioms.'], ['DejaVu fonts','Typography', 'DejaVuSerif (body text) and DejaVuSans (headers, labels, diagrams). ' @@ -339,7 +347,7 @@ def footer_cb(canvas, doc): 'installed and the DejaVu fonts in scripts/fonts/.')) E.append(body( 'The mathematical content is fully specified in the formal ontology documents ' - '(ZP-A through ZP-K, plus ZP-F). The companion documents and foreword are narrative ' + '(the formal layers listed in register.md). The companion documents and foreword are narrative ' 'restatements of the same content. If the formal documents change, the companions ' 'and foreword require updating to match.')) E.append(body( @@ -352,10 +360,9 @@ def footer_cb(canvas, doc): 'The Zero Paradox is a human-originated mathematical framework, developed through ' 'iterative collaboration with an AI research assistant, documented in a rigorous ' 'ontology format, rendered as publication-quality PDFs using open-source Python ' - 'tooling, and formally verified in Lean 4 + Mathlib. All ten Lean-verified formal layers ' - '(ZP-A, ZP-B, ZP-C, ZP-D, ZP-E, ZP-G, ZP-H, ZP-I, ZP-J, ZP-K) build clean. ' - 'ZP-F (The Counterexamples) provides a classical mathematical argument without a Lean component. ' - 'Proofs are machine-checked.', + 'tooling, and formally verified in Lean 4 + Mathlib. The formal layers\' Lean results, ZP-F\'s ' + 'general counterexample results among them (ZP-F § II), are machine-checked; Section 6 ' + 'says how to rebuild them.', bg=GREEN, hdr_bg=GREEN)) print(f'Building: {out_path}') diff --git a/scripts/build_zp_choice_free_core.py b/scripts/build_zp_choice_free_core.py index 861a79ab..a8bae4ab 100644 --- a/scripts/build_zp_choice_free_core.py +++ b/scripts/build_zp_choice_free_core.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP Addendum: The Choice-Free Core -Version 1.13 | October 2026 +Version 1.19 | November 2026 Framework-wide note; reads after the Foreword. """ import os from zp_utils import * -VERSION = '1.13' +VERSION = '1.19' FIRST_RELEASED = 'June 2026' # ── fix() guard ── @@ -52,7 +52,7 @@ def build(): # ── Preamble (artifact-first) ──────────────────────────────────────────────── print('[build_zp_choice_free_core] Building preamble...') E.append(body( - 'Build the file ZeroParadox/AxiomProfile.lean and read the Lean kernel\'s output. It reports ' + 'Build the file ZeroParadox/AxiomProfile.lean and read the output of Lean\'s `#print axioms` command. It reports ' 'that the central theorem of this framework — the Binary Snap, T-SNAP, whose SHAPE is ' 'derived while its occurrence follows from the occurrence commitment together with DA-1 (closed given DP-2), the ' 'transition ⊥ → ε0 — depends on no axioms at all: not ' @@ -62,8 +62,9 @@ def build(): '`lake build ZeroParadox.AxiomProfile` and see it.')) E.append(body( 'Two boundaries are stated up front, because the claim is narrow and exact. The framework ' - 'as a whole is not choice-free. Most of its theorems do depend on `Classical.choice`. ' - 'Most places it appears are places where the framework builds on Mathlib\'s ' + 'as a whole is not choice-free. Many of its theorems depend on `Classical.choice` (no ' + 'proportion is measured here). Many of the places it appears are places where the framework ' + 'builds on Mathlib\'s ' 'classically-built analysis, order, and computability libraries — the layers that ' 'realize the snap inside standard analytic structures (p-adic topology, Hilbert space, ' 'ordinals), where the dependence is inherited from those libraries. Not all of it is ' @@ -75,7 +76,7 @@ def build(): 'used by the core results above. And dependence is not necessity: that those ' 'realizations use choice as written does not show the mathematics requires it. ' 'Several of their statements carry it as written (Section III), so no proof of those ' - 'statements can drop it; whether a restatement on a choice-free carrier holds is a ' + 'statements can drop it; whether a restatement on a carrier whose statements are choice-free holds is a ' 'separate question.')) E.append(hr()) @@ -86,7 +87,7 @@ def build(): hr(), ] E.append(body( - 'The Lean kernel\'s `#print axioms` command reports the complete axiom dependency of any ' + 'Lean\'s `#print axioms` command reports the complete axiom dependency of any ' 'result. Run on the framework\'s central results, it returns the following. "Does not depend ' 'on any axioms" is the strongest possible report — stronger than "choice-free," since ' 'it uses not even propositional extensionality.')) @@ -104,9 +105,9 @@ def build(): E.append(sp(4)) E.append(body( 'A second tier of results is choice-free but uses propositional extensionality and quotient ' - 'soundness (`[propext, Quot.sound]`), both standard in Lean 4. These include the structural ' - 'floor (PowerSet.ps_structural_floor) and the wheel of fractions ' - '(WheelFrac.instWheel, inf_ne_bot). No `Classical.choice`.')) + 'soundness (`[propext, Quot.sound]`), both standard in Lean 4. These include the power set\'s ' + 'depth chart (ps_structural_floor, ZeroParadox/Order/PowerSet.lean) and the wheel of fractions ' + '(ZeroParadox.instWheel and inf_ne_bot, ZeroParadox/Algebra/WheelFrac.lean). No `Classical.choice`.')) E.append(sp(6)) # ── Section II ─────────────────────────────────────────────────────────────── @@ -117,9 +118,10 @@ def build(): hr(), ] E.append(body( - 'The honest contrast. `Classical.choice` does appear across the framework — in the ' - 'majority of its theorems — and the same `#print axioms` artifact shows exactly where. ' - 'Most occurrences are in a layer that realizes the snap floor inside a standard analytic ' + 'The honest contrast. `Classical.choice` does appear across the framework, in many of its ' + 'theorems. Each file\'s `#print axioms` block reports, declaration by declaration, which carry ' + 'it, and ZeroParadox/AxiomProfile.lean prints a selection (§§ 0–III). Many ' + 'occurrences are in a layer that realizes the snap floor inside a standard analytic ' 'structure, inheriting choice from the Mathlib library that builds that structure ' 'classically. Not every occurrence is inherited: the framework writes bare classicals of its ' 'own, and ZeroParadox/Category/ChoiceCannotBe.lean § IV collects cases among them whose ' @@ -169,7 +171,8 @@ def build(): 'principle (related prior art, cited not claimed, as recorded in ' 'ZeroParadox/Category/LawvereTaboo.lean: Bauer, "On fixed-point theorems in synthetic ' 'computability", Tbilisi Math. J. 10(3) (2017), Cor 4.3; de Jong–Escardó, ' - 'arXiv:2102.08812, Cor 39(iii)-(iv); Booij–Escardó–Lumsdaine–Shulman, ' + '"Predicative Aspects of Order Theory in Univalent Foundations", arXiv:2102.08812, ' + 'Cor 39(iii)-(iv); Booij–Escardó–Lumsdaine–Shulman, ' '"Parametricity, automorphisms of the universe, and excluded middle", arXiv:1701.05617, ' 'Thm 3, and Thm 5 (Simpson), whose proof technique the reduction uses) — the latter sitting on the keystone rather than on an imported order ' 'instance; § IV\'s cases 3 to 5 are reductions for principles proved with bare ' @@ -186,8 +189,8 @@ def build(): 'a type rather than a proof, no proof of any statement mentioning that type can be ' 'clean, and removability there means changing the statement, not cleaning the argument. That ' 'case is measured: the statements of c3_irreversible, t4_snap_orthogonal, fD_functor and ' - 'fC_functor, each only assumed, already report Classical.choice (the statement control, ' - '2026-10-08), so they are statement-carried, and the open question for them is a restatement ' + 'fC_functor, each only assumed, already report Classical.choice (the statement-carried row of ' + 'ZeroParadox/AxiomProfile.md), so they are statement-carried, and the open question for them is a restatement ' 'on a carrier whose statements are choice-free. fB_functor\'s statement is choice-free; its ' 'dependence stays open.')) E.append(body( @@ -208,7 +211,7 @@ def build(): 'central results leaned on the Axiom of Choice — the canonical free, non-constructive ' 'selection. They do not. T-SNAP is axiom-free; the keystone is choice-free. The ' '"forced, not chosen" thesis is internally consistent at the level of what the framework ' - 'actually asserts. Where choice appears it is mostly the supporting library\'s classical ' + 'actually asserts. Where choice appears it is often the supporting library\'s classical ' 'foundation showing through the realizations rather than an assumption of the argument. ' 'The reductions Section III points at are the exception on a different axis: they are about ' 'necessity, not provenance. Some of their principles are proved with the ' @@ -236,7 +239,7 @@ def build(): 'collects, and for related declarations; § I prints the choice-free core and § II further choice-free results; ' '§ III prints the analytic-realization results that carry choice, as an honest ' 'contrast. Build with `lake build ZeroParadox.AxiomProfile` and read ' - 'the kernel\'s report. The per-theorem map is in the project repository.', + 'the `#print axioms` report. The per-theorem map is in the project repository.', 'Choice-probe (the one-layer classification): branch `choice-probe`; the verdict and the ' 'three decomposed sources are recorded in the project notes.', ] @@ -250,17 +253,19 @@ def build(): 'that the whole framework is choice-free (it is not), nor that the analytic-layer choice ' 'is removable or necessary. Where a statement carries it as written (Section III), no ' 'proof of that statement can drop it and the open question is a restatement on a ' - 'choice-free carrier; elsewhere necessity is open. The fact surfaced here is the ' + 'carrier whose statements are choice-free (for the ε0 results, its two ' + 'readings and the search record are in ZeroParadox/Ordinal/SnapNucleus.md, section Axiom ' + 'footprint); elsewhere necessity is open. The fact surfaced here is the ' 'verified one.', ] )) E.append(sp(6)) E.append(Paragraph( - 'Endnote: This is a framework-wide note, machine-verified as of October 2026 (lake build; ' - 'statement control measured 2026-10-08). The central ' + 'Endnote: This is a framework-wide note; the footprints it cites are copies, and the live ' + 'record is the #print axioms output of the files it names. The central ' 'theorem T-SNAP depends on no axioms; the conceptual core is free of the Axiom of Choice; ' - '`Classical.choice` appears mostly where the framework builds on Mathlib\'s classical analysis, ' + '`Classical.choice` appears in many places where the framework builds on Mathlib\'s classical analysis, ' 'order, and computability libraries, where several statements carry it as written (for ' 'those, the open question is a restatement) and elsewhere whether it is necessary remains ' 'open. It is not only there: the framework carries bare classicals of its own, and the ' diff --git a/scripts/build_zpa.py b/scripts/build_zpa.py index d35f7287..012605be 100644 --- a/scripts/build_zpa.py +++ b/scripts/build_zpa.py @@ -1,11 +1,11 @@ """ -Build ZP-A: Lattice Algebra (v1.33) +Build ZP-A: Lattice Algebra (v1.37) """ import os from zp_utils import * -VERSION = '1.33' +VERSION = '1.37' FIRST_RELEASED = 'April 2026' def build(): @@ -21,11 +21,11 @@ def build(): body('Illustrated Companion: A paired ZP-A Illustrated Companion document provides concrete examples and visual intuitions for the results in this document. Examples are kept separate from the formal layers to distinguish illustrative material from proofs. The companion is a reading aid; no proof-critical judgements should be drawn from examples alone.'), sp()] - E.append(label_box('Metatheoretic Declaration — ZF + AFA', [ - 'This document is stated over ZF + AFA (Zermelo–Fraenkel set theory with Aczel’s Anti-Foundation Axiom). AFA replaces the classical Axiom of Foundation and permits self-containing sets — in particular, sets satisfying x = {x}.', - 'Scope: This declaration affects only CC-2 (Section V), which asserts ⊥ = {⊥}. All algebraic results in Sections I–IV are independent of AFA and hold in standard ZF.', - 'Standard concrete models (power sets ordered by inclusion, real intervals ordered by max, etc.) satisfy A1–A4 but do not satisfy ⊥ = {⊥}. This is expected — they are models of the algebraic structure, not instantiations of the ZF + AFA metatheory. The self-containment of ⊥ is a set-theoretic claim about what ⊥ is, not an algebraic one.', - 'The Axiom of Choice is not assumed. Foundation-freeness is forced (Section V); which anti-foundation axiom hosts ⊥ is not, and AFA is adopted as the canonical host — see ZP-E Remark R-AFA.', + E.append(label_box('Metatheoretic Declaration — ZFC− + AFA', [ + 'This document is stated over ZFC− + AFA: Zermelo–Fraenkel set theory with Choice, with Aczel’s Anti-Foundation Axiom (AFA) in place of the classical Axiom of Foundation. It is Aczel’s ZFC− + AFA (Aczel 1988, p. xviii). Barwise and Moss’s ZFA (Barwise & Moss 1996, p. 72) is the same swap of Foundation for AFA over a ZFC− that also has urelements (a proper class of them, by Strong Plenitude, p. 28); Choice is among its axioms (p. 28). AFA permits self-containing sets — in particular, sets satisfying x = {x}.', + 'Scope: This declaration affects only CC-2 (Section V), the Quine atom, whose set-theoretic occupant is a set satisfying x = {x}. All algebraic results in Sections I–IV are independent of AFA and hold in standard ZF.', + 'Standard concrete models (power sets ordered by inclusion, real intervals ordered by max, etc.) satisfy A1–A4, and no element of them is asserted to be a set x = {x}. This is expected — they are models of the algebraic structure, not instantiations of the ZFC− + AFA metatheory. Self-containment is stated as a role that each structure occupies or not by its own theorem (Section V), not as an algebraic property of ⊥.', + 'Choice is kept: it is an axiom of ZFC−. Which results use it is measured result by result (#print axioms); 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 at all (t_snap_derived, ZeroParadox/AxiomProfile.lean). Foundation-freeness is forced (Section V); which anti-foundation axiom hosts the Quine-atom role is not, and AFA is adopted as the canonical host — see ZP-E Remark R-AFA.', ])) E.append(sp(8)) @@ -109,21 +109,21 @@ def build(): E.append(Paragraph('V. The Self-Containment of ⊥', S['h1'])) E.append(Paragraph('5.1 Foundational Characterisation', S['h2'])) - E.append(body('The axioms A1–A4 establish ⊥ as the additive identity and algebraic minimum of L. The following forced metatheoretic commitment characterises its set-theoretic nature. Under CC-2, R3 reads off that ⊥ admits no external interpreter position. That rules out an external executor, not an inert ⊥: it does not supply DA-1’s precondition, which is what the occurrence commitment asserts and which DA-1 consumes (ZP-E Section IV, Path 1). See R3.')) - E.append(body('Foundation note: The framework is stated over ZF + AFA (Zermelo–Fraenkel set theory with Aczel’s Anti-Foundation Axiom). The classical Axiom of Foundation is replaced by AFA, which permits self-containing sets. Dropping Foundation is not an arbitrary modelling choice: ⊥ = {⊥} is a member of itself (⊥ ∈ ⊥), which the Axiom of Foundation (Regularity) forbids — under a well-founded membership relation no set is self-membered (no_quine_atom, ZeroParadox/Settheory/Wall.lean) — so a Foundation universe cannot host ⊥. Which anti-foundation axiom replaces Foundation is a further choice: AFA is the one this framework adopts, not the only one that admits such a set. R3 and ZP-C L-INF corroborate the non-well-founded character of ⊥ rather than independently prove the exclusion. See ZP-E Remark R-AFA for the full cross-framework argument. The Axiom of Choice is not assumed.')) + E.append(body('The axioms A1–A4 establish ⊥ as the additive identity and algebraic minimum of L. The following forced metatheoretic commitment concerns the set-theoretic host of the Quine-atom role, which ⊥ occupies in the lattice under a self-application map. Under CC-2, R3 reads off that ⊥ admits no external interpreter position. That rules out an external executor, not an inert ⊥: it does not supply DA-1’s precondition, which is what the occurrence commitment asserts and which DA-1 consumes (ZP-E Section IV, Path 1). See R3.')) + E.append(body('Foundation note: The framework is stated over ZFC− + AFA (Zermelo–Fraenkel set theory with Choice, with Aczel’s Anti-Foundation Axiom in place of Foundation). The classical Axiom of Foundation is replaced by AFA, which permits self-containing sets. Dropping Foundation is not an arbitrary modelling choice: a set equal to its own singleton, x = {x}, is a member of itself (x ∈ x), which the Axiom of Foundation (Regularity) forbids — under a well-founded membership relation no set is self-membered (no_quine_atom, ZeroParadox/Settheory/Wall.lean) — so in a Foundation universe no set occupies the Quine-atom role (zfset_quine_role_unoccupied). Which anti-foundation axiom replaces Foundation is a further choice: AFA is the one this framework adopts, not the only one that admits such a set. R3 and ZP-C L-INF corroborate the non-well-founded character of the role’s host rather than independently prove the exclusion. See ZP-E Remark R-AFA for the full cross-framework argument. Only Foundation is replaced; Choice is kept.')) E.append(sp(4)) E.append(label_box('Forced Metatheoretic Commitment CC-2 — Self-Containment of ⊥', [ - 'The bottom element ⊥ of L is its own extension: the collection of all objects bearing the structural property of ⊥ is ⊥ itself.', - 'Formally: ⊥ = {⊥}', - 'Under ZF + AFA, ⊥ is a Quine atom — a set satisfying x = {x}. By set extensionality, any infinite collection of objects all indistinguishable under the structural property of ⊥ collapses to ⊥ itself. There is no multiplicity, only ⊥.', - 'This is a Forced Metatheoretic Commitment, not a freely chosen modeling decision. Foundation cannot host ⊥ = {⊥}: the bottom is a member of itself, and Regularity forbids self-membership in ZF; in Lean, Mathlib’s ZFSet, a model of ZFC, contains no such set (no_quine_atom). The Foundation-freeness of any host of ⊥ is forced and machine-checked (quineAtomHost_not_wellFounded; see ZP-E Remark R-AFA); what remains a commitment rather than a theorem is that a Quine atom and its uniqueness are the right requirements to demand, and which anti-foundation axiom meeting them to adopt (ZP-E Remark R-AFA) — neither is derived from A1–A4 at the algebraic level. A differently-motivated requirement set that hosts ⊥ without demanding a unique Quine atom would reopen the first; it would not touch the forcing, which is settled.', - 'Status: FORCED METATHEORETIC COMMITMENT — Foundation-freeness of any host of ⊥ is forced and machine-checked (quineAtomHost_not_wellFounded); two things remain commitments rather than derivations: the requirements-choice (a unique Quine atom), and the choice of AFA among the anti-foundation axioms that meet it (ZP-E Remark R-AFA). Algebraic fixed-point content formally verified in ZFC by ZP-J (ScaleBridge); the literal membership ⊥ ∈ ⊥ is refuted in Mathlib’s ZFSet (no_quine_atom) and holds for an abstract membership relation on a two-element carrier (OneAtom, oneAtom_quineAtomHost); as membership in a model of ZF + AFA it is outside Lean scope (metatheoretic).', - 'Cross-framework note: Dropping Foundation is not an arbitrary choice — ⊥ = {⊥} is a member of itself (⊥ ∈ ⊥), which Regularity forbids in ZF, so ZF + Foundation cannot host it; in Lean, Mathlib’s ZFSet, a model of ZFC, contains no such set (no_quine_atom). What is forced runs one way: a host whose bottom is its own only member is not well-founded (quineAtomHost_not_wellFounded). Run backwards it selects no theory, so the anti-foundation axiom is chosen, and AFA is adopted as the canonical host (ZP-E Remark R-AFA). R3 and ZP-C L-INF corroborate ⊥\'s non-well-founded character; they are not independent proofs of the exclusion. See ZP-E Remark R-AFA for the full cross-framework argument.', - 'Lean 4 scope — three distinct layers. (1) Set-theoretic: the claim ⊥ = {⊥} as a set cannot be realized in Mathlib’s ZFSet, a model of ZFC, whose membership is well-founded (no_quine_atom: x ∉ x for every x : ZFSet). This remains a prose-level commitment in ZF + AFA. (2) AFAStructure context (the typeclass taken as a hypothesis): ZP-J defines IsQuineAtom as the lattice-theoretic analog — IsQuineAtom q := selfMem q ∧ ∀ x, selfMem x → x = q. Within an AFAStructure instance, t_exec_iff proves IsQuineAtom q ↔ q = ⊥ (SetTheoryAFA.lean); ZP-K’s da1_closed_concrete closes this concretely on MachinePhase. These results take the AFAStructure typeclass as a hypothesis, which every ZP-A lattice can supply trivially, so the hypothesis carries no AFA set-theoretic content of its own. (3) ZFC-clean (no AFA import): ScaleBridge.lean proves the fixed-point content in standard ZFC — selfMem_eq_singleton_free and z2_selfMem_singleton establish {x : ℤ₂ | 2x = x} = {0}. This result is loop-free from AFA. The set-theoretic interpretation connecting layer 3 to layer 1 remains outside Lean scope.', + 'The Quine atom is a role: a point that steps to itself and to nothing else (Motion.SelfOnlyAt, ZeroParadox/Die.lean). Where a set steps to its members, a set occupies the role exactly when it is its own only member, x = {x} (zfset_selfOnlyAt_mem_iff).', + 'Formally, chart by chart (ZeroParadox/Settheory/QuineDichotomy.lean): when the step is a self-application map supplied by AbstractSelfApp, whose only fixed point is ⊥, ⊥ of L is the only occupant, by the class fields alone (selfApp_quine_role_iff); when the step is membership in a QuineAtomHost, whose bottom is its own only member and the only such element, that host’s own bottom is the only occupant (quineAtomHost_quine_role_iff), so ⊥ of L occupies it exactly when the host’s bottom is ⊥ of L (the host examples after quineAtomHost_quine_role_iff); no set of Mathlib’s well-founded ZFSet occupies it (zfset_quine_role_unoccupied). Every ZPSemilattice carries an AbstractSelfApp (trivialSelfApp, the constant map to ⊥) and every inhabited type a QuineAtomHost (trivialQuineAtomHost), so an occupancy says something only with the step named. No equation between ⊥ of L and a set is stated: it would be ill-typed.', + 'Under ZFC− + AFA the set chart is occupied: the Quine atom is a set satisfying x = {x}, and AFA allows at most one solution of x = {x} (Aczel 1988, p. 19), so where the role is occupied there is no multiplicity.', + 'This is a Forced Metatheoretic Commitment, not a freely chosen modeling decision. Foundation cannot host a set x = {x}: such a set is a member of itself, and Regularity forbids self-membership in ZF; in Lean, Mathlib’s ZFSet, a model of ZFC, contains no such set (no_quine_atom). The Foundation-freeness of any host of the Quine-atom role is forced and machine-checked (quineAtomHost_not_wellFounded; see ZP-E Remark R-AFA); what remains a commitment rather than a theorem is that a Quine atom and its uniqueness are the right requirements to demand, and which anti-foundation axiom meeting them to adopt (ZP-E Remark R-AFA) — neither is derived from A1–A4 at the algebraic level. A differently-motivated requirement set that hosts the Quine-atom role without demanding a unique Quine atom would reopen the first; it would not touch the forcing, which is settled.', + 'Status: FORCED METATHEORETIC COMMITMENT — Foundation-freeness of any host of the Quine-atom role is forced and machine-checked (quineAtomHost_not_wellFounded); two things remain commitments rather than derivations: the requirements-choice (a unique Quine atom), and the choice of AFA among the anti-foundation axioms that meet it (ZP-E Remark R-AFA). Algebraic fixed-point content formally verified in ZFC by ZP-J (ScaleBridge); the literal self-membership x ∈ x is refuted in Mathlib’s ZFSet (no_quine_atom) and holds of the bottom of an abstract membership relation on a two-element carrier (OneAtom, oneAtom_quineAtomHost); as membership in a model of ZFC− + AFA it is outside Lean scope (metatheoretic), and no equation makes ⊥ of L such a set.', + 'Cross-framework note: Dropping Foundation is not an arbitrary choice — a set x = {x} is a member of itself (x ∈ x), which Regularity forbids in ZF, so ZF + Foundation cannot host it; in Lean, Mathlib’s ZFSet, a model of ZFC, contains no such set (no_quine_atom). What is forced runs one way: a host whose bottom is its own only member is not well-founded (quineAtomHost_not_wellFounded). Run backwards it selects no theory, so the anti-foundation axiom is chosen, and AFA is adopted as the canonical host (ZP-E Remark R-AFA). R3 and ZP-C L-INF corroborate the non-well-founded character of the role\'s host; they are not independent proofs of the exclusion. See ZP-E Remark R-AFA for the full cross-framework argument.', + 'Lean 4 scope — three distinct layers. (1) Set-theoretic: no set x = {x} exists in Mathlib’s ZFSet, a model of ZFC, whose membership is well-founded (no_quine_atom: x ∉ x for every x : ZFSet; zfset_quine_role_unoccupied). Such a set lives in ZFC− + AFA, outside Lean scope, and no equation between it and ⊥ of L is stated. (2) AFAStructure context (the typeclass taken as a hypothesis): ZP-J defines IsQuineAtom as the lattice-theoretic analog — IsQuineAtom q := selfMem q ∧ ∀ x, selfMem x → x = q. Within an AFAStructure instance, t_exec_iff proves IsQuineAtom q ↔ q = ⊥ (SetTheoryAFA.lean); ZP-K’s da1_closed_concrete closes this concretely on MachinePhase. These results take the AFAStructure typeclass as a hypothesis, which every ZP-A lattice can supply trivially, so the hypothesis carries no AFA set-theoretic content of its own. (3) ZFC-clean (no AFA import): ScaleBridge.lean proves the fixed-point content in standard ZFC — selfMem_eq_singleton_free and z2_selfMem_singleton establish {x : ℤ₂ | 2x = x} = {0}. This result is loop-free from AFA. What relates the layers is the Quine-atom role, occupied or not chart by chart; no equation across them is stated.', ])) E.append(sp(4)) E.append(label_box('Remark R3 — CC-2 Leaves No External Interpreter Position for ⊥', [ - 'A self-containing object has no external interpreter by structure: ⊥ = {⊥} is its own interpretation. A description requires a describer distinct from the thing described; CC-2 admits no such distinction for ⊥. That rules out an external executor, not an inert ⊥: it does not settle whether the machine configuration reaching P0 (ZP-E) is there in Sense B, a running machine’s current configuration, rather than Sense A, an inert string.', + 'A self-containing object has no external interpreter by structure: an occupant of the Quine-atom role steps to itself and to nothing else, so it is its own interpretation. A description requires a describer distinct from the thing described; CC-2 admits no such distinction for the occupant, which in the lattice under a self-application map is ⊥ (selfApp_quine_role_iff). That rules out an external executor, not an inert ⊥: it does not settle whether the machine configuration reaching P0 (ZP-E) is there in Sense B, a running machine’s current configuration, rather than Sense A, an inert string.', 'Dependency note: R3 is the structural motivation of ZP-E’s Path 1 and derives neither DA-1 nor its precondition. That the configuration reaching P0 is there in Sense B is DA-1’s precondition, what the occurrence commitment asserts, and DA-1 consumes it (ZP-E Section IV).', ])) E.append(sp()) @@ -148,7 +148,7 @@ def build(): ['≤ partial order (D1, T1)', 'Derived — ZP-D: ordering on states'], ['Monotonicity of state sequences (T3)', 'Derived from A1–A3 — ZP-D: state layer ordering'], ['⊥ as global minimum (T2, CC-1)', 'Derived (T2) / Conditional (CC-1) — ZP-E: ontological grounding claim. CC-1 is restated in ZP-J as an equivalence (cc1_derived, t_exec_iff), not forced.'], - ['⊥ = {⊥} self-containment (CC-2, R3)', 'Forced Metatheoretic / Remark — ZP-E: Path 1’s structural motivation (rules out an external executor, not an inert ⊥). Fixed-point content verified in ZFC by ZP-J.'], + ['Quine-atom role, self-containment (CC-2, R3)', 'Forced Metatheoretic / Remark — ZP-E: Path 1’s structural motivation (rules out an external executor, not an inert ⊥). Fixed-point content verified in ZFC by ZP-J.'], ['No subtraction / additive ontology (R1)', 'Structural — ZP-C: no operation may reduce informational content'], ['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 c0, conditional on the alignment hypothesis hε0 (ε0 sent to c1)']], [2.5*inch, 4.0*inch] @@ -164,8 +164,8 @@ def build(): ['State transition as join (D2)', 'Valid — Defined; consistent with signature'], ['Monotonicity of state sequences (T3)', 'Valid — Derived from A1–A3 and D3'], ['CC-1: S0 = ⊥', 'CONDITIONAL CLAIM — modelling commitment at ZP-A scope. ZP-J restates it as an equivalence (a Quine-atom start is a ⊥ start: cc1_derived, t_exec_iff); the starting-point choice is not forced.'], - ['CC-2: ⊥ = {⊥}', 'Forced Metatheoretic Commitment — Foundation-freeness forced (QuineAtomHost); AFA adopted as the host, not selected; fixed-point content verified in ZFC by ScaleBridge'], - ['ZF + AFA foundation (no AC)', 'Meta-theoretic — framework-wide; the host adopted for CC-2'], + ['CC-2: the Quine atom (a role)', 'Forced Metatheoretic Commitment about the host — occupancy proved chart by chart (QuineDichotomy.lean); Foundation-freeness forced (QuineAtomHost); AFA adopted as the host, not selected; fixed-point content verified in ZFC by ScaleBridge'], + ['ZFC− + AFA foundation (Foundation replaced by AFA, Choice kept)', 'Meta-theoretic — framework-wide; the host adopted for CC-2 (Aczel 1988, p. xviii; Barwise & Moss 1996, p. 72, whose ZFC− on p. 28 also has urelements)'], ['OQ-A1: Sufficiency of monotonicity', '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 c0, conditional on the alignment hypothesis hε0 (ε0 sent to c1)']], [2.5*inch, 4.0*inch] )) diff --git a/scripts/build_zpa_companion.py b/scripts/build_zpa_companion.py index e92895c3..75597fbe 100644 --- a/scripts/build_zpa_companion.py +++ b/scripts/build_zpa_companion.py @@ -1,5 +1,5 @@ """ -Build ZP-A Illustrated Companion (v1.12) +Build ZP-A Illustrated Companion (v1.23) Covers: join-semilattice, partial order, Hasse diagram, one-directional transitions, monotonicity (T3), bottom-as-constituent (T2), four concrete examples, and CC-2. """ @@ -89,7 +89,7 @@ def transition_diagram(): fontName='DV-B', fillColor=RED)) return d -VERSION = '1.12' +VERSION = '1.23' FIRST_RELEASED = 'April 2026' @@ -231,12 +231,20 @@ def footer_cb(canvas, doc): E.append(sp(4)) E.append(remember_box( 'Note: [0, ∞) with maximum is a valid join-semilattice, and ℝ ' - 'works perfectly well as an algebraic structure here. But as a metric substrate ' - 'for the Binary Snap, ℝ fails — for any positive ε, the element ' - 'ε/2 is always smaller, so no minimal first step can exist. This is the ' - 'subject of ZP-F (The Counterexamples), which establishes formally that no ' - 'linearly ordered field can host the snap. Q₂ is required precisely because ' - 'it is not a linearly ordered field in the same sense.')) + 'works perfectly well as an algebraic structure here. But in ℝ, 0 has no first step ' + 'above it, AX-B1’s form: for any positive ε, the element ' + 'ε/2 is always smaller, so no minimal first step can exist. That no first step exists ' + 'is the subject of ZP-F (The Counterexamples), which proves that no linearly ordered field ' + 'has a least positive element (f_snap_impossible); what obstructs a first step is density ' + '(axb1_fails_everywhere_iff_dense). T-SNAP’s shape, the Binary Snap, does not need ' + 'one: t_snap_given holds at a step taken in a densely ordered join-semilattice (the ' + 'ℚ≥0 example, ZeroParadox/Order/Snap.lean). Among the completions of ℚ, the topological difference ' + 'between ℝ and Q₂ is that ℝ is connected, so not totally disconnected (real_no_snap), while Q₂ is ' + 'totally disconnected (padic_snaps). That is not a separate fence: for a linear order ' + 'carrying its order topology, connectedness implies density (Mathlib ' + 'denselyOrdered_of_preconnectedSpace). Q₂’s topology supplies no first step: ' + 'Mathlib gives Q₂ no order, and under the norm preorder 0 has no first step there either (ZeroParadox/BottomCannotBe.lean). The first ' + 'step is supplied by AX-B1, a commitment (ZeroParadox/Order/SnapCannotBe.lean, § V).')) E.append(sp(4)) E.append(example_box('Example — Document edit history', [ 'Open a document and start making edits. Even hitting Backspace does not erase from the ' @@ -247,33 +255,49 @@ def footer_cb(canvas, doc): ])) E.append(sp(8)) # CC-2: Self-Containment of ⊥ - E.append(Paragraph('⊥ Contains Itself (CC-2)', CS['h1'])) + E.append(Paragraph('⊥ in the Quine-Atom Role (CC-2)', CS['h1'])) E.append(cbody( 'Every state sits above ⊥. But what exactly is ⊥? The standard ' 'answer: the additive identity, the algebraic zero, the starting point. ZP-A ' - 'adds a sharper answer: ⊥ is a Quine atom — a set that equals its ' - 'own singleton.')) + 'adds a sharper answer in terms of a role, the Quine atom (CC-2): a point that ' + 'steps to itself and to nothing else. Which point fills it depends on the step, ' + 'as the next paragraph details: under a self-application map whose only fixed point is ' + '⊥, ⊥ fills it; under membership, the host’s own bottom fills it, and that ' + 'is ⊥ of the lattice exactly when the host is built with ⊥ as its bottom, as the ' + 'host built from the lattice’s AFA structure is (the examples after ' + 'quineAtomHost_quine_role_iff, ZeroParadox/Settheory/QuineDichotomy.lean). In set theory, where a set steps to its ' + 'members, that role is filled by a set that equals its own singleton.')) E.append(cbody( - 'Formally: ⊥ = {⊥}. The collection of all objects bearing the structural ' - 'property of ⊥ is ⊥ itself. There is no multiplicity. Infinitely many ' - 'indistinguishable ⊥ instances collapse, by set extensionality, into the ' - 'single object ⊥.')) + 'Formally, the role is stated in each setting on its own terms rather than as one ' + 'equation. In a lattice given a self-application map whose only fixed point is ⊥ (even ' + 'the constant map to ⊥ qualifies), with that map as the step, ⊥ is the only ' + 'point filling it. With membership as the step, in a host whose bottom is its own only ' + 'member and where no other element is its own only member, that host’s bottom is the ' + 'only point filling it. No ordinary, well-founded set fills ' + 'it at all. No equation between ⊥ and a set is stated, since the two live in ' + 'different types. Where the role is filled here it is filled once, so there is no ' + 'multiplicity.')) E.append(example_box('Why this matters', [ 'Can there be two "copies" of ⊥ that are somehow different? A Quine atom ' 'says no. Any object identical to ⊥ in all structural respects IS ⊥. ' 'There is nothing external to ⊥ by which to distinguish copies.', - 'A label requires a labeller outside it. ⊥ = {⊥} has no outside. ' + 'A label requires a labeller outside it. A point that steps only to itself has no ' + 'outside. ' 'That rules out an outside executor; it does not by itself make ⊥ run. ' 'That the snap at P₀ is an execution rather than a description being read is ' 'what the occurrence commitment asserts (ZP-E), and DA-1 consumes it.', ])) E.append(remember_box( - 'Technical note (CC-2): the Quine atom property requires dropping the classical Axiom ' - 'of Foundation (which rules out self-containing sets); the framework replaces it with ' - 'Aczel\'s Anti-Foundation Axiom (AFA), one of several anti-foundation axioms that admit ' - 'such a set. The Axiom of Choice is not assumed. This is a framework-level commitment — A1–A4 ' - 'are unaffected, but it changes what ⊥ is allowed to be. ' - 'For a plain-language explanation of why Foundation is incompatible with ⊥ = {⊥}, ' + 'Technical note (CC-2): for a set to fill the Quine-atom role, the host set theory must ' + 'drop the classical Axiom of Foundation (which rules out self-containing sets, so under it ' + 'no set fills the role); the framework replaces it with Aczel\'s Anti-Foundation Axiom ' + '(AFA), one of several anti-foundation axioms that admit such a set. Only Foundation is ' + 'replaced and Choice is kept, as in Aczel\'s ZFC− + AFA (and in Barwise and Moss\'s ZFA, whose ZFC− also ' + 'has urelements, a proper class of them by Strong Plenitude, p. 28). Adopting AFA is a framework-level commitment about the host theory ' + '(CC-2\'s); dropping Foundation is forced by the role itself, whichever anti-foundation axiom hosts it (quineAtomHost_not_wellFounded) — A1–A4 ' + 'are unaffected, and no equation makes ⊥ of the lattice a set. ' + 'For a plain-language explanation of why Foundation is incompatible with a set that is ' + 'its own only member, ' 'see the ZP-J Illustrated Companion; for why AFA is adopted rather than forced, see ZP-E ' 'Remark R-AFA.')) E.append(sp(8)) diff --git a/scripts/build_zpb.py b/scripts/build_zpb.py index 943c23ec..60fbc209 100644 --- a/scripts/build_zpb.py +++ b/scripts/build_zpb.py @@ -1,13 +1,13 @@ """ -Build ZP-B: p-Adic Topology (v1.30) +Build ZP-B: p-Adic Topology (v1.33) This document makes no Planck-scale comparison for epsilon-0: an adversary review (2026-05-21) -flagged that analogy because it makes a document read as a physics grand theory. +flagged that analogy because it makes the document read as a physics grand theory. """ import os from zp_utils import * -VERSION = '1.30' +VERSION = '1.33' FIRST_RELEASED = 'April 2026' def build(): @@ -27,7 +27,7 @@ def build(): E.append(label_box('Axiom AX-B1 — Binary Existence', [ 'The foundational distinction of the Zero Paradox framework is binary: a state either exists or it does not. There is no third option at this level.', '0 — non-existence (⊥ in ZP-A; in Lean, ⊥ of OntologicalStates under instOntZPS)', - '1 — existence (ε0, the state off ⊥ of OntologicalStates)', + '1 — existence (ε0 of OntologicalStates, the state off ⊥ there; D5 below states the ε0 role in Q2, which any nonzero point at the chosen rung occupies)', '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. (In this two-state chart, 1 is the top.)', 'Status: AXIOM. This is the only non-topological commitment in ZP-B. It precedes p-adic analysis and is the premise from which the field selection is derived.', 'Scope: AX-B1 asserts the structure of the ontological distinction, not its physical realisation. It is invariant across all instantiations.', @@ -78,9 +78,10 @@ def build(): 'Prior art: Shannon names the base-2 unit of information the bit (a word he credits to J. W. Tukey), ' 'and a device with two stable positions can store one bit (C. E. Shannon, "A Mathematical ' 'Theory of Communication", Bell System Technical Journal 27 (1948), Introduction). ' - 'MP-1 minimises digit values without redundancy and does not use the cost measure that prices a base ' + 'MP-1 minimises the number of digit values without redundancy and does not use the cost measure that prices a base ' 'by the number of digit values times the number of digits it needs, with optimum e, so that 3 is almost always the most ' - 'economical integer base (B. Hayes, "Third Base", American Scientist 89(6), 490 (2001), doi:10.1511/2001.6.490). ' + 'economical integer base (B. Hayes, "Third Base", American Scientist 89(6), November–December 2001, doi:10.1511/2001.6.490; ' + 'the page, 490, is from the print record and was not checked: the copy read here is the unpaginated web version). ' 'For a given range rounding can tie or reverse that ranking (two values cost 2 in base 2 and 3 in base 3).', ])) diff --git a/scripts/build_zpc.py b/scripts/build_zpc.py index 493f20c7..c679b35d 100644 --- a/scripts/build_zpc.py +++ b/scripts/build_zpc.py @@ -1,11 +1,11 @@ """ -Build ZP-C: Information Theory (v1.26) +Build ZP-C: Information Theory (v1.39) """ import os from zp_utils import * -VERSION = '1.26' +VERSION = '1.39' FIRST_RELEASED = 'April 2026' def build(): @@ -17,7 +17,7 @@ def build(): Paragraph(version_line(FIRST_RELEASED, VERSION), S['subtitle']), sp(10), body('This document is self-contained within information theory and discrete analysis on Q2, with two named cross-layer dependencies. The topological structure of Q2 — total disconnectedness (ZP-B T5), the clopen ball hierarchy, and the binary existence axiom (AX-B1) — is imported from ZP-B. The Candidate Theorem T-BUF (Section V) additionally invokes ZP-A’s state-transition definition D2 (f(x) = x ∨ α) to identify the resulting state as the Binary Snap. T-BUF is conditional on execution: its Step 2, that the configuration at P0 is executing, is not derived here or in ZP-E; it is the occurrence commitment (ZP-E, DA-1 insert § IV), which DA-1 consumes and does not supply. Every claim is marked as Derived, Axiomatic, Defined, or Candidate.'), - body('Encoding commitment. The two ontological states of AX-B1 are represented here as point-mass (Dirac) distributions over {0, 1} — the minimum-sufficient probabilistic encoding (RP-1, Section II). Under this encoding, the information-theoretic separation between ⊥ and the minimum non-bottom state (ε0) is exactly 1 bit (T1b). The 1-bit result is conditional on this encoding; RP-1 declares and justifies the commitment. Separately, at ⊥, the primary descriptive tool of information theory — surprisal — is unbounded above (L-INF, Section III): no finite external description can contain ⊥. These two results — the 1-bit cost of the transition and the infinite descriptive cost of the origin — are the information-theoretic expression of the same structural constraint on ⊥.'), + body('Encoding commitment. The two ontological states of AX-B1 are represented here as point-mass (Dirac) distributions over {0, 1} — the minimum-sufficient probabilistic encoding (RP-1, Section II). Under this encoding, the information-theoretic separation between ⊥ and ε0, the atom above ⊥ of the two-state carrier, is exactly 1 bit (T1b). The 1-bit result is conditional on this encoding; RP-1 declares and justifies the commitment. Separately, the primary descriptive tool of information theory, surprisal, is unbounded above in the depth of the ball hierarchy, each value finite (L-INF, Section III), and c0, ⊥ of MachinePhase, corresponds to that hierarchy’s limit point 0 ∈ Q2, where the 2-adic additive valuation is ⊤ (R-BRIDGE); from these the framework argues that no finite external description can contain c0. These two results — the 1-bit cost of the transition and the infinite descriptive cost of the origin — are the information-theoretic expression of the same structural constraint, read on two bottoms: ⊥ of the two-state encoding of AX-B1, and c0, ⊥ of MachinePhase.'), body('Illustrated Companion: A paired ZP-C Illustrated Companion provides concrete examples and visual intuitions for the results here. Examples are kept separate from the formal layers to distinguish illustrative material from proofs.'), sp()] @@ -47,8 +47,8 @@ def build(): E.append(label_box('Theorem T1 — State Representations are Uniquely Derived', [ 'Given AX-B1 and RP-1, the distributions are unique:', 'P = (1, 0) (the bottom state ⊥: all mass at 0 — non-existence)', - 'Q = (0, 1) (the minimum non-bottom state ε0: all mass at 1 — existence)', - 'Proof: AX-B1 establishes two ontological states. RP-1 requires point-mass representation of each. The bottom state ⊥ occupies value 0: P = (1,0). The minimum non-bottom state ε0 occupies value 1: Q = (0,1). No distribution (p, 1−p) with 0 < p < 1 is consistent with AX-B1. P and Q are unique. Status: DERIVED from AX-B1 and RP-1. ✓', + 'Q = (0, 1) (ε0, the atom above ⊥ of the two-state carrier: all mass at 1 — existence)', + 'Proof: AX-B1 establishes two ontological states. RP-1 requires point-mass representation of each. The bottom state ⊥ occupies value 0: P = (1,0). ε0, the atom above ⊥ of the two-state carrier, occupies value 1: Q = (0,1). No distribution (p, 1−p) with 0 < p < 1 is consistent with AX-B1. P and Q are unique. Status: DERIVED from AX-B1 and RP-1. ✓', ])) E.append(sp(4)) E.append(label_box('Corollary T1b — JSD = 1 bit', [ @@ -111,19 +111,19 @@ def build(): E.append(Paragraph('III-B. Unbounded Surprisal of the Bottom Element', S['h1'])) E.append(label_box('Lemma L-INF — Unbounded Surprisal of ⊥', [ 'The surprisal I(n) = n at ball-hierarchy depth n is unbounded above: for any finite bound M, there exist depths n with I(n) > M.', - '⊥ = c0 corresponds to the limit point 0 ∈ Q2 — the limit of the binary ball hierarchy at infinite depth. The binary branching measure assigns equal probability mass at each branch level (D4), and the surprisal diverges without bound as depth increases (T2). At this limit, no finite bound M contains the informational content of ⊥.', + 'c0, ⊥ of MachinePhase, corresponds to the limit point 0 ∈ Q2 — the limit of the binary ball hierarchy at infinite depth. The binary branching measure assigns equal probability mass at each branch level (D4), and the surprisal diverges without bound as depth increases (T2), each value finite. Surprisal is defined at each depth, not at the limit point itself.', 'Proof: Let M ∈ ℝ. By the Archimedean property, ∃ n ∈ ℕ with n > M. Then I(n) = n > M. Since M was arbitrary, surprisal is unbounded above. ✓', 'Formal content: surprisal is not bounded above by any real M.', - 'Semantic content: ⊥ has unbounded surprisal — it is the limit point of the binary ball hierarchy under the 2-adic metric, the accumulation point approached by sequences of increasing depth. No finite bound M contains the surprisal at that limit; therefore no finite external interpreter can hold ⊥ as a static description. This is one argument for DA-1’s precondition (ZP-E, DA-1 insert § IV, Path 2), and it does not derive it. ZP-A CC-2 (⊥ = {⊥}), itself a commitment, gives a second, structural argument for the same conclusion: a self-containing object has no external interpreter by structure (ZP-A R3). The informational argument from the ball hierarchy and the structural argument from self-containment are independent; neither makes the configuration at P0 executing.', + 'Semantic content: c0, ⊥ of MachinePhase, corresponds to the limit point 0 of the binary ball hierarchy under the 2-adic metric, approached by sequences of increasing depth along which surprisal exceeds every finite bound; at that point the 2-adic additive valuation is ⊤ (R-BRIDGE). From these two charts the framework argues that no finite external interpreter can hold c0 as a static description. This is one argument for DA-1’s precondition (ZP-E, DA-1 insert § IV, Path 2), and it does not derive it. ZP-A CC-2 (the Quine atom, a role: in a ZP-A lattice under a self-application map supplied by AbstractSelfApp, ⊥ is its only occupant, selfApp_quine_role_iff), itself a commitment, gives a second, structural argument for the same conclusion: a self-containing object has no external interpreter by structure (ZP-A R3). The informational argument from the ball hierarchy and the structural argument from self-containment are independent; neither makes the configuration at P0 executing.', 'Note: L-INF supplies unbounded surprisal; the step from there to executing is not a consequence of L-INF and is not DA-1. It is a bridge principle of its own (ZP-E, DA-1 insert § IV, Path 2), which the framework does not adopt, which is not the occurrence commitment, and which is not a premise of the Snap.', - 'Status: DERIVED from D4 and T2. Structural corroboration: ZP-A CC-2 (⊥ = {⊥}) and R3. Lean: l_inf (purity check: no non-Mathlib axioms).', + 'Status: DERIVED from D4 and T2. Structural corroboration: ZP-A CC-2 (the Quine atom, a role) and R3. Lean: l_inf (purity check: no non-Mathlib axioms).', ])) E.append(sp(4)) E.append(label_box('Remark R-BRIDGE — On the Relationship Between K and 2-Adic Surprisal', [ 'ZP-C uses two complexity measures: Kolmogorov complexity K(x|n)/|x| (Section I) and ' '2-adic surprisal I(n) = n (Section III). These measure related but distinct structures. ' 'Their relationship warrants explicit statement.', - 'What each measures. K(x|n)/|x| = 1 is a property of a specific binary string x: ' + 'What each measures. K(x|n) ≥ |x| is a property of a specific binary string x: ' 'no program shorter than x generates it. It is a pointwise statement about a particular ' 'configuration at the incompressibility threshold. I(n) = n is a property of position in ' 'the ball hierarchy: the surprisal of any string at 2-adic depth n is n, by the branching ' @@ -136,10 +136,14 @@ def build(): 'grows without bound. A string can be 2-adically deep without being Kolmogorov-incompressible, ' 'and vice versa.', 'How ZP-C uses them. ZP-C uses K and I as two separate arguments, not as a single ' - 'unified measure and not as two routes to one threshold. L-INF is the 2-adic surprisal argument: ' - 'I(n) unbounded → no finite interpreter can hold ⊥. DA-1 Path 3 (ZP-E) is the ' - 'K-incompressibility argument: K = 1 rules out a shorter external generator, not an inert string, ' - 'so Path 3 shows that executing is not derivable from incompressibility. Neither derives ' + 'unified measure and not as two routes to one threshold. The 2-adic surprisal argument has two charts. Depth chart, L-INF: ' + 'I(n) = n is unbounded in the depth n with each value finite (l_inf). Point chart: at 0 of Q2, the one point ' + 'in every ball B(0, 2−n) of the chain centred at 0 (fB_bottom_is_limit), the 2-adic additive valuation is ⊤ ' + '(padic_addVal_bot; the floor-and-⊤ coincidence is infinitude_forces_infinite_complexity at q2InfinitudeFloor); c0, ⊥ of ' + 'MachinePhase, corresponds to that point. From these the framework argues that no finite interpreter can hold ' + 'c0. DA-1 Path 3 (ZP-E) is the ' + 'K-incompressibility argument: K(x|n) ≥ |x| rules out a shorter external generator, not an inert string, ' + 'so it does not derive executing from incompressibility. Neither derives ' 'DA-1’s precondition.', ])) E.append(sp(4)) @@ -158,16 +162,16 @@ def build(): 'Step 1 — c0 and c1 are distinct configurations by D7: the control unit is in a different state (idle vs. executing). c0 ≠ c1.', 'Step 2 — By AX-B1, a state either exists or it does not. The machine at c1 occupies a configuration distinct from c0. The transition c0 → c1 is a binary state change in the sense of AX-B1.', 'Step 3 — The transition is irreducible: there is no intermediate configuration between c0 and c1. The first instruction fetch is the minimal unit of execution.', - 'Step 4 — c0 is modeled as corresponding to ⊥ in the semilattice (CC-2 — see below). c1 is strictly above ⊥: the machine configuration has gained content (an active execution context) not present in c0.', + 'Step 4 — c0 is modeled as corresponding to ⊥ in the semilattice (ZP-C CC-2 — see below). c1 is strictly above ⊥: the machine configuration has gained content (an active execution context) not present in c0.', 'Conclusion: c1 ≠ ⊥ (in Lean, l_run, with ⊥ of MachinePhase = c0). The act of execution is itself a non-bottom state, regardless of what the output tape contains. ✓', 'Status: DERIVED from AX-B1 and D7. No Coding Theorem required. No output-tape contents required.', ])) E.append(sp(4)) - E.append(label_box('Conditional Claim CC-2 — c₀ = ⊥ (Parallel to CC-1 in ZP-A)', [ + E.append(label_box('Conditional Claim CC-2 (ZP-C) — c₀ = ⊥ (Parallel to CC-1 in ZP-A; not ZP-A CC-2, the Quine atom)', [ 'We model the initial machine configuration c0 as corresponding to ⊥ in the semilattice (L, ∨, ⊥). This is not derived from D7 or from A1–A4 — it is a modeling choice.', 'Motivation: c0 is the machine state prior to any execution: no instruction has been fetched, no content has accumulated. ⊥ is the algebraic element below all others — the state of no accumulated content. The identification is motivated by structural correspondence, not derivation.', - 'Parallel: CC-1 in ZP-A commits to S0 = ⊥ for state sequences. CC-2 makes the same commitment for machine configurations. Both are modeling choices, not derivations from the core axioms.', - 'Effect: Step 4 of L-RUN depends on CC-2. The conclusion c1 ≠ ⊥ follows from L-RUN\'s proof; the identification of c0 with ⊥ is the additional modeling commitment supplied by CC-2.', + 'Parallel: CC-1 in ZP-A commits to S0 = ⊥ for state sequences. ZP-C CC-2 makes the same commitment for machine configurations. Both are modeling choices, not derivations from the core axioms.', + 'Effect: Step 4 of L-RUN depends on ZP-C CC-2. The conclusion c1 ≠ ⊥ follows from L-RUN\'s proof; the identification of c0 with ⊥ is the additional modeling commitment supplied by ZP-C CC-2.', 'Status: CONDITIONAL CLAIM — modeling commitment; not derived from D7 or A1–A4.', ])) E.append(sp(4)) @@ -186,7 +190,7 @@ def build(): 'Step 2 — By L-RUN, c1 ≠ ⊥.', 'Step 3 — Therefore the execution trace τ(p) = (c0, c1, …) contains c1, which is a non-bottom configuration state, regardless of what appears on the output tape at termination.', 'Step 4 — The output of p being ⊥ does not imply that all configurations in τ(p) are ⊥. Output state and configuration state are distinct (R4).', - 'Conclusion: No program can produce ⊥ as output without passing through a non-bottom intermediate configuration state. TQ-IH answered negatively. ✓', + 'Conclusion: No program can produce ⊥ as output without passing through a non-bottom intermediate configuration state. TQ-IH answered negatively. ✓ The quantification over programs is Step 1’s, from D7; what Lean proves is the configuration fact, tq_ih: c1 ≠ c0 (Ne.symm l_run).', 'Status: DERIVED from L-RUN, D7, and R4. No Kolmogorov machinery required. TQ-IH is one of the results from which ZP-E derives the shape of the Snap as Theorem T-SNAP.', ])) E.append(sp(4)) @@ -199,17 +203,17 @@ def build(): E.append(sp(4)) E.append(label_box('Candidate Theorem T-BUF — Execution at P₀ Forces a Non-Bottom State', [ 'Statement: At the incompressibility threshold P0, the Binary Snap ⊥ → ε0 is a structural consequence of execution, not an external trigger.', - 'Step 1 — P0 identifies the configuration x at which K(x|n)/n = 1: the configuration string is incompressible. (D1)', - 'Step 2 — The configuration at P0 is executing: it is a running machine’s current configuration (Sense B, ZP-E, DA-1 insert § II), not an inert string. This step is not derived: it is the occurrence commitment (instantiation occurs), and T-BUF is conditional on it. Arguments for it, none deriving it: surprisal is unbounded at ⊥ (L-INF), and the step from unbounded surprisal to executing is a bridge principle of its own, which the framework does not adopt (ZP-E, DA-1 Path 2); it is incompressible (D1), which rules out a shorter external generator and not an inert string (ZP-E, DA-1 Path 3). DA-1 (ZP-E, DA-1 insert § IV, closed given DP-2) consumes this step and does not supply it. In ZP-A’s order, given CC-1, its first-step form is the hypothesis hocc of t_snap_given (ZP-E, Premises of T-SNAP).', + 'Step 1 — P0 identifies the configuration x at which K(x|n) ≥ n = |x|: the configuration string is incompressible, and, since K(x|n) ≤ |x| + c for every x, K(x|n)/n is 1 up to an additive constant in K (bounds and sources: ZP-E, T-SNAP Step 1). (D1)', + 'Step 2 — The configuration at P0 is executing: it is a running machine’s current configuration (Sense B, ZP-E, DA-1 insert § II), not an inert string. This step is not derived: it is the occurrence commitment, and T-BUF is conditional on it. Arguments for it, none deriving it: the 2-adic surprisal argument in its two charts (depth chart, L-INF: surprisal unbounded in the depth n with each value finite, l_inf; point chart: the 2-adic additive valuation ⊤ at 0 of Q2, the point to which c0 corresponds, padic_addVal_bot; R-BRIDGE), and the step from unbounded surprisal to executing is a bridge principle of its own, which the framework does not adopt (ZP-E, DA-1 Path 2); it is incompressible (D1), which rules out a shorter external generator and not an inert string (ZP-E, DA-1 Path 3). DA-1 (ZP-E, DA-1 insert § IV, closed given DP-2) consumes this step and does not supply it. In ZP-A’s order, given CC-1, its first-step form is the hypothesis hocc of t_snap_given (ZP-E, Premises of T-SNAP).', 'Step 3 — Any execution passes through c1 (L-RUN). c1 ≠ ⊥ (L-RUN conclusion).', 'Step 4 — In (L, ∨, ⊥), this non-bottom configuration state is c1 = ⊥ ∨ ε0. By ZP-A D2, this is the Binary Snap.', 'Conclusion: Given Step 2, execution at P0 guarantees a non-bottom configuration state (L-RUN), and that state is ε0 in the semilattice. The derivation pathway is P0 + L-RUN + TQ-IH + ZP-A D2, given Step 2. ✓', - 'Status: CANDIDATE THEOREM — conditional on execution. Step 1 is a definition (D1) and Steps 3 and 4 are derived within ZP-C; Step 2 is the occurrence commitment (ZP-E, DA-1 insert § IV), not a derived step, and DA-1 does not close it. ZP-E derives the Snap’s shape as Theorem T-SNAP; that the Snap occurs follows from the occurrence commitment together with DA-1 (closed given DP-2).', + 'Status: CANDIDATE THEOREM — conditional on execution. Step 1 is a definition (D1) and Steps 3 and 4 are derived within ZP-C; Step 2 is the occurrence commitment (ZP-E, DA-1 insert § IV), not a derived step, and DA-1 does not close it. ZP-E derives the Snap’s shape as Theorem T-SNAP; that the Snap occurs follows from the occurrence commitment together with DA-1 (closed given DP-2). The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII).', ])) E.append(sp(4)) E.append(label_box('Remark R5 — Updated Status of AX-1', [ 'AX-1 (Binary Snap Causality) was previously labeled Axiomatic in ZP-C.', - 'AX-1 was a Candidate Theorem in ZP-C; it is now retired: its shape is proved as T-SNAP (ZP-E), and that the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). The derivation pathway ZP-C gave it: P0 (D1) identifies the threshold. L-RUN establishes that execution at the threshold constitutes a state change off ⊥. TQ-IH establishes that no program avoids this. ZP-A D2 establishes that a state change off ⊥ is the Binary Snap.', + 'AX-1 was a Candidate Theorem in ZP-C; it is now retired: its shape is proved as T-SNAP (ZP-E), and that the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). The derivation pathway ZP-C gave it: P0 (D1) identifies the threshold. L-RUN establishes that execution at the threshold constitutes a state change off ⊥. TQ-IH, read with D7, establishes that no executing program avoids this. ZP-A D2 establishes that a state change off ⊥ is the Binary Snap.', 'That a configuration at P0 is an execution event (a running machine’s current configuration, not an inert string) is the occurrence commitment, DA-1’s precondition. DA-1 (ZP-E, a Derived Proposition closed given DP-2) consumes it and does not supply it: given it, c0 → c1 is D7’s. Both bear on whether the Snap occurs, not on its shape.', 'Status label: RETIRED in the ZP-E DA-1 insert, as stated above. AX-1 was a Candidate Theorem in ZP-C, with its gap identified: T-BUF Step 2, which is the occurrence commitment.', ])) @@ -222,10 +226,10 @@ def build(): ['Smooth embedding, MO-1, P1', 'Retired', 'Retired. Inconsistent with ZP-B.'], ['RP-1: Representation principle', 'Principle — explicit', 'Bridge between AX-B1 and probabilistic tools.'], ['RP-2: Branching measure on Q₂ \\ {0}', 'Principle — explicit', 'Canonical branching measure; representational commitment; required by T2 and L-INF.'], - ['CC-2: c₀ = ⊥', 'Conditional Claim', 'Modeling commitment — c₀ identified with ⊥ in semilattice. Parallel to CC-1 in ZP-A. Required by L-RUN Step 4.'], + ['ZP-C CC-2: c₀ = ⊥', 'Conditional Claim', 'Modeling commitment — c₀ identified with ⊥ in semilattice. Parallel to CC-1 in ZP-A. Required by L-RUN Step 4.'], ['D7: Machine configuration', 'Defined', 'Foundation for L-RUN and TQ-IH.'], ['L-RUN: Hardware Lemma', 'Derived — Lemma', 'Execution is a state change off ⊥. Derived from AX-B1 and D7.'], - ['TQ-IH: Test Question', 'Closed — Confirmed', 'No program can output ⊥ without a non-bottom intermediate configuration state. Proven by L-RUN. Externally confirmed April 2026 (R-TQ): domain-independent, requires no Turing-specific or Kolmogorov machinery.'], + ['TQ-IH: Test Question', 'Closed — Confirmed', 'No program can output ⊥ without a non-bottom intermediate configuration state, given D7 (every executing program passes through c1); L-RUN supplies c1 ≠ c0 (Lean: tq_ih). Externally confirmed April 2026 (R-TQ): domain-independent, requires no Turing-specific or Kolmogorov machinery.'], ['T-BUF: Buffer Overflow Theorem', 'Candidate Theorem', 'Conditional on execution: given that the configuration at P0 is executing (Step 2, the occurrence commitment), its state is non-bottom and is ε0. DA-1 consumes Step 2 and does not supply it.'], ['AX-1: Binary Snap Causality', 'Retired (was a Candidate Theorem)', 'Derivation pathway formalized. AX-1 retired in the ZP-E DA-1 insert: shape proved as T-SNAP; the snap occurs given the occurrence commitment and DA-1.']], [1.6*inch, 1.5*inch, 3.4*inch] @@ -244,7 +248,7 @@ def build(): ['R3: Smooth embedding retired', 'Valid — Retired; inconsistent with ZP-B'], ['D4: Discrete surprisal I(x)', 'Valid — pointwise on Q2 \\ {0}; branching measure stated'], ['RP-2: Branching measure', 'Valid — Principle; explicit representational commitment; canonical binary branching measure'], - ['CC-2: c0 = ⊥', 'Valid — Conditional Claim; modeling commitment; parallel to CC-1 in ZP-A; load-bearing for L-RUN Step 4'], + ['ZP-C CC-2: c0 = ⊥', 'Valid — Conditional Claim; modeling commitment; parallel to CC-1 in ZP-A; load-bearing for L-RUN Step 4'], ['D5: Difference operator DF', 'Valid — antisymmetric; no smoothness assumed'], ['D6: Circulation (extended)', 'Valid — finite and infinite cases both defined; finite conservation acknowledged'], ['T2: Non-conservation rebuilt', 'Valid — Derived; telescoping critique addressed; divergence at σ→0 established'], @@ -252,7 +256,7 @@ def build(): ['D7: Machine configuration', 'Valid — Defined; standard Turing model; no physics imported'], ['L-RUN: Hardware Lemma', 'Valid — Derived from AX-B1 and D7'], ['R4: Configuration vs. output independence', 'Valid — load-bearing distinction for TQ-IH and T-BUF'], - ['TQ-IH: Test question answered', 'Valid — Derived by L-RUN; no Kolmogorov machinery required'], + ['TQ-IH: Test question answered', 'Valid — Derived from L-RUN and D7 (Lean: tq_ih, c1 ≠ c0); no Kolmogorov machinery required'], ['T-BUF: Candidate Theorem', 'Candidate — conditional on execution; Step 1 defined (D1), Steps 3 and 4 derived in ZP-C; Step 2 is the occurrence commitment (ZP-E), not closed by DA-1'], ['R5: AX-1 status updated', 'Valid — AX-1 was a Candidate Theorem in ZP-C (prior Axiomatic status corrected); it is now retired: shape proved as T-SNAP (ZP-E); the snap occurs given the occurrence commitment and DA-1'], ['R-BRIDGE: K vs. 2-adic surprisal', 'Refuted (counterexample Sn = 2n, ZP-I § II.B); T-IZ never depended on it (it goes through t_iz_cauchy)']], diff --git a/scripts/build_zpc_companion.py b/scripts/build_zpc_companion.py index 14e47f93..25617c2f 100644 --- a/scripts/build_zpc_companion.py +++ b/scripts/build_zpc_companion.py @@ -1,5 +1,5 @@ """ -Build ZP-C Illustrated Companion (v2.11) +Build ZP-C Illustrated Companion (v2.14) """ import os @@ -177,7 +177,7 @@ def lrun_diagram(): strokeColor=COMP_BLUE, strokeWidth=1, strokeDashArray=[4, 3])) return d -VERSION = '2.11' +VERSION = '2.14' FIRST_RELEASED = 'April 2026' @@ -297,8 +297,11 @@ def footer_cb(canvas, doc): 'not about the incompressibility threshold P₀; the bridge between the two is refuted ' '(ZP-I § II.B).')) E.append(cbody( - 'This matters because unbounded surprisal means no finite external interpreter can hold ⊥ ' - 'as a static description. It does not show that anything is running. The step from ' + 'That is the depth chart: each depth has a finite surprisal, and there is no largest. The point chart ' + 'is the limit itself: 0 in ℚ₂, the one point in every ball of the chain centred at 0, where the 2-adic ' + 'additive valuation is infinite (padic_addVal_bot). The initial machine state c₀, ⊥ of the machine-state ' + 'type, corresponds to that point. From the two charts together the framework argues that no finite ' + 'external interpreter can hold ⊥ as a static description. That argument does not show that anything is running. The step from ' 'unbounded surprisal to executing is a bridge principle of its own, which the framework does ' 'not adopt (ZP-E, DA-1 Path 2). That the configuration reaching P₀ is a running machine\'s ' 'current configuration, and not an inert string, is what the framework\'s occurrence ' @@ -319,8 +322,8 @@ def footer_cb(canvas, doc): E.append(Paragraph('The Binary Snap Costs Exactly 1 Bit', CS['h1'])) E.append(cbody( - 'The Jensen-Shannon Divergence (JSD) between the bottom state ⊥, P = (1,0), and the minimum ' - 'non-bottom state ε0, Q = (0,1), is exactly 1 bit. These distributions are derived from AX-B1 - ' + 'The Jensen-Shannon Divergence (JSD) between the bottom state ⊥, P = (1,0), and ε0, ' + 'the atom above ⊥ of the two-state carrier, Q = (0,1), is exactly 1 bit. These distributions are derived from AX-B1 - ' 'not assumed. The Snap is the minimum informational event possible.')) E.append(jsd_diagram()) E.append(Paragraph( @@ -340,7 +343,7 @@ def footer_cb(canvas, doc): 'The identification of c₀ with the bottom state ⊥ is a modeling commitment (CC-2 in ' 'ZP-C) — a choice made explicit in the formal document, parallel to CC-1 in ZP-A ' '(which identifies the initial state S₀ with ⊥). It is not derived from the machine ' - 'definition; it is chosen. Labeling it CC-2 keeps that choice visible.')) + 'definition; it is chosen. Labeling it ZP-C CC-2 keeps that choice visible (ZP-A has its own CC-2, the Quine atom).')) # ── Page 3 ───────────────────────────────────────────────────────────────── E.append(lrun_diagram()) @@ -367,7 +370,7 @@ def footer_cb(canvas, doc): 'ZP-C adds explicit labels to two choices the framework makes. Labeling them is not ' 'a weakness — it is how the framework keeps track of what is proven versus what is chosen.')) E.append(cbody( - 'CC-2 (Modeling Commitment): The Turing machine initial configuration c₀ is identified ' + 'ZP-C CC-2 (Modeling Commitment): The Turing machine initial configuration c₀ is identified ' 'with ⊥. This is the same pattern as CC-1 in ZP-A, which identifies the ' 'initial state S₀ with ⊥. Neither identification is forced by the definitions — both are ' 'deliberate choices that make the multi-layer framework cohere.')) @@ -386,8 +389,9 @@ def footer_cb(canvas, doc): 'Key Result: T-SNAP — The Shape of the Binary Snap Is a Proven Theorem', 'The derivation chain for the shape: any live computation must execute a first instruction, ' 'and that execution is a non-bottom state (L-RUN). ' - 'No Turing machine program can produce any output without passing through such a non-bottom ' - 'intermediate state. And any state change off ⊥ is precisely the ' + 'So no executing Turing machine program can produce any output, ⊥ included, without passing through such a non-bottom ' + 'intermediate state: it passes through the first running configuration by the definition of execution, ' + 'and what is proved is that this configuration differs from c₀ (TQ-IH, c₁ ≠ c₀). And any state change off ⊥ is precisely the ' 'Binary Snap (ZP-A D2). ZP-E closes the chain as Theorem T-SNAP. ' 'The shape of the Binary Snap is no longer assumed — it is derived. ' 'That the Snap happens is a separate matter. The framework commits to instantiation occurring: ' diff --git a/scripts/build_zpd.py b/scripts/build_zpd.py index 172e5418..ce5c6401 100644 --- a/scripts/build_zpd.py +++ b/scripts/build_zpd.py @@ -1,11 +1,11 @@ """ -Build ZP-D: State Layer (Hilbert Space) (v1.19) +Build ZP-D: State Layer (Hilbert Space) (v1.21) """ import os from zp_utils import * -VERSION = '1.19' +VERSION = '1.21' FIRST_RELEASED = 'April 2026' def build(): @@ -49,7 +49,7 @@ def build(): E.append(label_box('Definition D1 — State Layer H', [ 'H = ℂn is a complex Hilbert space with orthonormal basis {e0, e1, …}.', 'The foundational minimum is n = 2, corresponding to the two ontological states of the framework: ' - '⊥ of OntologicalStates (mapped to e0) and ε0, the state off ⊥ of OntologicalStates (mapped to e1). ' + '⊥ of OntologicalStates (mapped to e0) and ε0 of OntologicalStates, the state off ⊥ there (mapped to e1; D2(ii) sends the point of the ε0 role in Q2 that it fixes to the same e1). ' 'These two orthogonal vectors express the binary existence/non-existence distinction that is the ' 'framework\'s central object. All further states are derived from this pair as joins in (L, ∨, ⊥) ' '— they require no additional foundational dimension.', @@ -73,7 +73,7 @@ def build(): E.append(label_box('Design Principle DP-1 — Orthogonality as the Representation of Clopen Separation', [ 'Clopen separation in Q2 (ZP-B T3: 0 is clopen-separated from all nonzero elements; clopen balls are mutually separated) is represented in H by orthogonality: at the chosen level k, points in different cells of the clopen partition Pk (D1) map to orthogonal vectors in H. Any two distinct points of Q2 lie in disjoint balls, so the same requirement stated over all disjoint balls would make the images of every two distinct points orthogonal; with nonzero images, as D2(v) requires, that is an orthogonal family indexed by all of Q2, which no finite-dimensional H holds (an orthonormal family in ℂn is finite; the example after dp1_orthogonality in ZeroParadox/State/StateSpace.lean). Without the nonzero premise the zero map would meet it. Pk is the finite partition it is stated over.', 'Motivation: Orthogonality in H is the natural algebraic analogue of topological separation. ⟨ei, ej⟩ = 0 for i ≠ j; two clopen balls are maximally distinct in the topological sense.', - 'Status: DESIGN PRINCIPLE — DP-1 is chosen, not derived. It is the natural and consistent choice, stated explicitly. T4 and T5 below depend on DP-1 as a premise.', + 'Status: DESIGN PRINCIPLE — DP-1 is chosen, not derived. It is the natural and consistent choice, stated explicitly. T4 and T5-b below depend on DP-1 as a premise.', ])) E.append(sp(4)) E.append(Paragraph('3.2 The Construction Target', S['h2'])) diff --git a/scripts/build_zpe.py b/scripts/build_zpe.py index fa9b6d8d..12421ce9 100644 --- a/scripts/build_zpe.py +++ b/scripts/build_zpe.py @@ -1,6 +1,6 @@ """ Zero Paradox — ZP-E: Bridge Document PDF Builder -Version 3.61 | October 2026 +Version 3.80 | November 2026 Follows all rules in pdf rendering standards: - DejaVu fonts only - Checkmark always wrapped in @@ -12,7 +12,7 @@ import os from zp_utils import * -VERSION = '3.61' +VERSION = '3.80' FIRST_RELEASED = 'April 2026' # ── Local overrides: ZP-E uses justified body text ──────────────────────────── @@ -49,8 +49,8 @@ def build(): 'DA-2 (Instantiation Succession), and ' 'DA-3 (Perspective-Relative Cardinality). 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. With DA-2 and the commitment C-DA2, the directed instantiation tree is formally licensed. With DA-3, ' + 'the occurrence commitment together with DA-1 (closed given DP-2). The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII). ' + 'tsnap_holds_but_nothing_moves shows T-SNAP does not carry that the snap occurs. With DA-2 and the commitment C-DA2, the directed instantiation tree is formally licensed. With DA-3, ' 'cardinality is shown to be position-dependent within the instantiation structure.')) E.append(body( 'Illustrated Companion: A paired ZP-E Illustrated Companion document provides accessible ' @@ -73,8 +73,8 @@ def build(): 'and in Q2 the norm value 0 is least on the image of the 2-adic norm in the reals (q2_norm_floor_isLeast), not as an order-bottom of Q2 itself, and {0} is the intersection of the nested clopen balls (fB_bottom_is_limit): ZP-A identifies ⊥, the bottom of the ZP-A semilattice, as the global minimum, below which the lattice\'s ordering ' 'relation cannot descend; ZP-B finds the 2-adic valuation undefined (or +∞) at 0 in Q2, where ' 'clopen separation is total — 0 and every nonzero element lie in disjoint clopen classes; ' - 'ZP-C finds surprisal unbounded above at the limit point 0 ∈ Q2 of its binary ball hierarchy, to which the initial configuration c0 corresponds (L-INF), so no finite ' - 'external description can contain it; ZP-D maps the state 0 of its state layer to a basis vector e0 orthogonal to ' + 'ZP-C finds surprisal unbounded in the depth of its binary ball hierarchy, each value finite (L-INF), and has the initial configuration c0 correspond to that hierarchy’s limit point 0 ∈ Q2; from the unbounded surprisal and that correspondence together, the framework argues that no finite ' + 'external description can contain c0; ZP-D maps the state 0 of its state layer to a basis vector e0 orthogonal to ' 'every other basis vector (dp1_orthogonality), so the snap is an orthogonal shift (t4_snap_orthogonal); ' 'orthogonality is symmetric and does not make the shift one-way, which comes from ZP-A and ZP-B ' '(T-SNAP Step 7). ' @@ -95,7 +95,7 @@ def build(): Paragraph('Formal Insert DA-1: Derived Proposition — Instantiation as Execution', S['h1']), Paragraph('DA-1 is a Derived Proposition: instantiation as execution, the first Lean ' 'formalization of DA-1 (axiom-free, conditional on DP-2, Snap.lean §VI), with ' - 'incompressibility read as self-description (ZP-C D1 + AIT) and CC-2/R3 as motivation for its precondition.', + 'incompressibility read as self-description (ZP-C D1 + AIT) and ZP-A CC-2/R3 as motivation for its precondition.', S['note']), hr(), ] @@ -103,18 +103,24 @@ def build(): E.append(Paragraph('I. The Gap at T-BUF Step 2', S['h2'])) E.append(body('The T-BUF chain from ZP-C states three results:')) E += [ - li('L-RUN: The transition c0 → c1 is a state change off ⊥. (ZP-C — Derived)'), - li('TQ-IH: No program outputs ⊥ without a non-bottom intermediate configuration state. (ZP-C — Derived by L-RUN)'), + li('L-RUN: The transition c0 → c1 is a state change off ⊥ of MachinePhase, which is c0 (l_run: c0 ≠ c1). (ZP-C — Derived)'), + li('TQ-IH: c1 ≠ c0, the same fact read from c1 (tq_ih). With ZP-C D7, by which every executing program passes through c1, it gives that no executing program outputs ⊥ without a non-bottom intermediate configuration state; that program-level reading is D7’s, not tq_ih’s. (ZP-C — Derived)'), li('T-BUF: At P0, the Binary Snap ⊥ → ε0 is a structural consequence of execution: an executing configuration is non-bottom, and that state is ε0 in the semilattice. (ZP-C — Candidate Theorem; its Step 2, that the configuration at P0 is executing, is the occurrence commitment, below, not a derived step)'), sp(4), ] E.append(body( 'T-BUF was labelled Candidate because Step 2 asserts that a configuration at P0 is a ' 'live machine state — that instantiation at P0 constitutes an execution event, not a static ' - 'description. ZP-C L-INF supplies one mathematical premise: surprisal is unbounded at ⊥, the ' - 'limit point 0 of the binary ball hierarchy, and not at P0 (the valuation-complexity bridge is ' - 'refuted, ZP-I § II.B); no finite external interpreter can hold ⊥ as a static description. ZP-A CC-2 ' - 'supplies a second, structural basis: ⊥ = {⊥} is a self-containing object with no external ' + 'description. The premise is stated in two charts. In the depth chart, ZP-C L-INF: ' + 'surprisal I(n) = n is unbounded in the ball-hierarchy depth n while each value is finite (l_inf). In the ' + 'point chart, at 0 of Q2, the one point in every ball B(0, 2−n) of the chain centred at 0 (fB_bottom_is_limit), ' + 'the 2-adic additive valuation is ⊤ (padic_addVal_bot, and only there, padic_addVal_eq_top_iff); the coincidence ' + 'of floor and ⊤ at one point is infinitude_forces_infinite_complexity, at the Q2 instance ' + 'q2InfinitudeFloor. ⊥ of MachinePhase, c0, corresponds to that ' + 'point (ZP-C L-INF). Neither chart locates the unboundedness at P0 (the valuation-complexity bridge is ' + 'refuted, ZP-I § II.B). From this premise the framework argues that no finite external interpreter can hold ' + '⊥ as a static description. ZP-A CC-2 ' + 'supplies a second, structural basis: ⊥, the lattice’s occupant of the Quine-atom role under a self-application map whose only fixed point is ⊥ (selfApp_quine_role_iff; every ZPSemilattice carries one, trivialSelfApp), is a self-containing object with no external ' 'interpreter by structure. Neither derives T-BUF Step 2: it is DP-2’s precondition, and it is what the ' 'occurrence commitment asserts (§ IV). DA-1 (§ IV below) consumes it and does not supply it: given it, ' 'D7 puts the machine at c1 (T-SNAP Step 3), and DP-2 and da1_minimal_path show that c0 and c1 ' @@ -180,8 +186,8 @@ def build(): 'c0 to c1, with the same output value before and after.', 'Scope of the claim: it holds given DP-2 and DP-2’s precondition, that the configuration reaching ' 'P0 is there in Sense B (§ II, a running machine’s current configuration) and not in ' - 'Sense A (an inert string). That precondition is not derived: it is what the occurrence commitment asserts ' - '(instantiation occurs), and Paths 1 to 3 below argue for it. ' + 'Sense A (an inert string). That precondition is not derived: it is what the occurrence commitment asserts, ' + 'and Paths 1 to 3 below argue for it. ' 'What follows from it is c0 → c1: by D7 a running machine has left c0, and its first ' 'running configuration is c1 (T-SNAP Step 3); DP-2 and da1_minimal_path (axiom-free) show that the two ' 'configurations are distinct while returning the same output value.', @@ -190,10 +196,12 @@ def build(): 'configuration (state c1) are distinct while returning the same output value, so the output value cannot ' 'show whether the step was taken. It takes no hypothesis and does not carry that the step is taken ' '(ZeroParadox/Order/SnapCannotBe.lean § I). The returned ⊥ occupies the bottom role again; reading it as a NEW null rather than the prior c0 is C-DA2, a modelling commitment. The axiom-free result is the role, not the novelty.', - 'Structural motivation (Paths 1 and 2 below): ZP-A CC-2 (⊥ = {⊥}) is a commitment: ZP-J t_exec_iff proves ' - '⊥ is the only occupant of the Quine-atom role, and that ⊥ of a ZPSemilattice is the AFA set Q = {Q}, its own singleton, is argued (R-AFA). ' + 'Structural motivation (Paths 1 and 2 below): the Quine atom (ZP-A CC-2): in an AFAStructure lattice ZP-J t_exec_iff proves ' + '⊥ is the only Quine atom (IsQuineAtom), and so the only occupant of the Quine-atom role with the AFA-built host’s membership as the step (quineAtomHost_quine_role_iff at afaStructure_isQuineAtomHost, [propext]); no equation makes ⊥ of a ZPSemilattice the AFA set Q = {Q}, and the commitment that remains concerns the host theory (R-AFA). ' 'ZP-A R3 reads off that a self-containing object admits no external interpreter position; that rules out an ' - 'external executor, not an inert ⊥. ZP-C L-INF gives ⊥ unbounded surprisal, exceeding the capacity of any ' + 'external executor, not an inert ⊥. Path 2 rests on two charts: ZP-C L-INF, surprisal unbounded in the ball-hierarchy depth with each value finite (l_inf), and ' + 'the 2-adic additive valuation ⊤ at 0 of Q2 (padic_addVal_bot), the point to which c0, ⊥ of MachinePhase, corresponds. ' + 'The framework argues from it that ⊥ exceeds the capacity of any ' 'finite interpreter, and the step from there to executing is a bridge principle of its own (Path 2), which the ' 'framework does not adopt and which is not the occurrence commitment. Neither derives the precondition.', ] @@ -206,28 +214,32 @@ def build(): 'MachinePhase) has fetched its first instruction. None derives it: ' 'Path 1 rules out an external executor, not an inert ⊥; Path 2 does not derive it: the step from unbounded surprisal to executing is a bridge ' 'principle of its own, which the framework does not adopt and which ' - 'is not the occurrence commitment; and Path 3 shows that executing is not derivable from incompressibility. ' + 'is not the occurrence commitment; and Path 3 rules out a shorter external generator, not an inert string. ' 'Given that precondition, the step c0 → c1 is D7’s (T-SNAP Step 3), and ' 'DP-2 + da1_minimal_path (axiom-free) show the two configurations distinct while returning the same output value.'), body('Path 1 — Structural (Self-Execution, ZP-J T-EXEC): Nothing exists outside the null space. ' '⊥ is prior to all differentiation — there is no external state, no prior cause, no position ' 'from which something else could execute ⊥. If ⊥ executes at all, the only possible ' - 'executor is ⊥ itself. A thing that executes itself contains itself, and the framework reads this as its own sole member: ' - '⊥ = {⊥}, so ⊥ ∈ ⊥. The argument is that this is forced by the impossibility of external ' + 'executor is ⊥ itself. A thing that executes itself contains itself, and the framework reads this as the Quine-atom ' + 'role (ZP-A CC-2): a point that steps to itself and to nothing else. The argument is that this is forced by the impossibility of external ' 'execution, which makes it more than a free choice and less than a theorem. ZP-A R3 states the structural consequence: a self-containing object admits no external ' - 'interpreter position. ZP-J T-EXEC proves that whatever fills the Quine-atom role is ⊥: IsQuineAtom(q) ↔ q = ⊥, ' + 'interpreter position. ZP-J T-EXEC proves that every Quine atom of an AFAStructure lattice is ⊥: IsQuineAtom(q) ↔ q = ⊥, ' 'proved axiom-free in Lean 4 (ZeroParadox.t_exec_iff). AFA (ZF + AFA) is a consistent ' - 'set-theoretic home for this structure, and the commitment is not the adoption of AFA ' - 'specifically: it is a set of requirements on the host theory — that the bottom is a ' - 'self-containing Quine atom (⊥ = {⊥}), and that this atom is unique — of ' - 'which AFA is the canonical example. ' - 'ZP-A CC-2 (⊥ = {⊥}) is a Forced Metatheoretic Commitment: on a lattice, T-EXEC proves that ' - 'whatever fills the Quine-atom role is ⊥ (axiom-free, given the field bot_self_mem); in AFA set theory Q = {Q} is a theorem (Aczel 1988, Example 1.3), and that the occupant of the framework’s ⊥ role, ⊥ of a ZPSemilattice, is that set Q is the argued metatheoretic step (see Remark R-AFA).'), + 'set-theoretic home for this structure, and adopting AFA is CC-2’s commitment; its Lean ' + 'abstraction is a set of requirements on the host theory (QuineAtomHost) — that the host has a ' + 'bottom that is its own only member, and that it is the only such set — which AFA meets, ' + 'and that any such host gives up Foundation is forced (quineAtomHost_not_wellFounded). ' + 'The Quine atom (ZP-A CC-2) is stated in the corpus’s shared vocabulary of step relations (ZeroParadox/Die.lean, the die; each carrier with its own step is a chart) as the role Motion.SelfOnlyAt, occupied or provably empty chart by chart: under a self-application map supplied by AbstractSelfApp, ' + '⊥ of the lattice is the only occupant (selfApp_quine_role_iff); in AFA set theory Q = {Q} is a theorem (Aczel 1988, Example 1.3); ' + 'with membership as the step, a host’s own bottom is the only occupant (quineAtomHost_quine_role_iff) and no well-founded set is one (zfset_quine_role_unoccupied). ' + 'No equation makes ⊥ of a ZPSemilattice the set Q, since it would be ill-typed; what stays a Forced Metatheoretic Commitment is the host theory (see Remark R-AFA).'), body('Path 2 — Informational (ZP-C L-INF): The surprisal I(n) = n at ball-hierarchy ' - 'depth n is unbounded — for any finite M, ∃ depth n with I(n) > M. ⊥ corresponds ' - 'to the limit point 0 ∈ Q2; its informational content exceeds every finite bound. ' - 'Any finite external interpreter can hold only a finite informational bound; ⊥ exceeds every ' - 'such bound. ' + 'depth n is unbounded — for any finite M, ∃ depth n with I(n) > M — while each value is finite (l_inf). ' + 'c0, ⊥ of MachinePhase, corresponds to the limit point 0 ∈ Q2, where the 2-adic additive ' + 'valuation is ⊤ (padic_addVal_bot). From these two charts the framework argues that ' + 'any finite external interpreter can hold only a finite informational bound, and no finite bound holds the whole depth ' + 'chain whose limit point c0 corresponds to: every bound M is exceeded at some depth n, though each I(n) is ' + 'finite (l_inf); surprisal, a function of the depth, takes no value at the limit point itself. ' 'Note: Path 2 is motivational context, not a formal path to the conclusion. The step ' '"exceeds every finite bound → therefore executing" is a bridge principle of its own, ' 'a missing principle and not a missing proof: the framework does not adopt it, and it is not the occurrence ' @@ -241,7 +253,8 @@ def build(): 'not claimed. This document states the question in the state chart, where a configuration is one ' 'fact and its running is a further fact; ZP-K Section III.II states it in two charts, the history ' 'chart reading a complete description of a run as the run, and denies neither.'), - body('Path 3 — Computational: Incompressibility as Self-Description (ZP-C D1 + standard AIT): ' + body('Path 3 — Computational: Incompressibility as Self-Description (ZP-C D1 + standard AIT; the two bounds used, ' + 'and their sources, are at T-SNAP Step 1): ' 'The preceding paths argue that ⊥ admits no external interpreter. This path argues from ' 'incompressibility toward the positive claim (executing). ' 'In the standard Turing model (D7), a machine configuration x is either executing or not executing, ' @@ -251,16 +264,18 @@ def build(): 'external program p (|p| < |x|) generates x when run, so x is a description awaiting a ' 'separate execution event by an external generator. ' '(A) and (B) are not exhaustive: (A) bundles not executing with having a shorter external generator. ' - 'At P0, read at the length n of c1 as in Step 1, K(c1|n)/|c1| = 1: c1 is algorithmically incompressible. ' + 'At P0, read at the length n of c1 as in Step 1, K(c1|n) ≥ |c1|: c1 is algorithmically incompressible, ' + 'and the ratio K(c1|n)/|c1| is 1 up to an additive constant in K (Step 1). ' 'No external program p exists with |p| < |c1| such that U(p, n) = c1. ' 'State (A) requires such a p, so state (A) is eliminated by the Kolmogorov condition. ' 'That rules out a shorter external generator, not an inert string: an incompressible string ' - 'written down and never run has no shorter generator and is not executing. So incompressibility ' - 'does not decide executing for configurations in general. ' - 'Note: so Path 3 shows that executing is not derivable from incompressibility. What it bears on is one event, not ' + 'written down and never run has no shorter generator and is not executing. So, for strings, ' + 'being incompressible does not imply executing: that string is a counterexample. The converse, ' + 'from executing to incompressible, is not claimed in this document. ' + 'Path 3 therefore does not derive executing from incompressibility. What it bears on is one event, not ' 'configurations in general: that the configuration reaching P0 is there in Sense B (§ II) ' - 'and not in Sense A. That is the precondition DP-2 takes, and it is what the occurrence commitment asserts ' - '(instantiation occurs), not a further premise. DA-1 does ' + 'and not in Sense A. That is the precondition DP-2 takes, and it is what the occurrence commitment asserts, ' + 'not a further premise. DA-1 does ' 'not supply it; DA-1 consumes it: given it, the step c0 → c1 is D7’s (T-SNAP Step 3).'), body('The formal grounding (DP-2, §III) and the three paths above operate at distinct levels, ' 'not as alternatives to one another. The conditional sits at the ' @@ -275,9 +290,9 @@ def build(): 'execute ⊥, so if ⊥ executes at all, the executor is ⊥ itself. That rules out an ' 'external executor, not an inert ⊥: in MachinePhase the bottom c0 is a Quine atom ' '(da1_closed_concrete), and the sequence that stays at c0 is a state sequence (Premises of ' - 'T-SNAP). The self-executor reading argues for ⊥ = {⊥} as ' - 'more than a free choice and less than a theorem (ZP-A CC-2, a Forced Metatheoretic Commitment); ' - 'ZP-J T-EXEC proves, axiom-free, that whatever fills the Quine-atom role is ⊥. Path 2 (informational) ' + 'T-SNAP). The self-executor reading argues for the Quine atom as ' + 'more than a free choice and less than a theorem (ZP-A CC-2, a Forced Metatheoretic Commitment about its host theory); ' + 'ZP-J T-EXEC proves, axiom-free, that every Quine atom (IsQuineAtom) of an AFAStructure lattice is ⊥. Path 2 (informational) ' 'provides motivational context — unbounded surprisal as a pointer toward why static holding is ' 'incoherent — but the bridge from unbounded surprisal (L-INF) to execution is not a derived claim: it is a bridge principle of its own, ' 'which the framework does not adopt and which is not the occurrence commitment. Path 3 (AIT) argues that incompressibility eliminates a ' @@ -295,9 +310,9 @@ def build(): 'Path 1 (structural, ZP-J T-EXEC + ZP-K): rules out an external executor, not an inert ⊥. Its Lean counterpart is da1_closed_concrete : IsQuineAtom(⊥ : MachinePhase), proved in Kleene.lean, which proves nothing computational. ' '(Under MachinePhase\'s selfMem x := x = ⊥, this reduces to (⊥ = ⊥) ∧ (∀ x, x = ⊥ ⇒ x = ⊥) — structural closure enforced by typeclass design, not a set-theoretic derivation from ZF+AFA. See R-K.0.) ' 'Path 2 (informational, L-INF): UNADOPTED BRIDGE PRINCIPLE — a missing principle, not a missing proof, distinct from the occurrence commitment and not a premise of the Snap; Path 2 does not derive the precondition. ' - 'Path 3 (computational, ZP-C D1 + AIT): bears on the precondition and shows that executing is not derivable from incompressibility — incompressibility rules out a shorter external generator, not an inert string; that the configuration reaching P0 is in Sense B and not Sense A is DP-2’s precondition, what the occurrence commitment asserts, which DA-1 consumes and does not derive. Its Lean counterpart (ZP-K) 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; da1_paths_unified carries it with Path 1 as a conjunction. ' + 'Path 3 (computational, ZP-C D1 + AIT): bears on the precondition and does not derive executing from incompressibility — incompressibility rules out a shorter external generator, not an inert string; that the configuration reaching P0 is in Sense B and not Sense A is DP-2’s precondition, what the occurrence commitment asserts, which DA-1 consumes and does not derive. Its Lean counterpart (ZP-K) 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; da1_paths_unified carries it with Path 1 as a conjunction. ' 'CC-1 (S0 = ⊥): restated — ZP-J cc1_derived with t_exec_iff makes a Quine-atom start and a ⊥ start the same condition (axiom-free, Lean) — and not forced: on a carrier with a second point a valid sequence starts elsewhere (ZeroParadox/Settheory/OntBridge.lean). ' - 'CC-2 (⊥ = {⊥}): ZP-J t_exec_iff proves ⊥ is the only occupant of the Quine-atom role (axiom-free); that ⊥ of a ZPSemilattice is the AFA set Q = {Q} is an argued metatheoretic commitment (see R-AFA). ' + 'The Quine atom (ZP-A CC-2): ZP-J t_exec_iff proves ⊥ is the only Quine atom (IsQuineAtom) of an AFAStructure lattice (axiom-free); with quineAtomHost_quine_role_iff at afaStructure_isQuineAtomHost ([propext]), it is therefore the only occupant of the Quine-atom role with that host’s membership as the step; no equation makes ⊥ of a ZPSemilattice the AFA set Q = {Q}, since it would be ill-typed, and the role is occupied or provably empty chart by chart; what stays a Forced Metatheoretic Commitment is the host theory (Foundation-freeness forced, AFA adopted; see R-AFA). ' 'DP-2 (§III) — explicit. ' 'T-SNAP’s premises, in its Lean form and in its prose argument, are stated under Premises of T-SNAP (DA-1 insert, § V). ' 'AIT (Kolmogorov complexity) outside Lean scope; the Kleene structure is its in-scope counterpart, carried as a KleeneStructure requirement (botCode_is_quine), not a proof of the AIT claim.'), @@ -316,7 +331,7 @@ def build(): E += [ sp(4), body('Premises of T-SNAP, in two readings. Both readings are true, and neither replaces the other. ' - 'In Lean, two of the premises, CC-1 and occurrence at the first step, are the hypotheses of t_snap_given, named in (i).'), + 'In Lean, two of the premises, CC-1 and occurrence at the first transition, are the hypotheses of t_snap_given, named in (i).'), li('(i) Lean form: the shape. t_snap_derived : c₀ ≠ c₁ ∧ c₁ ≠ c₀ ∧ ' 'join c₀ c₁ = c₁ (ZeroParadox/Order/Snap.lean) takes no hypotheses, and #print axioms reports no axioms. ' 'It is a fact about the fixed two-state type MachinePhase, with the initial phase c₀ as its bottom element ⊥ and the running phase c₁ above it: ' @@ -324,7 +339,7 @@ def build(): 'built into the choice of that type, and the start at ⊥ into the statement’s choice of c₀. It fixes the SHAPE of the transition, not that one occurs: tsnap_holds_but_nothing_moves proves ' 'the same statement in a dynamics where every phase is a fixed point. ' 'Two of the premises as hypotheses: t_snap_given (same file) holds over any join-semilattice with bottom, taking ' - 'S₀ = ⊥ (hcc1, CC-1) and S₁ ≠ S₀ (hocc, occurrence at the first step: the step at index 1 is taken) ' + 'S₀ = ⊥ (hcc1, CC-1) and S₁ ≠ S₀ (hocc, occurrence at the first transition: the step at index 1 is taken) ' 'and giving the same shape at S₀, S₁. Its two inequalities restate hocc; only the join conjunct is derived, from A4. ' 't_snap_derived’s statement is its MachinePhase instance at the sequence c₀, c₁, c₁, …, where hcc1 holds by rfl ' 'and hocc reduces to c₁ ≠ c₀. MachinePhase does not discharge occurrence: the sequence that stays at c₀ is a ' @@ -334,7 +349,7 @@ def build(): li('(ii) Prose argument: the shape, then the occurrence. The seven steps below read that shape as a statement about the ' 'framework’s own state sequence. That reading uses commitments, among them AX-B1 (binary existence, ZP-B, the framework’s one ' 'substantive modelling commitment) at Step 4, and CC-1 (S0 = ⊥, a ZP-A Conditional Claim) for the start at ⊥ in Steps 4 and 6. ' - 'That the transition OCCURS rests further on the occurrence commitment: instantiation occurs, in Sense B (§ II), so the configuration ' + 'That the transition OCCURS rests further on the occurrence commitment, in its execution chart: instantiation occurs, in Sense B (§ II), so the configuration ' 'reaching P₀ is a running machine’s current configuration and not an inert string. That is Step 2, and it is DP-2’s precondition. ' 'DA-1 does not supply Step 2; it consumes it. DA-1 is closed only given DP-2: once DP-2’s precondition is granted, ' 'c₀ → c₁ is D7’s (Step 3), and DP-2 with da1_minimal_path shows the two configurations distinct while returning ' @@ -353,25 +368,25 @@ def build(): 'What follows is the informal motivation for the modelling choices that let that term ' 'be read as a statement about the framework’s own state sequence.'), sp(4), - li('Step 1 — P0 identifies the incompressibility threshold. ZP-C § I takes x to be a binary string of length n, so n = |x| and K(x|n)/n = K(x|n)/|x|. ZP-C D1 defines P0 as the limit of K(x|n)/n as n grows, the algorithmic entropy rate of x, and the threshold is that rate at its maximum, 1. The steps below use the finite-string form ZP-C also uses (§ I), not the limit: K(x|n)/|x| = 1 for one configuration string x of length n, so x is algorithmically incompressible at its length. (ZP-C § I, D1)'), - li('Step 2 — The configuration reaching P0 is in Sense B, not Sense A (the occurrence commitment): At P0, K(c1|n)/|c1| = 1 (Step 1 at x = c1) — c1 is incompressible, so no shorter external generator exists. That rules out a shorter external generator, not an inert string; that the configuration reaching P0 is a running machine’s current configuration (Sense B) and not an inert string (Sense A) is what the occurrence commitment asserts, not a derived step. Arguments for it, none deriving it: ⊥ = {⊥} (ZP-A CC-2/R3); unbounded surprisal (ZP-C L-INF); DA-1 Path 3. (The occurrence commitment, whose content is DP-2’s precondition. DA-1, closed given DP-2, consumes this step and does not supply it)'), + li('Step 1 — P0 identifies the incompressibility threshold. ZP-C § I takes x to be a binary string of length n, so n = |x| and K(x|n)/n = K(x|n)/|x|. ZP-C D1 defines P0 as the limit of K(x|n)/n as n grows, the algorithmic entropy rate of x, and the threshold is that rate at its maximum, 1. The steps below use the finite-string form ZP-C also uses (ZP-C Remark R-BRIDGE and T-BUF Step 1), not the limit: one configuration string x of length n with K(x|n) ≥ |x|, so x is algorithmically incompressible at its length. Since K(x|n) ≤ |x| + c for every x, with c depending only on the universal machine U, the ratio K(x|n)/|x| is then 1 up to an additive constant in K, not necessarily exactly 1. K here is plain conditional complexity, which the sources below write C. That some x of each length n has K(x|n) ≥ n is a counting argument (Buhrman, Jiang, Li and Vitányi 1998, arXiv:cs/9809060, § 3); the upper bound K(x) ≤ |x| + O(1) is Shen 2015 (arXiv:1504.04955, Theorem 2(a)), and it holds given n by the same paper’s Theorem 10(a), C(x|y) ≤ C(x) + O(1). (ZP-C § I, D1)'), + li('Step 2 — The configuration reaching P0 is in Sense B, not Sense A (the occurrence commitment): At P0, K(c1|n) ≥ |c1| (Step 1 at x = c1) — c1 is incompressible, so no shorter external generator exists. That rules out a shorter external generator, not an inert string; that the configuration reaching P0 is a running machine’s current configuration (Sense B) and not an inert string (Sense A) is what the occurrence commitment asserts, not a derived step. Arguments for it, none deriving it: the Quine atom (ZP-A CC-2/R3); unbounded surprisal (ZP-C L-INF); DA-1 Path 3. (The occurrence commitment, whose content is DP-2’s precondition. DA-1, closed given DP-2, consumes this step and does not supply it)'), li('Step 3 — Any instantiated execution passes through c1. (ZP-C D7 — definitional; c1 is the first running configuration)'), li('Step 4 — c1 ≠ ⊥. (ZP-C L-RUN — Derived; c1 has gained execution context not present in c0 = ⊥; by AX-B1 this is a distinct, non-bottom state)'), - li('Step 5 — No program that executes produces only ⊥ configuration states. (ZP-C TQ-IH — Derived; execution trace τ(p) contains c1 for any executing program p)'), + li('Step 5 — No program that executes produces only ⊥ configuration states. (ZP-C TQ-IH, c1 ≠ c0, read with Step 3’s D7: the execution trace τ(p) contains c1 for any executing program p)'), li('Step 6 — In (L, ∨, ⊥), c1 is an element strictly above ⊥. By ZP-A D2, the transition ⊥ → c1 is a valid state transition: c1 = ⊥ ∨ ε0 for some ε0 ∈ L with ε0 > ⊥. This transition is the Binary Snap.'), li('Step 7 — The transition is irreversible: algebraically, no join from c1 returns to ⊥ (t_snap_irreversible, the no-return form of ZP-A R1; that the signature has no subtraction operator makes an inverse inexpressible, which is a different fact); topologically by ZP-B C3 (no continuous return path to 0 in Q2). These two grounds are sufficient. Conceptual correspondence: ZP-G AX-G2 (hom(X, 0) = ∅ for X ≠ 0) expresses the same irreversibility in categorical language — ZP-G is downstream of ZP-E and is not a formal dependency of this proof.'), sp(4), body('Conclusion: The Binary Snap is a derived consequence, given the commitments under Premises of 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. ✓'), + 'together with DA-1 (closed given DP-2). tsnap_holds_but_nothing_moves shows T-SNAP does not carry it. ✓'), derived('Status: DERIVED — Cross-Framework. Premises: in two readings, under Premises of T-SNAP above; the Lean form fixes the shape ' - 'with no hypotheses, t_snap_given takes CC-1 and occurrence at the first step as hypotheses, and the prose argument’s shape and its ' + 'with no hypotheses, t_snap_given takes CC-1 and occurrence at the first transition as hypotheses, and the prose argument’s shape and its ' 'occurrence rest on commitments, among them those named there. ' 'Dependencies cited in the steps: ZP-C D1, D7, L-RUN, TQ-IH; ZP-B C3; ZP-A D2, R1; ZP-E DA-1; ZP-J T-EXEC. ' 'CC-1 (S₀ = ⊥): restated — a Quine-atom start and a ⊥ start are one condition (ZP-J cc1_derived, t_exec_iff; axiom-free) — and not forced, since on a carrier with a second point a valid sequence starts elsewhere. ' - 'CC-2 (⊥ = {⊥}): ZP-J t_exec_iff proves ⊥ is the only occupant of the Quine-atom role (axiom-free); that ⊥ of a ZPSemilattice is the AFA set Q = {Q} is argued metatheoretically (see R-AFA). ' - 'Both remain commitments: CC-1 is a Conditional Claim, expressed through the Quine-atom role and not removed by it; CC-2 is a Forced Metatheoretic Commitment. ' + 'The Quine atom (ZP-A CC-2): ZP-J t_exec_iff proves ⊥ is the only Quine atom (IsQuineAtom) of an AFAStructure lattice (axiom-free); no equation makes ⊥ of a ZPSemilattice the AFA set Q = {Q}, since it would be ill-typed (see R-AFA). ' + 'Both remain commitments: CC-1 is a Conditional Claim, expressed through the Quine-atom role and not removed by it; ZP-A CC-2 is a Forced Metatheoretic Commitment about the host theory. ' 'Conceptual correspondence only: ZP-G AX-G2 (downstream of ZP-E; not a formal dependency).'), ] @@ -389,8 +404,10 @@ def build(): 'with ε₀, the proof-theoretic ordinal of Peano Arithmetic.', 'The ordinal ε₀ (Cantor 1897, Math. Ann. 49, §20, Satz B). In ordinal arithmetic, ε₀ is the smallest fixed ' 'point of the map α → ωα: equivalently, ε₀ = sup{ω, ωω, ' - 'ωωω, ...}. No finite ω-tower reaches it. Gentzen ' - 'proved in 1936 that transfinite induction up to ε₀ is sufficient to prove Con(PA). ' + 'ωωω, ...}. No finite ω-tower reaches it. Gentzen (1936), ' + 'in the form stated by Rathjen (arXiv:1405.4484, Theorem 2.8(i), p. 10): primitive recursive ' + 'arithmetic, PRA, proves the implication from PRWO(ε₀) (that no primitive recursive ' + 'sequence of ordinals below ε₀ descends forever) to Con(PA). ' 'Necessity — that no smaller ordinal would do — is the other direction, and it rests on ' 'different ground: the provability in PA of transfinite induction at every ordinal ' 'strictly below ε₀, which Gentzen reports as already known, crediting Hilbert-Bernays, ' @@ -399,7 +416,7 @@ def build(): 'ordinal ε₀ is therefore the minimum threshold at which finite arithmetic exhausts its own ' 'generative capacity.', 'The structural analogy. ZP\'s ε₀ occupies an analogous position in the state ' - 'lattice. At P₀, c₁ satisfies K(c₁|n)/|c₁| = 1, the finite-string form of T-SNAP Step 1: it is algorithmically ' + 'lattice. At P₀, c₁ satisfies K(c₁|n) ≥ |c₁|, the finite-string form of T-SNAP Step 1: it is algorithmically ' 'incompressible. Just as the ' 'Cantor ε₀ cannot be reached from 0 by any finite ω-tower, ZP\'s ε₀ is reached from ⊥ ' 'by the snap, and no program shorter than c₁ outputs c₁ given its length n. Both name a structurally analogous object: a ' @@ -425,42 +442,49 @@ def build(): bridge_box( 'Remark R-AFA — Why Foundation is Ruled Out; Non-Well-Foundedness Forced, AFA Adopted', [ - 'CC-2 — the identification of ⊥ with the Quine atom ⊥ = {⊥} — ' - 'is a set-theoretic step beyond ZP-A\'s algebra: it is not derived from A1–A4. What it ' - 'entails is nonetheless not arbitrary, and the two halves separate. The membership structure ' - 'the framework\'s bottom must have forces a non-well-founded host, which is what rules ' - 'ZF + Foundation out. Which non-well-founded axiom to adopt is a further step that the ' + 'The Quine atom (ZP-A CC-2) is a role, a point that steps to itself and to nothing else, and no ' + 'equation identifies ⊥ of a ZPSemilattice with a set Q = {Q}: it would be ill-typed ' + '(Path 1 above lists the occupancy theorems chart by chart). What is a set-theoretic step ' + 'beyond ZP-A\'s algebra, not derived from A1–A4, is the choice of a host theory in which ' + 'a set occupies the role under membership. That choice is nonetheless not arbitrary, and its ' + 'two halves separate. Occupying the role under membership forces a non-well-founded ' + 'host, which is what rules ZF + Foundation out. Which non-well-founded axiom to adopt is a further step that the ' 'forcing does not take: ZF + AFA is the host this framework adopts, as the canonical theory ' 'meeting the requirements, not the one theory the bottom selects.', - 'Foundation rules out the bottom (structural). The framework\'s bottom is the Quine ' - 'atom ⊥ = {⊥}: it is a member of itself, ⊥ ∈ ⊥. ZF + Foundation ' + 'Foundation leaves the role unoccupied (structural). With membership as the step, a set ' + 'occupying the Quine-atom role is its own only member, x = {x} (zfset_selfOnlyAt_mem_iff), so it ' + 'is a member of itself, x ∈ x. ZF + Foundation ' '(the Axiom of Regularity) forbids exactly this — under a well-founded membership relation no ' 'set lies on a membership cycle of any length, so in particular no set is a member of itself. ' 'This is a theorem of ZF + Foundation, not a framework-specific stipulation; it is ' 'machine-checked here as no_quine_atom / no_membership_cycle ' - '(ZeroParadox/Settheory/Wall.lean, footprint [propext, Quot.sound], choice-free). A ' - 'Foundation-respecting universe therefore cannot host ⊥ at all.', - 'The framework\'s readings of ⊥ support the premise that ⊥ is circular; the ' + '(ZeroParadox/Settheory/Wall.lean, footprint [propext, Quot.sound], choice-free), and in the ' + 'die as zfset_quine_role_unoccupied. With membership as the step, a Foundation-respecting ' + 'universe therefore has no occupant of the role at all (under any well-founded membership: the ' + 'well-founded example in ZeroParadox/Settheory/QuineDichotomy.lean, from wf_no_selfloop); under a ' + 'self-application step the role is occupied in every ZPSemilattice, Foundation or not ' + '(selfApp_quine_role_iff, with trivialSelfApp supplying the map), so the exclusion concerns the membership chart.', + 'The framework\'s readings of ⊥ support the premise that the role is occupied under membership; the ' 'exclusion itself is a theorem. R3 ' - '(ZP-A) — ⊥ = {⊥} has no describer position external to itself — and ' + '(ZP-A) — an occupant of the Quine-atom role has no describer position external to itself — and ' 'L-INF (ZP-C) — the 2-adic surprisal I(n) = n is unbounded, so no finite interpreter ' 'can hold ⊥ — each describe an object with no external vantage and unbounded ' 'self-referential depth. That is exactly the profile of a non-well-founded, self-membered ' - 'set: the two readings motivate why ⊥ must be the circular object Foundation excludes, ' + 'set: the two readings motivate why the role must be occupied under membership, which Foundation excludes, ' 'rather than serving as independent proofs of the exclusion.', - 'Non-well-foundedness is forced; AFA is the canonical replacement. The membership ' - 'structure of ⊥ = {⊥} is circular ' - '(⊥ ∈ ⊥ ∈ ⊥ ∈ …), so ⊥ can live only in a ' + 'Non-well-foundedness is forced; AFA is the canonical replacement. An occupant under ' + 'membership lies on a membership loop ' + '(x ∈ x ∈ x ∈ …), so the role can be occupied only in a ' 'non-well-founded ' - 'metatheory. That much is forced; the particular axiom is not. Aczel records four ' + 'metatheory (wf_no_selfloop; for a host, quineAtomHost_not_wellFounded, below). That much is forced; the particular axiom is not. Aczel records four ' 'anti-foundation axioms, and AFA, FAFA and SAFA each admit exactly one ' 'Quine atom — his own term is a reflexive set — while being pairwise ' 'incompatible (Aczel 1988, Corollary 4.28; Appendix A, p. 108). Supplying exactly one ' 'therefore does not single AFA out, so AFA is ' 'adopted as the canonical witness rather than selected by the membership structure.', 'What is machine-checked (the requirements framework). The question of which host ' - 'theory can admit ⊥ is reduced to two requirements: (Y\') a Quine atom ' - '⊥ = {⊥} and (Z\') its uniqueness among reflexive sets, x = {x}, the ' + 'theory can admit an occupant of the role is reduced to two requirements: (Y\') a Quine ' + 'atom, a host bottom b = {b}, and (Z\') its uniqueness among reflexive sets, x = {x}, the ' 'fields bot_mem_iff and reflexive_unique of the typeclass QuineAtomHost ' '(ZeroParadox/Settheory/QuineHost.lean). AFA allows at most one solution of x = {x} (Aczel ' '1988, p. 19), and decorates a* = {a, a*} for every set a (Examples 1.5–1.6, ' @@ -471,7 +495,7 @@ def build(): 'The AFA and Boffa sorts are cited facts about those theories, each illustrated by a finite ' 'toy (QuineHost.lean § VII; boffa_fails_reflexive_unique). Realizability carries no ' 'information: every inhabited carrier meets QuineAtomHost (trivialQuineAtomHost). The ' - 'typeclass QuineHost (fields bot_selfMem, ⊥ ∈ ⊥, and selfMem_unique, no ' + 'typeclass QuineHost (fields bot_selfMem, b ∈ b for its bottom b, and selfMem_unique, no ' 'other element self-membered) is a different requirement, incomparable with QuineAtomHost ' '(QuineHost.lean § VII); AFA\'s membership fails its second field, since ' '0* ∈ 0*. What stays argued is which requirements to demand, below.', @@ -501,16 +525,18 @@ def build(): 'Boffa\'s axiom itself.', 'What remains — a narrow Forced Metatheoretic Commitment. With the forcing ' 'proved, one step is not a theorem: that a Quine atom and its uniqueness are ' - 'the right two requirements to demand — the commitment to ⊥ = {⊥} ' - 'as the minimal option consistent with A4\'s additive-identity role (it has exactly one ' + 'the right two requirements to demand — the commitment to a host bottom b = {b} ' + 'as the minimal option (it has exactly one ' 'member, itself, and introduces no internal differentiation; any extension ' - '⊥ = {⊥, x} with x ≠ ⊥ would add members carrying their own ' - 'membership chains). This is a Forced Metatheoretic Commitment — stronger than ' - 'a free choice, weaker than a theorem — not a Conditional Claim; the set-membership ' - 'face ⊥ ∈ ⊥ stays metatheoretic, while the occupant of the Quine-atom role ' - 'is machine-checked to be ⊥ (t_exec, ZeroParadox/Settheory/SetTheoryAFA.lean, ' - 'axiom-free, given the field bot_self_mem). The named falsifier is correspondingly narrow: a differently-motivated ' - 'requirement set that hosts ⊥ without demanding a unique Quine atom would reopen this ' + 'b = {b, x} with x ≠ b would add members carrying their own ' + 'membership chains). This is a Forced Metatheoretic Commitment about the host theory ' + '— stronger than a free choice, weaker than a theorem — not a Conditional Claim. ' + 'It is not an equation between ⊥ of a ZPSemilattice and a set, which would be ill-typed: ' + 'the Quine-atom role’s occupancy is machine-checked chart by chart (Path 1 above), and with the ' + 'membership of the host built from an AFAStructure lattice as the step its only occupant is ⊥ ' + '(quineAtomHost_quine_role_iff at afaStructure_isQuineAtomHost; in the IsQuineAtom form, t_exec, ' + 'ZeroParadox/Settheory/SetTheoryAFA.lean, axiom-free, given the field bot_self_mem). The named falsifier is correspondingly narrow: a differently-motivated ' + 'requirement set that hosts the role without demanding a unique Quine atom would reopen this ' 'choice — it would not touch the forcing, which is proved.', ] ), @@ -521,16 +547,16 @@ def build(): E.append(body( 'Remark R-DA1: AX-1 is retired, and its content was split in two. Results in ZP-E that ' 'previously depended on AX-1 as an axiom now depend on T-SNAP, a derived theorem, for the shape, and, wherever they use that the Snap happens, on the ' - 'occurrence commitment (instantiation occurs) together with DA-1. T5 (Iterative Forcing Theorem) depended on AX-1 and is restated below. T4 (Unified Snap ' + 'occurrence commitment together with DA-1. T5 (Iterative Forcing Theorem) depended on AX-1 and is restated below. T4 (Unified Snap ' 'Description) carried AX-1 as an axiom label on the causality component — that label is upgraded ' 'to Derived — T-SNAP for the shape, with occurrence still a commitment. DA-1 is additionally upgraded from Design Principle to Derived ' - 'Proposition, closed given DP-2 (da1_minimal_path); ZP-A CC-2 (⊥ = {⊥}), R3 and ZP-C L-INF argue for its precondition, which is what the occurrence commitment asserts, and none derives it. ' + 'Proposition, closed given DP-2 (da1_minimal_path); ZP-A CC-2 (the Quine atom), R3 and ZP-C L-INF argue for its precondition, which is what the occurrence commitment asserts, and none derives it. ' 'The intentional axioms of the system are now: AX-B1 (binary existence), ' 'AX-G1 (initial object), AX-G2 (source asymmetry). AX-1 is retired: its shape is Theorem T-SNAP, and the occurrence ' 'commitment is not on this list because it is a commitment, not a named axiom. ' 'Additional structural commitments are carried as typeclass fields: A4 (bot_join, ' 'ZPSemilattice — standard semilattice algebra), AFAStructure.quine_unique and bot_self_mem ' - '(the Quine-atom role), KleeneStructure.botCode_is_quine (computational closure). Like named axioms these are ' + '(the Quine-atom role), KleeneStructure.botCode_is_quine (the bottom code is a computational quine, which a constant code meets). Like named axioms these are ' 'assumptions, carried as hypotheses by every theorem that uses them; #print axioms does not surface typeclass fields. ' 'Unlike named axioms they can be cheap to meet: every ZP-A lattice supplies AFAStructure trivially, and ' 'KleeneStructure’s botCode_is_quine is met by a constant code (the computable KleeneStructure ' @@ -581,23 +607,23 @@ def build(): hr(), ] - E.append(Paragraph('I. The Gap DA-2 Closes', S['h2'])) + E.append(Paragraph('I. The Gap DA-2 Addresses', S['h2'])) E.append(body('Given the premises stated under Premises of T-SNAP (DA-1 insert, § V), DA-1 and T-SNAP give the Binary Snap on reaching P0 ' 'within an instantiation. After DA-1 the CC-1 and terminal-state questions remain open; ZP-B R1’s scope and the occurrence fence stand beside them:')) E += [ li('CC-1 (ZP-A) posits S0 = ⊥ — not derivable from A1–A4 alone (ZP-J restates it as ' 'an equivalence with starting at a Quine atom, cc1_derived and t_exec_iff, and does not force it). This leaves open whether ⊥ is unique across all instantiations or whether ' 'each instantiation carries its own ⊥.'), - li('ZP-B R1 (Universal Structure vs. Instantiation-Contingent Parameters) keeps the structural role of ε0 of ' - 'Q2 universal; what is contingent per instantiation is the rung v of ZP-B D5 and its threshold ' - '2−v. R1 keeps AX-B1, whose 0 is ⊥ of OntologicalStates, a ZP-A semilattice, ' - 'universal as structure.'), - li('Occurrence fence. T-SNAP fixes the SHAPE of each step. It does not establish that any step is taken: tsnap_holds_but_nothing_moves exhibits a model in which T-SNAP holds and nothing moves. Every "fires" below narrates the commitment that instantiation occurs, not a consequence of the theorem.'), li('Whether T-SNAP’s shape applies at the terminal state of instantiation In, read as the ' 'starting ⊥ of In+1. That needs the terminal state connected to a ⊥ role-occupant. DA-2 provides ' 'the role half only: what plays the ⊥ role of a ZP-A semilattice is that ⊥ (da2_bottom_characterization). ' 'Reading it as a new ⊥ is C-DA2, a commitment. Nothing here places that terminal state at P0: the ' 'valuation-complexity bridge offered for it is refuted (ZP-I § II.B).'), + li('ZP-B R1 (Universal Structure vs. Instantiation-Contingent Parameters) keeps the structural role of ε0 of ' + 'Q2 universal; what is contingent per instantiation is the rung v of ZP-B D5 and its threshold ' + '2−v. R1 keeps AX-B1, whose 0 is ⊥ of OntologicalStates, a ZP-A semilattice, ' + 'universal as structure.'), + li('Occurrence fence. T-SNAP fixes the SHAPE of each step. It does not establish that any step is taken: tsnap_holds_but_nothing_moves exhibits a model in which T-SNAP holds and nothing moves. Every "fires" below narrates the occurrence commitment, not a consequence of the theorem.'), sp(4), ] @@ -680,11 +706,11 @@ def build(): 'successor instantiations branching from it.'), li('Each edge within an instantiation is a step in a monotone state sequence (ZP-A T3). Edges are irreversible (ZP-B C3).'), li('Branching at each node: every distinct outbound vector from the terminal state of In is a ' - 'valid ε0 for a distinct In+1. T-SNAP does not select among branches. Because ⊥ = {⊥} ' - '(ZP-A CC-2) is the single self-containing ⊥ with no internal differentiation, every ' + 'valid ε0 for a distinct In+1. T-SNAP does not select among branches. Because ⊥, the only ' + 'occupant of the Quine-atom role in the lattice under a self-application map (ZP-A CC-2; selfApp_quine_role_iff), has no internal differentiation, every ' 'ε0 that represents a first differentiation in any direction is a valid outcome. ' - 'The work here is done by the undifferentiated ⊥ of CC-2, not by T-SNAP: given that ' - 'instantiation occurs, no direction is privileged, so the structure branches rather than ' + 'The work here is done by the undifferentiated ⊥ of ZP-A CC-2, not by T-SNAP: given the ' + 'occurrence commitment, no direction is privileged, so the structure branches rather than ' 'threading a line. T-SNAP fixes the shape of each step; it does not supply the occurrence.'), li('No back edges: C-DA2 COMMITS to no instantiation reaching the ⊥ of any ancestor. This is the commitment, not a theorem - in the 2-adic chart the arc returns to the same 0 (snap_arc_z2_loop).'), sp(4), @@ -697,10 +723,10 @@ def build(): 'NEW bottom is a further commitment (C-DA2); ' 'in the 2-adic realization the arc tends back to the same 0 of ℤ2 (snap_arc_z2_loop). Nothing ' 'here places that terminal state at P0 (ZP-I § II.B). No new axiom is required. The multiverse is not the claim that ' - 'T-SNAP fires in all directions simultaneously: it is the claim that ⊥ = {⊥} (ZP-A CC-2) has no ' + 'T-SNAP fires in all directions simultaneously: it is the claim that ⊥, the lattice’s occupant of the Quine-atom role under a self-application map (ZP-A CC-2), has no ' 'internal differentiation and therefore no preferred direction for ε0. The multiverse of ' 'instantiations is the full set of all minimal differentiations available from the single ' - 'self-containing ⊥ — a structural consequence of CC-2 + T-SNAP + DA-2 jointly, given C-DA2.')) + 'self-containing ⊥ — a structural consequence of ZP-A CC-2 + T-SNAP + DA-2 jointly, given C-DA2.')) E.append(Paragraph('VI. The Zero Paradox Iterated', S['h2'])) @@ -724,14 +750,14 @@ def build(): E += [ body('Structural Implication: Branching Tree Structure. T-SNAP fixes the SHAPE of the Binary Snap — ' 'that if ⊥ transitions it goes to some ε₀ > ⊥, and that the step is one-way. It does not ' - 'establish that the transition is taken: that the Snap occurs follows from the occurrence commitment (instantiation occurs) ' + 'establish that the transition is taken: that the Snap occurs follows from the occurrence commitment ' 'together with DA-1 (closed given DP-2), and the NO-GO ' 'gauge tsnap_holds_but_nothing_moves exhibits a model in which T-SNAP holds and nothing moves. ' 'DA-2 supplies the role half only: a terminal state that plays the ⊥ role in a successor ' 'instantiation’s semilattice is that ⊥. That it does is a commitment of its own (occupancy); that it ' 'is a NEW ⊥, so that the instantiations form a forward-directed branching tree, is the further commitment ' 'C-DA2. The branching comes ' - 'from CC-2\'s undifferentiated ⊥ and the succession from DA-2 with C-DA2, all conditional on instantiation occurring. Note: T-SNAP alone does ' + 'from ZP-A CC-2\'s undifferentiated ⊥ and the succession from DA-2 with C-DA2, all conditional on instantiation occurring. Note: T-SNAP alone does ' 'not establish that it fires on all outbound vectors simultaneously — that universality is the ' 'scope of DA-2, not a direct consequence of the snap theorem itself.'), body('Monotonicity and Path Irrecoverability. Within an instantiation, state sequences are monotone — no state ' @@ -840,10 +866,10 @@ def build(): ['AX-1: Binary Snap Causality', 'RETIRED — shape proved as T-SNAP; the snap occurs given the occurrence commitment and DA-1', 'Its content was split in two: the shape of the Snap is proved, as Theorem T-SNAP (from L-RUN, TQ-IH and the bottom law, with no Lean axioms), ' - 'and that the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). ' + 'and that the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). ' 'Premises under Premises of T-SNAP (DA-1 insert, § V); given CC-1, the first-step form of the Snap occurring is the hypothesis hocc of t_snap_given.'], ['DA-1: Derived Proposition (DP-2 formal grounding)', - 'CLOSED given DP-2 — DP-2 (formal core); CC-2 + L-INF + AIT argue for the precondition, none deriving it', + 'CLOSED given DP-2 — DP-2 (formal core); ZP-A CC-2 + L-INF + AIT argue for the precondition, none deriving it', 'Primary formal grounding: DP-2 (TrackedOutput, Snap.lean §VI) — da1_minimal_path proved ' 'axiom-free. Given the precondition, the machine moves from c0 to c1 by D7 (T-SNAP Step 3); da1_minimal_path shows ' 'the two configurations return the same output value, so the output value cannot show whether execution occurred. ' @@ -871,8 +897,8 @@ def build(): 'Derived from AX-B1 and RP-1.'], ['OQ-E1: Sequence vs. tree', 'CLOSED given the occurrence commitment and C-DA2 — DA-2', - 'The structure is a forward-directed tree, not a linear sequence. Given that instantiation occurs — the ' - 'occurrence commitment, not a consequence of T-SNAP — DA-2 with C-DA2 supplies the succession and the ' + 'The structure is a forward-directed tree, not a linear sequence. Given the ' + 'occurrence commitment, not a consequence of T-SNAP, DA-2 with C-DA2 supplies the succession and the ' 'branching follows. ' 'Countable vs. uncountable branching is perspective-dependent (DA-3).'], ['OQ-E2: Cardinality-semilattice correspondence', @@ -884,7 +910,7 @@ def build(): 'Named commitments: AX-B1 (binary existence), AX-G1 (initial object), AX-G2 (source asymmetry). ' 'Structural commitments as typeclass fields: A4/bot_join (ZPSemilattice), ' 'AFAStructure.quine_unique and bot_self_mem (the Quine-atom role, which every ZP-A lattice supplies trivially), ' - 'KleeneStructure.botCode_is_quine (computational closure, which a constant code meets). ' + 'KleeneStructure.botCode_is_quine (the bottom code is a computational quine, which a constant code meets). ' 'Typeclass fields are assumptions carried as hypotheses by the theorems that use them; #print axioms does not surface them. Further commitments are not axioms, among them CC-1 (S0 = ⊥), a ZP-A Conditional Claim; T-SNAP’s are stated under Premises of T-SNAP (DA-1 insert, § V).'], ['Temperature T in BA-1', 'PARAMETER — intentional', @@ -908,7 +934,7 @@ def build(): 'DP-2 (TrackedOutput, Snap.lean §VI); its precondition: the occurrence commitment; ZP-A CC-2, R3; ZP-C L-INF', 'None', 'Derived Proposition — primary: DP-2 (da1_minimal_path proved axiom-free in Lean). ' - 'Arguments for its precondition, none deriving it: CC-2/R3 (structural), L-INF (informational), AIT incompressibility (Path 3). ' + 'Arguments for its precondition, none deriving it: ZP-A CC-2/R3 (structural), L-INF (informational), AIT incompressibility (Path 3). ' 'AIT+ZF+AFA outside Lean scope.'], ['DA-2: Instantiation succession', 'ZP-A A4, CC-1; ZP-B C3, R1; T-SNAP', @@ -929,7 +955,7 @@ def build(): ['AX-1 retirement', 'T-SNAP proves the shape; the snap occurs given the occurrence commitment and DA-1', 'N/A', - 'AX-1 is retired: T-SNAP proves the shape, and that the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2)'], + 'AX-1 is retired: T-SNAP proves the shape, and that the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2)'], ['Iterative Forcing T5 (restated)', 'Selection: succession_succ, ZeroParadox/Ordinal/SnapSuccession.lean § I; for a monotone map sending the tower’s stages to c0, given the alignment hypothesis hε0, nothing below ε0 fires (snap_unconditional). Iteration: T3, R1, t_snap_irreversible, tsnap_holds_but_nothing_moves', 'None', @@ -937,7 +963,7 @@ def build(): ['Multiverse — structural implication', 'T-SNAP + DA-2 + C-DA2 jointly', 'None', - 'Structural implication given the occurrence commitment — T-SNAP gives the snap\'s shape, CC-2\'s undifferentiated ⊥ the branching, DA-2 with C-DA2 the succession'], + 'Structural implication given the occurrence commitment — T-SNAP gives the snap\'s shape, ZP-A CC-2\'s undifferentiated ⊥ the branching, DA-2 with C-DA2 the succession'], ['OQ-E2: Cardinality correspondence', 'DA-3', 'N/A', @@ -959,7 +985,7 @@ def build(): 'are provably distinct even when both produce ⊥. ✓ ' 'ZP-K: da1_closed_concrete : IsQuineAtom(⊥ : MachinePhase) proved in Kleene.lean. ' 'Path 1’s Lean counterpart is da1_closed_concrete, which proves nothing computational; Path 1 rules out an external executor, not an inert ⊥. ' - 'Path 3 (computational, ZP-C D1 + AIT): bears on the precondition and shows that executing is not derivable from incompressibility — incompressibility rules out a shorter external generator, not an inert string; that ' + 'Path 3 (computational, ZP-C D1 + AIT): bears on the precondition and does not derive executing from incompressibility — incompressibility rules out a shorter external generator, not an inert string; that ' 'the configuration reaching P0 is in Sense B and not Sense A is DP-2’s precondition, what the occurrence commitment asserts. Its 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. ' @@ -968,15 +994,15 @@ def build(): 'missing proof, distinct from the occurrence commitment and not a premise of the Snap; Path 2 does not derive the precondition. No computability library closes the gap between \'system at P₀\' and \'system is ' 'running.\' ' 'DA-1’s formal grounding (DP-2, da1_minimal_path) does not depend on Path 1, Path 2 or Path 3. ' - 'CC-1 restated in ZP-J as an equivalence, and not forced (a valid sequence can start elsewhere on a carrier with a second point); CC-2 a Forced Metatheoretic Commitment whose Quine-atom role t_exec_iff shows only ⊥ fills.'], + 'CC-1 restated in ZP-J as an equivalence, and not forced (a valid sequence can start elsewhere on a carrier with a second point); ZP-A CC-2 a Forced Metatheoretic Commitment about the host theory, while in an AFAStructure lattice t_exec_iff shows ⊥ is the only Quine atom (IsQuineAtom).'], ['T-SNAP: Binary Snap derived', 'Valid — Derived, in two readings. The Lean form (t_snap_derived) fixes the SHAPE with no hypotheses and no axioms. ' 'The seven-step prose argument uses commitments, and that the transition OCCURS is not established by T-SNAP (tsnap_holds_but_nothing_moves). ' - 'Premises: DA-1 insert § V, Premises of T-SNAP; two of them (CC-1 and occurrence at the first step) as hypotheses, t_snap_given. ✓'], + 'Premises: DA-1 insert § V, Premises of T-SNAP; two of them (CC-1 and occurrence at the first transition) as hypotheses, t_snap_given. ✓'], ['AX-1 retirement', 'Valid — AX-1 is retired, and its content was split in two. T-SNAP proves the shape, ' 'strengthened from assumed to derived. That the Snap occurs is stated separately: it follows from the occurrence commitment ' - '(instantiation occurs) together with DA-1 (closed given DP-2). Given CC-1, its first-step form is the hypothesis hocc in t_snap_given; ' + 'together with DA-1 (closed given DP-2). Given CC-1, its first-step form is the hypothesis hocc in t_snap_given; ' 'tsnap_holds_but_nothing_moves shows T-SNAP does not carry it.'], ['DA-2: Instantiation Succession', 'Valid — Definitional Alignment. Clarification of CC-1 scope. No new axiom. A4 role of ⊥ extended across instantiation boundaries. ✓'], @@ -1014,18 +1040,18 @@ def build(): sp(12), hr(), Paragraph( - 'ZP-E carries three formal inserts (DA-1, DA-2, DA-3). T-SNAP is derived, with its premises stated in the DA-1 insert § V and two of them (CC-1 and occurrence at the first step) as the hypotheses of t_snap_given; its irreversibility ' + 'ZP-E carries three formal inserts (DA-1, DA-2, DA-3). T-SNAP is derived, with its premises stated in the DA-1 insert § V and two of them (CC-1 and occurrence at the first transition) as the hypotheses of t_snap_given; its irreversibility ' 'rests on ZP-A R1 and ZP-B C3, with ZP-G downstream. DA-1 is closed given DP-2 (da1_minimal_path, axiom-free). ' 'Path 1’s Lean counterpart is da1_closed_concrete (ZP-K), which proves IsQuineAtom(⊥ : MachinePhase) and nothing ' 'computational; Path 3’s Lean counterpart is the machinePhaseKleene instance’s botCode_is_quine field, a KleeneStructure ' 'requirement, not a witness of execution; and ' 'the step from Path 2 to executing is a bridge principle of its own (a missing principle, not a missing proof), which the ' - 'framework does not adopt and which is distinct from the occurrence commitment; and Path 3 bears on the precondition and shows that ' - 'executing is not derivable from incompressibility: that the configuration reaching P0 is in Sense B is what the occurrence ' + 'framework does not adopt and which is distinct from the occurrence commitment; and Path 3 bears on the precondition and does not derive ' + 'executing from incompressibility: that the configuration reaching P0 is in Sense B is what the occurrence ' 'commitment asserts, and DA-1 consumes it. Remark ' 'R-ε0 justifies the ε0 symbol as a structural analogy. Remark ' - 'R-AFA rules Foundation out by the self-membership of ⊥ = {⊥} (Regularity, ' - 'no_quine_atom): the forcing is machine-checked ' + 'R-AFA rules Foundation out as a host of the Quine-atom role (Regularity, ' + 'no_quine_atom; zfset_quine_role_unoccupied): the forcing is machine-checked ' '(quineAtomHost_not_wellFounded), and a narrow Forced Metatheoretic Commitment remains. Open question: OQ-E2. ' 'Remaining axioms: AX-B1, AX-G1, AX-G2.', S['endnote']), diff --git a/scripts/build_zpe_companion.py b/scripts/build_zpe_companion.py index 063f37f8..8f92e9fd 100644 --- a/scripts/build_zpe_companion.py +++ b/scripts/build_zpe_companion.py @@ -1,6 +1,6 @@ """ Build ZP-E Illustrated Companion -Version 1.27 | October 2026 +Version 1.41 | November 2026 """ import os @@ -144,7 +144,7 @@ def axioms_table(): rows = [ ['AX-B1', 'Binary Existence. A state either exists or it does not. No third option. ' - 'The framework’s ONE substantive modelling commitment: that the outcome space is DISCRETE rather than a continuum. The two states being distinct is decidable; the choice of a discrete alphabet is not, and the real numbers are where it fails.'], + 'The framework’s ONE substantive modelling commitment: that the outcome space is DISCRETE rather than a continuum. The two states being distinct is decidable; the choice of a discrete alphabet is not. In the real numbers, an ordered field, 0 has no first step above it, AX-B1’s form (f_snap_impossible: no linearly ordered field has a least positive element).'], ['AX-G1', 'Initial Object Exists, and No Terminal Object. There is a starting point that reaches everything in exactly one way, ' 'and no end point that everything reaches in exactly one way. ' @@ -154,7 +154,11 @@ def axioms_table(): ['AX-G2', 'Source Asymmetry. Nothing returns to the initial object. ' 'The origin is unreachable from outside. ' - 'Not a novel commitment — follows from ZP-A antisymmetry and ZP-B C3.'], + 'Not a novel commitment where it holds: in a category built from a partial order with a least element, ' + 'such as the ZP-A semilattice order, a morphism into the least element means being below it, so antisymmetry ' + 'makes the source that element (the least element is a strict initial object, in the sense of Carboni, Lack and Walters 1993; the two antisymmetry examples at the end of ZeroParadox/Category/AxG2Reduce.lean). ' + 'ZP-B C3 is the analogous fact in Q2, proved in its own layer. It does not hold in every category: ' + 'ZP-H’s AX-G2 row names one where it fails.'], ] data = [hdr] + [[Paragraph(fix(r[0]), CS['tbl_cell']), Paragraph(fix(r[1]), CS['tbl_cell'])] for r in rows] @@ -171,7 +175,7 @@ def axioms_table(): t = Table(data, colWidths=[TW*0.18, TW*0.82]) t.setStyle(ts); return t -VERSION = '1.27' +VERSION = '1.41' FIRST_RELEASED = 'April 2026' @@ -219,7 +223,7 @@ def footer_cb(canvas, doc): 'the Binary Snap from its own mathematical vantage point. Each description is proved within its own ' 'framework, from that framework’s own premises (ZP-D’s include its design premise DP-1). ZP-H T-H3 ' '(th3_snap_all_functors) is their conjunction, four domain facts joined by “and”, with no functor or morphism in ' - 'its statement; ZP-H’s modelling commitment is the identification, under its functors, of the objects each framework located independently. ' + 'its statement, and ZP-H identifies none of the objects each framework located; where a shared role is checked, it is checked in one framework at a time (ZP-H Section VI). ' 'Reading the four as one event is the framework’s interpretation, not a theorem. The bottoms the four ' 'descriptions start from form a family (the bottom family, MC-1), not one object: an identity across the ' 'frameworks is retired as ill-typed, because their objects live in different mathematical types.')) @@ -240,7 +244,8 @@ def footer_cb(canvas, doc): 'The symbol ε₀ has two charts, and they are not merged. In the ordinal chart, ε₀ is the ' 'proof-theoretic ordinal of Peano Arithmetic, the minimum ordinal up to which PA ' 'cannot prove transfinite induction. Goodstein\'s theorem is the standard witness: every ' - 'Goodstein sequence eventually terminates, but PA cannot prove this; the proof requires ' + 'Goodstein sequence eventually terminates, but PA cannot prove this (Kirby and Paris, 1982, as ' + 'ZeroParadox/Ordinal/Goodstein.lean records); the proof requires ' 'transfinite induction up to ε₀. That ordinal is at once the least fixed point of the map ' 'α ↦ ω^α and the supremum of the tower ω, ω^ω, ω^(ω^ω), …, and neither face replaces the other. ' 'In that chart the snap does land on it: closing ⊥ under α ↦ ω^α gives ε₀ in one step. ' @@ -275,11 +280,15 @@ def footer_cb(canvas, doc): 'foundational assumption, taken without derivation. The claim was: when P₀ is reached, ' 'the Snap happens. Why? Because AX-1 says so. That claim bundled two things: the shape of ' 'the Snap (what a step off ⊥ looks like) and its occurrence (that the step is taken). ' - 'AX-1 is now retired, and its content was split in two: T-SNAP proves the shape, and that the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2).')) + 'AX-1 is now retired, and its content was split in two: T-SNAP proves the shape, and that the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). ' + 'The occurrence commitment is stated in two charts, execution and slot, in the header of ' + 'ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), ' + 'the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape ' + '(ZeroParadox/Information/CrossingTrials.lean § VIII).')) E.append(cbody( 'The DA-1 insert puts an argument where "Because AX-1 says so" stood, and the occurrence ' - 'commitment stays in place. The argument runs as follows. The occurrence commitment says instantiation ' - 'occurs as a running configuration: the configuration reaching P₀ is a running machine’s current ' + 'commitment stays in place. The argument runs as follows. In its execution chart, the occurrence ' + 'commitment says instantiation occurs as a running configuration: the configuration reaching P₀ is a running machine’s current ' 'configuration, not an inert string. That is a commitment, not a theorem (formal ZP-E, T-SNAP Step 2). ' 'Given it, the machine has left c₀ and is at c₁, by the definition of the first running configuration (D7); ' 'DA-1 (closed given DP-2) uses that commitment and does not supply it. Any running configuration passes through c₁ ' @@ -289,20 +298,24 @@ def footer_cb(canvas, doc): 'it fixes the shape of the step, not that the step happens. The argument about the framework’s own ' 'sequence uses commitments, among them AX-B1 (existence is binary: a state exists or it does not) and ' 'CC-1 (the sequence starts at ⊥); that the step actually happens rests further on DA-1, which is closed ' - 'only given DP-2, and on the framework’s commitment that instantiation occurs. The formal ZP-E ' + 'only given DP-2, and on the occurrence commitment. The formal ZP-E ' 'states these premises under Premises of T-SNAP, and the Lean t_snap_given takes two of them as its hypotheses: ' 'the start at ⊥ and the first step being taken.')) E.append(cbody( 'DA-1 is a Derived Proposition, closed given DP-2, as the next paragraph explains. That a ' 'configuration at P₀ is executing is not part of what it derives: that is DP-2’s precondition, ' - 'and it is what the occurrence commitment asserts. ZP-A CC-2, ' - '⊥ = {⊥}, itself a commitment (argued, not proved), motivates it. The bottom element ⊥ ' - 'is a Quine atom, a self-containing object with no external position from which it ' + 'and it is what the occurrence commitment asserts. ZP-A CC-2, the Quine atom, motivates it. In the die ' + 'it is a role, a point that steps to itself and to nothing else; under a self-application map supplied ' + 'by AbstractSelfApp, ⊥ of a ZP-A semilattice is its only occupant by that class’s own fields ' + '(selfApp_quine_role_iff), which the constant map onto ⊥ also meets, so the content is in the host. That ' + 'any host of the role is not well-founded is forced (quineAtomHost_not_wellFounded); which requirements ' + 'to demand of it, and adopting AFA, stay commitments (argued, not proved). In that role, ' + '⊥ of the semilattice leaves no external position from which it ' 'could be interpreted as a static description. So if ⊥ executes at all, nothing outside ' 'it can be the executor; the executor is ⊥ itself. That rules out an external executor, ' 'not an inert ⊥: the two-state machine type in the Lean source has a Quine-atom bottom ' 'and also admits a dynamics in which nothing moves. That the configuration reaching P₀ is running is the occurrence ' - 'commitment, not a consequence of ⊥ = {⊥}.')) + 'commitment, not a consequence of the Quine atom (CC-2).')) E.append(cbody( 'The two-layer structure of DA-1: DA-1 rests on two explicit layers. ' 'The first is the formal conditional: DP-2 (Execution Distinguishability) establishes ' @@ -316,19 +329,24 @@ def footer_cb(canvas, doc): 'running rather than inert? That precondition is what the occurrence commitment asserts. Three ' 'arguments bear on it, and none derives it.')) E.append(cbody( - 'Three arguments for the precondition: ' - '(1) CC-2/R3 (ZP-A): ⊥ = {⊥} is a Quine atom — it interprets itself, leaving no ' + 'Three arguments for the precondition (ZP-E’s Paths 1, 2 and 3): ' + '(1) CC-2/R3 (ZP-A): ⊥ of the state semilattice fills the Quine-atom role (CC-2), whose occupancy ' + 'is settled chart by chart — read as interpreting itself, it leaves no ' 'external position from which it could be read as a static description. As shown above, ' 'that rules out an external executor, not an inert ⊥. ' - '(2) L-INF (ZP-C): the surprisal of ⊥ diverges to infinity — no finite static ' - 'distribution can represent ⊥. That rules out a finite static description; the step from ' + '(2) Informational, in two charts: surprisal grows without bound with depth in the ball hierarchy, ' + 'each value finite (ZP-C L-INF, l_inf); and at 0 of ℚ₂, the one point in every ball of the chain centred ' + 'at 0, the 2-adic additive valuation is ⊤ (padic_addVal_bot). ⊥ of the machine-state type, c₀, corresponds to ' + 'that point. From this the framework argues that no finite static distribution can represent ⊥. That ' + 'rules out a finite static description; the step from ' 'there to executing is a bridge principle of its own, a missing principle and not a missing proof, ' 'which the framework does not adopt and which is separate from the occurrence commitment. ' '(3) Computational (incompressibility as self-description): at the incompressibility threshold P₀, the configuration c₁ ' - 'is maximally incompressible — K(c₁|n)/|c₁| = 1 — so no shorter external program generates it. ' + 'is incompressible (K(c₁|n) ≥ |c₁|, the ratio K(c₁|n)/|c₁| being 1 up to an additive constant in K), ' + 'so no shorter external program generates it. ' 'That rules out a shorter external generator, not an inert string: an incompressible string ' - 'written down and never run has no shorter generator and is still not executing. So executing ' - 'is not derivable from incompressibility; that the configuration reaching P₀ ' + 'written down and never run has no shorter generator and is still not executing. So Path 3 does not derive executing ' + 'from incompressibility; that the configuration reaching P₀ ' 'is running, not inert, is what the occurrence commitment asserts. ' 'All three share D7\'s static/executing dichotomy as background and none is circular ' 'with DP-2.')) @@ -341,14 +359,14 @@ def footer_cb(canvas, doc): 'carried together by da1_paths_unified as a conjunction; that they name one structural fact is the ' 'framework’s reading. Neither Path 2 (unbounded surprisal) nor Path 3 (incompressibility) derives ' 'executing: the step from unbounded surprisal to executing is a bridge principle of its own, a missing principle that the ' - 'framework does not adopt and that is separate from the occurrence commitment, and Path 3 shows that ' - 'executing is not derivable from incompressibility. ' + 'framework does not adopt and that is separate from the occurrence commitment; for Path 3 the reason is ' + 'item (3) above, a fact of algorithmic information theory and not among what Lean checks. ' 'The formal grounding of DA-1 is therefore DP-2, through da1_minimal_path.')) # The caption is kept on the same page as its diagram (it was orphaned onto the next page). E.append(KeepTogether([tsnap_chain_diagram(), ccaption( 'The T-SNAP derivation chain. The chain uses commitments, ' 'among them AX-B1 and CC-1 (S₀ = ⊥), and fixes the shape of the Snap; that the Snap occurs rests further on ' - 'the occurrence commitment (instantiation occurs), whose content is DA-1’s precondition, and on DA-1 (closed given DP-2), ' + 'the occurrence commitment, whose execution chart is DA-1’s precondition, and on DA-1 (closed given DP-2), ' 'which consumes it. AX-1 is retired: its shape is now a ' 'theorem (T-SNAP, amber), and that the Snap occurs is stated separately, following from that commitment together with DA-1.')])) E.append(sp(4)) @@ -357,7 +375,7 @@ def footer_cb(canvas, doc): 'Surveillance footage can prove the first while the second still rests on testimony the court ' 'chooses to accept. AX-1 bundled two claims in the same way. T-SNAP proves the first, the shape ' 'of the Snap, which was once assumed. The second, that the Snap happens, was not proved along with ' - 'it: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2).', + 'it: it follows from the occurrence commitment together with DA-1 (closed given DP-2).', ])) E.append(sp(8)) @@ -369,8 +387,8 @@ def footer_cb(canvas, doc): E.append(sp(6)) E.append(cbody( 'AX-1 is not on this list: it is retired, and its shape is Theorem T-SNAP. Further commitments are not axioms and are stated where they are used, ' - 'among them the occurrence commitment (that instantiation occurs; together with DA-1 it gives that the Snap happens), CC-1 (S₀ = ⊥, a ZP-A Conditional Claim), the choice of starting point that T-SNAP is derived given, ' - 'and CC-2 (⊥ = {⊥}, a ZP-A Forced Metatheoretic Commitment), which motivates DA-1’s precondition; DA-1 itself is closed given DP-2. ' + 'among them the occurrence commitment (together with DA-1 it gives that the Snap happens), CC-1 (S₀ = ⊥, a ZP-A Conditional Claim), the choice of starting point that T-SNAP is derived given, ' + 'and CC-2 (the Quine atom: the role of a point that steps to itself and to nothing else, whose occupancy is settled chart by chart; in the set chart under AFA, the set x = {x}, Aczel 1988, Example 1.3; a ZP-A Forced Metatheoretic Commitment: adopting AFA is CC-2’s commitment, the host requirements (QuineAtomHost) are its Lean abstraction, and that any such host gives up Foundation is forced (quineAtomHost_not_wellFounded)), which motivates DA-1’s precondition; DA-1 itself is closed given DP-2. ' 'The framework makes no stronger claim than it has to.')) E.append(sp(8)) E.append(remember_box( diff --git a/scripts/build_zpf.py b/scripts/build_zpf.py index d33e3f1b..4520417a 100644 --- a/scripts/build_zpf.py +++ b/scripts/build_zpf.py @@ -1,11 +1,11 @@ """ -Build ZP-F: The Counterexamples (v1.20) +Build ZP-F: The Counterexamples (v1.26) """ import os from zp_utils import * -VERSION = '1.20' +VERSION = '1.26' FIRST_RELEASED = 'April 2026' def build(): @@ -29,20 +29,28 @@ def build(): # ── I. Purpose and Scope ────────────────────────────────────────────────── E.append(Paragraph('I. Purpose and Scope', S['h1'])) E.append(body( - 'The Zero Paradox framework requires a metric space in which a minimal first ' - 'departure from ⊥ has a structurally forced SHAPE — the Binary Snap. ' - 'What is derived is that shape, not that the departure is taken: a join-semilattice in ' - 'which T-SNAP holds and nothing moves is exhibited in the Lean source ' - '(tsnap_holds_but_nothing_moves). ' - 'This document establishes the negative result: no linearly ordered field can ' - 'serve as that substrate. The real numbers ℝ are the canonical and most ' + 'The Zero Paradox framework separates a derived SHAPE from a committed first step. ' + 'The shape, the Binary Snap, is T-SNAP: in any ZPSemilattice (ZP-A’s join-semilattice with least element, axioms A1–A4), a run that starts ' + 'at the semilattice\'s ⊥ and whose first transition goes to a different state (S 1 ≠ S 0) ' + 'meets that shape (t_snap_given, with both as hypotheses). What is derived is that shape, not that ' + 'the transition is taken: a ' + 'join-semilattice in which T-SNAP holds and nothing moves is exhibited in the Lean source ' + '(tsnap_holds_but_nothing_moves). A first step above the carrier\'s ⊥, an element ' + 'covering it (HasFirstStep), is AX-B1\'s form, and it is committed, not derived. ' + 'This document establishes the negative result for that commitment: in no linearly ' + 'ordered field does 0 have a first step above it, AX-B1\'s form. T-SNAP\'s shape does ' + 'not need a first step: t_snap_given holds at a ' + 'step taken in a densely ordered join-semilattice (ℚ≥0 under max, whose ⊥ is 0; ' + 'ZeroParadox/Order/Snap.lean). The real numbers ℝ are the canonical and most ' 'familiar instance; the theorem applies to any field carrying a compatible ' 'linear order.')) E.append(body( 'The blocking mechanism is elementary: in any such field, for any positive ' 'element ε, the element ε/2 exists, is positive, and is strictly ' - 'smaller. There is no floor. The Binary Snap requires a floor. Therefore ' - 'the snap is structurally impossible in any linearly ordered field.')) + 'smaller. There is no least positive element, so 0 has no first step above it, ' + 'AX-B1\'s form, in any linearly ordered field. That a run\'s first transition is a cover is a hypothesis ' + 'beyond T-SNAP\'s shape (t_snap_given_cover), and the shape itself (t_snap_given) does ' + 'not need it.')) E.append(body( 'This result contextualises the choice of Q₂ in ZP-B. Among all completions ' 'of ℚ, Ostrowski\'s theorem identifies exactly two kinds: Archimedean completions ' @@ -106,9 +114,13 @@ def build(): E.append(label_box('Theorem F-SNAP-IMPOSSIBLE', [ '¬∃ ε₀ : F, 0 < ε₀ ∧ ¬∃ δ : F, 0 < δ ∧ δ < ε₀', - 'The Binary Snap cannot occur in any linearly ordered field.', - 'A snap requires a minimal first departure from 0 with nothing below it. ' - 'F-SNAP-BLOCKED shows such a floor never exists in a linearly ordered field.', + 'F-SNAP-IMPOSSIBLE (f_snap_impossible): no linearly ordered field has a least positive ' + 'element, so 0 has no first step above it (AX-B1\'s form). ' + 'T-SNAP\'s shape does not need a first step (t_snap_given holds at a step taken in a ' + 'densely ordered join-semilattice, ℚ≥0 under max, ZeroParadox/Order/Snap.lean).', + 'A first step is a minimal first departure from 0, with nothing strictly between it and 0 ' + '(a cover, HasFirstStep). ' + 'F-SNAP-BLOCKED shows such a step never exists in a linearly ordered field.', 'Proof: Direct from F-SNAP-BLOCKED. Status: DERIVED. ✓', ])) E.append(sp(4)) @@ -145,7 +157,8 @@ def build(): E.append(label_box('Corollary R-SNAP-IMPOSSIBLE', [ '¬∃ ε₀ : ℝ, 0 < ε₀ ∧ ¬∃ δ : ℝ, 0 < δ ∧ δ < ε₀', - 'The Binary Snap cannot occur in ℝ. ' + 'R-SNAP-IMPOSSIBLE (r_snap_impossible): ℝ has no least positive element, so 0 has ' + 'no first step above it in ℝ (AX-B1\'s form). ' 'Follows from F-SNAP-IMPOSSIBLE at F = ℝ. Status: DERIVED (corollary). ✓', ])) E.append(sp(4)) @@ -164,20 +177,22 @@ def build(): E.append(body( 'ZP-F is self-contained and does not feed formally into any other layer. ' 'It is the negative complement to ZP-B: where ZP-B establishes that Q₂ ' - 'removes the topological obstruction to the snap (its 2-adic topology is totally ' - 'disconnected, t5_totallyDisconnected, with clopen balls), ZP-F establishes that ℝ — and any linearly ordered field — ' - 'cannot host it. Neither supplies the first step AX-B1 commits to, a cover of ⊥ on ' + 'removes the topological obstruction to an irreversible step (c3_irreversible: no continuous path ' + 'in Q₂ from a nonzero point to 0, since its 2-adic topology is totally ' + 'disconnected, t5_totallyDisconnected, with clopen balls; ' + 'a case of Mathlib’s TotallyDisconnectedSpace.eq_of_continuous: in Q₂ no continuous path joins any two distinct points, so the step out from 0 is blocked as well), ZP-F establishes that in ℝ — and any linearly ordered field — ' + '0 has no first step above it, AX-B1\'s form. Neither supplies the first step AX-B1 commits to, a cover of ⊥ on ' 'the state carrier, the set of states a run S moves through, ordered as in ZP-A ' - '(HasFirstStep). t_snap_given_cover assumes the run\'s first step is a cover (hcov); ' - 'with CC-1, the commitment that the run starts at ⊥ (S 0 = ⊥), that step is ' + '(HasFirstStep). t_snap_given_cover assumes the run\'s first transition is a cover (hcov); ' + 'with CC-1, the commitment that the run starts at ⊥ (S 0 = ⊥), that transition is ' 'a cover of ⊥. MachinePhase meets the commitment: its state c₁ covers its ' '⊥, c₀.')) E.append(body( 'The dependency order of the framework places ZP-F as independent:')) E.append(data_table( ['Layer', 'Role', 'Dependency'], - [['ZP-B', 'p-Adic topology — Q₂ removes the topological obstruction', 'ZP-A'], - ['ZP-F', 'Counterexample — ℝ and ordered fields cannot host the snap', 'None (self-contained)'], + [['ZP-B', 'p-Adic topology — Q₂ removes the topological obstruction to an irreversible step (c3_irreversible) and supplies no first step', 'ZP-A'], + ['ZP-F', 'Counterexample — in ℝ and ordered fields 0 has no first step above it (AX-B1\'s form)', 'None (self-contained)'], ['ZP-G', 'Category theory', 'Self-contained; ZP-E conceptually']], [0.8*inch, 3.5*inch, 2.2*inch] )) @@ -190,7 +205,8 @@ def build(): 'they fill every gap. Density — the property established in F-DENSITY: for any ' 'ε > 0 there exists δ with 0 < δ < ε — is not a deficiency in ' 'ℝ; it is one of ℝ\'s defining virtues. The counterexample above shows ' - 'that this virtue is exactly what disqualifies ℝ as a host for the Binary Snap. ' + 'that this virtue is exactly what rules out a first step above 0 in ℝ, AX-B1\'s form; ' + 'T-SNAP\'s shape does not need one (t_snap_given). ' 'The exclusion is not a matter of degree: density follows from the ordered field axioms, ' 'so every linearly ordered field is ruled out by exactly the same argument. ' 'Familiarity here misleads: the setting that feels most natural ' @@ -207,18 +223,19 @@ def build(): 'ℝ: ruling out ℝ and every Archimedean completion leaves the p-adic fields, and ' 'T0, under MP-1, then selects Q₂ among them.')) E.append(body( - 'The structural difference can be stated directly. It has two fences, the order and the ' - 'topology, and the order separates ℝ from Q₂ globally, not at zero. ' + 'The structural difference can be stated directly. It has an order side and a topological ' + 'side, and the order separates ℝ from Q₂ globally, not at zero. ' 'AX-B1 commits the point the snap leaves to having a first step: an element directly above ' 'it with nothing strictly between, a cover (HasFirstStep). A cover of a least ' 'element is what order theory calls an atom (Mathlib bot_covBy_iff). An ordered field has no ' 'bottom element; its 0, which plays that role here, has no first step ' '(axb1_fails_in_ordered_field). That is one instance of a stronger fact: an order is ' 'dense if and only if no element at all has a first step ' - '(axb1_fails_everywhere_iff_dense). The equivalence quantifies over every element, so ' + '(axb1_fails_everywhere_iff_dense, the corpus restatement of Mathlib\'s ' + 'denselyOrdered_iff_forall_not_covBy). The equivalence quantifies over every element, so ' 'density rules out a first step at 0, and one element without a first step does not ' 'make an order dense. In the metric chart zero is a limit point of the nonzero elements, ' - 'in ℝ and equally in Q₂; so being a limit point does not decide the snap. ' + 'in ℝ and equally in Q₂. ' 'Q₂\'s zero is a floor of the limit kind: the doubling orbit of a nonzero element ' 'converges to 0 and does not reach it in finite time, while counting down in ℕ ' 'reaches 0 in finitely many steps (floor_reach_separates_mu_nu). In the valuation chart ' @@ -240,24 +257,27 @@ def build(): 'valuation order 0 is greatest, v(0) = ⊤ (addVal_bot). ' 'The first step AX-B1 commits to is a cover of ⊥ on the state carrier, in ZP-A\'s ' 'induced order (HasFirstStep), a commitment. t_snap_given_cover ' - '(ZeroParadox/Order/Snap.lean) assumes the run\'s first step is a cover (hcov); with ' - 'CC-1, the run\'s start at ⊥, that step is a cover of ⊥. The converse fails: a ' - 'run can start at a ⊥ that has a cover while its own first step is not one ' + '(ZeroParadox/Order/Snap.lean) assumes the run\'s first transition is a cover (hcov); with ' + 'CC-1, the run\'s start at ⊥, that transition is a cover of ⊥. The converse fails: a ' + 'run can start at a ⊥ that has a cover while its own first transition is not one ' '(ZeroParadox/Order/SnapCannotBe.lean). MachinePhase meets the commitment (the ' 'MachinePhase example in ZeroParadox/Order/Snap.lean stating that c₁ covers its ' '⊥). In neither ordering of Q₂ does its 0 have a first step: in the norm ' 'preorder it has none, and in the valuation order nothing lies above it. ' - 'The snap does not fail in ℝ by accident. In the order it fails because ℝ ' - 'is densely ordered, and in a dense order no element has a first step, 0 included; in ' - 'the topology ℝ is connected (place_topological_signature), so not totally ' - 'disconnected (real_no_snap), a second and separate fence.')) + 'The first step is not missing in ℝ by accident. It is missing because ℝ ' + 'is densely ordered, and in a dense order no element has a first step, 0 included ' + '(axb1_fails_everywhere_iff_dense; for 0 in any linearly ordered field, f_snap_impossible). The topological difference from Q₂ is that ℝ is connected ' + '(place_topological_signature), so not totally disconnected (real_no_snap). That is not ' + 'a separate fence against a first step: for a linear order carrying its order topology, connectedness implies ' + 'density (Mathlib denselyOrdered_of_preconnectedSpace).')) E.append(sp(4)) E.append(remark_box( 'Remark: The Dual Limit Condition', [ 'The results of §II–§III and ZP-L together admit an informal ' - 'structural account of why the snap is domain-specific.', + 'structural account of why a first step above 0, AX-B1’s form, is ' + 'domain-specific.', 'In any dense ordered field, 0 has no nearest neighbour from above: for any ' 'ε > 0 there exists δ with 0 < δ < ε (F-DENSITY). Zero is ' 'a topological limit point from above with no minimum positive element. AX-B1 ' @@ -290,7 +310,7 @@ def build(): 'at every element (axb1_fails_everywhere_iff_dense). Their 0 also lacks an immediate ' 'predecessor, for the same reason, and without (2) that does not help. ' 'In the non-standard naturals *ℕ with ' - 'the order topology, every element has an immediate predecessor, so there is ' + 'the order topology, every nonzero element has an immediate predecessor, so there is ' 'no limit point at infinity in the order-topology sense; condition (1) fails ' 'informally. (This *ℕ observation is informal — not a proved result ' 'of this document or ZP-L.)', @@ -322,24 +342,23 @@ def build(): 'ε₀ is located from above as the least fixed point of ' 'α ↦ ω^α and from below as the limit of the CNF tower; ' 'in ZP-M, the computability and ordinal fixed points are argued to converge to the ' - 'same 2-adic limit. This recurrence is not coincidental. The snap is the point ' + 'same 2-adic limit. Reading: this recurrence is not coincidental. The snap is the point ' 'where a domain\'s own measurement framework exhausts itself; no single framework ' 'can locate it from inside because the framework runs out exactly there. ' 'This suggests a dual approach is required in each case: each framework reaches the ' 'boundary from its own direction, and the snap is the point they agree on. ' 'No general theorem to this effect is established here.', - 'The surreal numbers (No) satisfy both conditions — non-Archimedean ' - 'structure (containing ε₀ as an ordinal) and genuine limit ordinals ' - '— and are the natural boundary test case for any duality theorem. Whether ' - 'the surreals admit a snap-like result, or whether a third structural condition ' - 'is required to exclude them, has not been determined. ' + 'The surreal numbers (No) are non-Archimedean and contain the limit ordinals, ' + 'ε₀ among them, so they are the natural boundary test case for any ' + 'duality theorem. No is a ' + 'linearly ordered field, so 0 of No has no first step above it, AX-B1’s form ' + '(ZP-L, Remark R-L.2), and No fails condition (2) at 0 as ℝ does. ' '(Informal — not a result of this document.)', 'Development path toward a formal theorem: prove the two conditions as ' 'independent Lean results (density impossibility established here; ε₀ ' 'a limit ordinal, the Order.IsSuccLimit example in ' 'ZeroParadox/Order/SnapCannotBe.lean), then prove they agree on the same structural ' - 'point. The surreal case is the critical test of whether two conditions are ' - 'jointly sufficient.', + 'point.', ] )) E.append(sp(4)) diff --git a/scripts/build_zpf_companion.py b/scripts/build_zpf_companion.py index 72590f9e..a284cef9 100644 --- a/scripts/build_zpf_companion.py +++ b/scripts/build_zpf_companion.py @@ -1,7 +1,7 @@ """ Build ZP-F Illustrated Companion -Where the Snap Fails: The Real Numbers as Counterexample -Version 1.19 | May 2026 +Where the First Step Fails: The Real Numbers as Counterexample +Version 1.24 | November 2026 """ import os, math @@ -83,8 +83,10 @@ def comparison_table(): 'Metric: 0 is a limit point too — the doubling orbit 2ⁿx tends to 0 and does not reach it in finite time'], ['Infinity lives in the representation (infinite decimal = finite magnitude)', 'Valuation: infinity is the address of 0 — v₂(0) = +∞, the greatest value; every nonzero element has a finite valuation'], - ['The snap cannot occur — density blocks every candidate first step', - 'The topological obstruction is removed, and no first step at 0 is supplied (AX-B1\'s first step is a cover of ⊥ on the state carrier, a commitment)'], + ['No first step above 0 (AX-B1\'s form): density puts a smaller positive element below ' + 'every candidate (f_snap_impossible: no linearly ordered field has a least positive ' + 'element). T-SNAP\'s shape does not need a first step (t_snap_given)', + 'The topological obstruction to an irreversible step is removed (c3_irreversible: no continuous path in Q₂ from a nonzero point to 0; a case of Mathlib’s TotallyDisconnectedSpace.eq_of_continuous: in Q₂ no continuous path joins any two distinct points, so the step out from 0 is blocked as well), and no first step at 0 is supplied (AX-B1\'s first step is a cover of ⊥ on the state carrier, a commitment)'], ] data = [hdr] + [[Paragraph(fix(r[0]), CS['kr_body']), Paragraph(fix(r[1]), CS['kr_body'])] for r in rows] @@ -107,7 +109,7 @@ def comparison_table(): return t -VERSION = '1.19' +VERSION = '1.24' FIRST_RELEASED = 'May 2026' @@ -120,14 +122,14 @@ def footer_cb(canvas, doc): canvas.setFillColor(colors.grey) canvas.drawCentredString( LETTER[0] / 2, 0.6 * inch, - 'Zero Paradox ZP-F Companion | Where the Snap Fails: The Real Numbers as Counterexample' + 'Zero Paradox ZP-F Companion | Where the First Step Fails: The Real Numbers as Counterexample' ' | ' + version_date()) canvas.restoreState() doc = SimpleDocTemplate( out_path, pagesize=LETTER, leftMargin=LM, rightMargin=RM, topMargin=TM, bottomMargin=BM, - title='Where the Snap Fails: The Real Numbers as Counterexample', + title='Where the First Step Fails: The Real Numbers as Counterexample', author='Zero Paradox Project', onFirstPage=footer_cb, onLaterPages=footer_cb) E = [] @@ -145,21 +147,29 @@ def footer_cb(canvas, doc): colWidths=[TW]) hdr.setStyle(hdr_ts) E += [hdr, sp(6), - Paragraph('Where the Snap Fails', CS['title']), + Paragraph('Where the First Step Fails', CS['title']), Paragraph('The Real Numbers as Counterexample', CS['subtitle']), Paragraph('ZP-F Companion | ' + version_line(FIRST_RELEASED, VERSION), CS['meta']), Paragraph( 'This companion document is written for general readers. It explains in plain ' - 'language why the real number line cannot serve as the mathematical substrate ' - 'for the Binary Snap, and where the 2-adic numbers Q₂ stand: ZP-F excludes ' - 'ordered fields, by density; ZP-B records that Q₂ is totally disconnected ' - '(t5_totallyDisconnected, an instance Mathlib already supplies), which removes the ' - 'topological obstruction; neither supplies the first step at ⊥ of the state ' - 'carrier, the set of states a run of the framework moves through, ordered as in ' - 'ZP-A (that first step is AX-B1, a commitment). ' + 'language why, on the real number line, 0 has no first step above it, AX-B1\'s ' + 'form, and why T-SNAP\'s shape, the Binary Snap, does not need one; and where the ' + '2-adic numbers Q₂ stand. Density is the reason ℝ has no first step ' + 'above 0 (f_snap_impossible). The topological difference from Q₂ is that ' + 'ℝ is connected, so not totally disconnected (real_no_snap), while Q₂ is ' + 'totally disconnected (padic_snaps). That is not a separate fence against a first step: for a linear order ' + 'carrying its order topology, connectedness implies density (Mathlib ' + 'denselyOrdered_of_preconnectedSpace). Q₂’s topology supplies no first step: ' + 'Mathlib gives Q₂ no order, and under the norm preorder 0 has no first step ' + 'there either (ZeroParadox/BottomCannotBe.lean). Neither carrier supplies the first step at ' + '⊥ of the state carrier, the set of states a run of the framework moves ' + 'through, ordered as in ZP-A (that first step is AX-B1, a commitment). ' 'The formal results are machine-verified in Lean 4 as part of ZP-F ' - '(F-SNAP-IMPOSSIBLE and the general ordered field result); see also ' - 'ZP-B (p-adic topology) for the positive case.', + '(F-SNAP-IMPOSSIBLE, f_snap_impossible: no linearly ordered field has a least ' + 'positive element, so 0 has no first step above it, AX-B1\'s form); see also ' + 'ZP-B (p-adic topology), where Q₂ is totally disconnected ' + '(t5_totallyDisconnected, an instance Mathlib already supplies) and that topology ' + 'supplies no first step.', CS['disc'])] # ── I. The Natural Question ───────────────────────────────────────────────── @@ -170,11 +180,15 @@ def footer_cb(canvas, doc): 'used. They seem like the natural substrate for any framework involving ' 'continuity, limits, and state transitions. This document is the answer.')) E.append(cbody( - 'The answer begins with a counterexample. The real number line is not a valid ' - 'substrate for the Binary Snap — not because it is wrong, but because it is ' - 'the space where the snap is structurally impossible. Understanding why the snap ' - 'fails in ℝ is the clearest path to seeing what Q₂ removes and what it ' - 'does not supply.')) + 'The answer begins with a counterexample. The real number line lacks the first step ' + 'AX-B1 commits the framework\'s carrier to — not because it is wrong, but because no ' + 'ordered field, ℝ and ℚ among them, has a least positive element ' + '(f_snap_impossible, which, despite its name, states exactly that), so 0 has no first ' + 'step above it. T-SNAP\'s shape does not need a first step: t_snap_given ' + 'holds at a step taken in a densely ordered join-semilattice (ℚ≥0 under max, ' + 'ZeroParadox/Order/Snap.lean). Understanding why ' + 'ℝ has no first step above 0 is the clearest path to seeing what Q₂ removes ' + 'and what it does not supply.')) E.append(sp(4)) # ── II. The Density Symmetry ──────────────────────────────────────────────── @@ -192,8 +206,10 @@ def footer_cb(canvas, doc): 'on a continuum that looks the same from every direction. For any candidate ' 'first step ε₀ > 0, the number ε₀ / 2 also exists, ' 'and ε₀ / 4, and ε₀ / 2ⁿ for every n. ' - 'A discrete, irreversible departure from zero — the Binary Snap — is ' - 'structurally impossible in ℝ.')) + 'So in ℝ 0 has no first step above it, AX-B1\'s form (f_snap_impossible: no ' + 'linearly ordered field has a least positive element). T-SNAP\'s shape, the Binary ' + 'Snap, does not need one: t_snap_given holds at a step taken in a densely ordered ' + 'join-semilattice.')) E.append(sp(6)) E.append(pi_curve_diagram()) E.append(ccaption( @@ -201,8 +217,11 @@ def footer_cb(canvas, doc): 'π — at two sampling resolutions. At standard scale it appears smooth ' 'and continuous (left). At high zoom, discrete steps become visible (right). ' 'In the actual real numbers, the decimal expansion can always continue; ' - 'the smooth curve never structurally breaks down. The snap requires ' - 'a space where that breakdown is built in, not imposed.')) + 'the smooth curve never structurally breaks down. A first step above 0, AX-B1\'s form, ' + 'needs a space where that breakdown is built in, not imposed; T-SNAP\'s shape, a join ' + 'step off ⊥ of the state semilattice to a different state (t_snap_given), does ' + 'not, and the cover is a ' + 'further hypothesis (t_snap_given_cover).')) E.append(sp(8)) # ── III. Where the Infinity Lives ────────────────────────────────────────── @@ -249,20 +268,24 @@ def footer_cb(canvas, doc): E.append(comparison_table()) E.append(sp(8)) - # ── IV. Finite Precision Makes the Snap Possible ──────────────────────────────────── - E.append(Paragraph('IV. Finite Precision Makes the Snap Possible', CS['h1'])) + # ── IV. Finite Precision Supplies a First Step ──────────────────────────────────── + E.append(Paragraph('IV. Finite Precision Supplies a First Step', CS['h1'])) E.append(cbody( 'Every computer already knows this. Any number system with a maximum number ' 'of decimal places — any fixed-point arithmetic system, any discretized ' 'simulation — has a smallest representable positive number — call it δ. ' - 'Below that, there\'s nowhere to go. The density argument fails at δ. The snap becomes ' - 'available: there is a genuine first step, and halving it is not possible. Whether that step ' - 'is taken is a separate question, and the framework commits to it rather than deriving it.')) + 'Below that, there\'s nowhere to go. The density argument fails at δ: there is a ' + 'genuine first step above 0, AX-B1\'s form, and halving it is not possible. T-SNAP\'s ' + 'shape is a join step off ⊥ of the state semilattice to a different state ' + '(t_snap_given) and does not need it; that a run\'s first transition is a cover is a further ' + 'hypothesis (t_snap_given_cover). Whether a ' + 'step is taken is a separate question, and the framework commits to it rather than ' + 'deriving it.')) E.append(cbody( 'The real numbers are the idealization in which this floor is removed — the ' 'limiting case in which precision is unbounded and the minimum disappears. ' 'That is not a feature from the perspective of the Zero Paradox. It is ' - 'exactly what blocks the snap.')) + 'exactly what rules out a first step above 0.')) E.append(cbody( 'Q₂ is not an artificially truncated real line, and it does not restore a ' 'smallest step. Its zero is a floor of the other kind: a finite-precision system\'s ' @@ -271,14 +294,14 @@ def footer_cb(canvas, doc): 'out by its valuation, v₂(0) = +∞. The first step AX-B1 commits to is a cover ' 'of ⊥ on the state carrier (a commitment): a state directly above ⊥ with ' 'nothing strictly between, which order theory calls an atom. t_snap_given_cover assumes ' - 'the run\'s first step is a cover; with CC-1, the commitment that the run starts at ' - '⊥, that step is a cover of ⊥. MachinePhase meets the commitment (its state ' + 'the run\'s first transition is a cover; with CC-1, the commitment that the run starts at ' + '⊥, that transition is a cover of ⊥. MachinePhase meets the commitment (its state ' 'c₁ covers its ⊥, c₀). In neither ordering of Q₂ does its 0 have a ' 'first step, so the step is not a consequence of the 2-adic structure.')) E.append(sp(4)) E.append(remember_box( - 'Every finite computational system is already subject to the Binary Snap by ' - 'construction. The minimum representable positive value exists; the density ' + 'Every finite-precision number system with a positive representable value already has ' + 'a first step above 0, AX-B1\'s form: its least positive value. The minimum representable positive value exists; the density ' 'argument fails there. The real numbers are the most familiar example of a ' 'structure that removes this floor — but any dense ordered set has the same ' 'property, including the rational numbers: for any ε₀ > 0, ' @@ -292,7 +315,7 @@ def footer_cb(canvas, doc): E.append(cbody( 'The real number line is not wrong. It is internally consistent and ' 'extraordinarily useful for calculus, analysis, and modeling continuous ' - 'change. But it cannot host the Binary Snap — not because it fails as ' + 'change. But on the line, 0 has no first step above it, AX-B1\'s form — not because the line fails as ' 'a mathematical structure, but because of how it treats zero.')) E.append(cbody( 'Consider a sports team. The coach and the players are not peers. The coach ' @@ -307,12 +330,11 @@ def footer_cb(canvas, doc): 'away from, not a state it can stably occupy or return to. In ℝ, zero ' 'has no such character: it is a regular point of a dense line, ' 'indistinguishable in structure from 1 or π, with no first step above it. ' - 'In the order, density is what disqualifies it (axb1_fails_everywhere_iff_dense); in ' - 'the topology, the line is connected (place_topological_signature), so not totally ' - 'disconnected (real_no_snap). ' - 'Being approached as a limit is ' - 'not what disqualifies it, since the 2-adic 0 is approached as a limit too ' - '(floor_reach_separates_mu_nu).')) + 'Density is what disqualifies it (axb1_fails_everywhere_iff_dense). The line is also ' + 'connected (place_topological_signature), so not totally disconnected (real_no_snap), ' + 'which is its topological difference from Q₂; for a line carrying its order ' + 'topology, connectedness implies density (Mathlib denselyOrdered_of_preconnectedSpace), ' + 'so that is not a second reason.')) E.append(cbody( 'The real number line treats zero as an ordinary point — a peer of every ' 'other element, with the same local structure as 1 or π. ' @@ -404,7 +426,7 @@ def footer_cb(canvas, doc): E.append(Paragraph('VIII. Two Limit Conditions, Side by Side', CS['h1'])) E.append(cbody( 'The density argument and the ordinal threshold argument are two separate ' - 'observations — one about why the snap fails in ℝ, one about how ' + 'observations — one about why 0 has no first step above it in ℝ, one about how ' 'ε₀ of Ordinal is reached. Read side by side they share a shape, and the ' 'shared shape is an analogy, not a proved identification.')) E.append(cbody( @@ -414,9 +436,8 @@ def footer_cb(canvas, doc): 'so zero has no first step. That is a fact about the order. In fact an order is dense ' 'exactly when no element at all has a first step (axb1_fails_everywhere_iff_dense), so ' 'density rules out a first step at zero; one element lacking a first step would not ' - 'make an order dense. Zero in ℝ is also a limit point, a fact about the metric; ' - 'so is zero in Q₂ (floor_reach_separates_mu_nu), so the limit point is not what ' - 'blocks the snap.')) + 'make an order dense. Zero in ℝ is also a limit point, a fact about the metric, ' + 'and so is zero in Q₂ (floor_reach_separates_mu_nu).')) E.append(cbody( 'From the ordinal side: ε₀ of Ordinal has no ordinal immediately below it. There is ' 'no α with α + 1 = ε₀. It is the limit of the tower ' @@ -452,17 +473,22 @@ def footer_cb(canvas, doc): E.append(Paragraph('What the Counterexample Shows', CS['h1'])) E.append(cbody( 'The real numbers are the most natural, most familiar metric space in ' - 'mathematics. They are also precisely the space where the Binary Snap ' - 'cannot occur. They are densely ordered, so no element, zero included, has a first ' + 'mathematics. They are also a space where 0 has no first step above it, AX-B1\'s form ' + '(f_snap_impossible: no linearly ordered field has a least positive element), while ' + 'T-SNAP\'s shape does not need one (t_snap_given holds at a step taken in a densely ' + 'ordered join-semilattice). They are densely ordered, so no element, zero included, has a first ' 'step: every candidate first step admits an infinite sequence of smaller steps below ' 'it. Zero is also a limit point there, but so is the 2-adic zero, so being a limit ' - 'point does not separate them. Two fences do. The order separates them globally, not ' + 'point does not separate them. The order separates them globally, not ' 'at zero: at zero neither has a first step, and globally ℝ is densely ordered ' '(axb1_fails_everywhere_iff_dense), in its norm preorder as in its field order, while the ' 'norm preorder on Q₂ is not; the norm-preorder facts are the § ROLE examples in ' - 'ZeroParadox/BottomCannotBe.lean. The topology is the second fence: ' + 'ZeroParadox/BottomCannotBe.lean. In the topology ' 'ℝ is connected (place_topological_signature), so not totally disconnected ' - '(real_no_snap), and Q₂ is totally disconnected (t5_totallyDisconnected).')) + '(real_no_snap), and Q₂ is totally disconnected (t5_totallyDisconnected); that ' + 'difference separates them too. It is not a separate fence against a first step: for a ' + 'linear order carrying its order topology, connectedness implies density (Mathlib ' + 'denselyOrdered_of_preconnectedSpace), so it adds no reason beyond density.')) E.append(cbody( 'Q₂ is not an exotic choice. Among all completions of the rationals, ' 'Ostrowski\'s theorem says there are exactly two kinds: Archimedean ones ' @@ -477,7 +503,8 @@ def footer_cb(canvas, doc): 'The framework did not choose unusual mathematics for its own sake. ' 'ZP-F shows that ordered fields are excluded, by density; ZP-B records that Q₂ is ' 'totally disconnected (t5_totallyDisconnected, an instance Mathlib already supplies), ' - 'which removes the topological obstruction. Neither supplies the first step at ⊥ ' + 'which removes the topological obstruction to an irreversible step (c3_irreversible: no ' + 'continuous path in Q₂ from a nonzero point to 0). Neither supplies the first step at ⊥ ' 'of the state carrier; that is AX-B1.')) E.append(cbody( 'A note on scope: ZP-F establishes this result for linearly ordered fields — ' @@ -488,17 +515,20 @@ def footer_cb(canvas, doc): 'frame for the ℝ comparison. The broader phenomenon is the same.')) E.append(sp(6)) E.append(key_result_box( - 'Where the Snap Fails', - 'The Binary Snap is impossible in ℝ: for any ε₀ > 0, ' - 'ε₀ / 2 also exists; ℝ is densely ordered, and in a dense order ' - 'no element has a first step. At zero Q₂ has none either, in its norm preorder; ' + 'Where the First Step Fails', + 'In ℝ, 0 has no first step above it, AX-B1\'s form (f_snap_impossible: no ' + 'linearly ordered field has a least positive element): for any ε₀ > 0, here ' + 'any positive real and not the ordinal, ε₀ / 2 also exists; ℝ is ' + 'densely ordered, and in a dense order no element has a first step. T-SNAP\'s shape does ' + 'not need one: t_snap_given holds at a step taken in a densely ordered join-semilattice. ' + 'At zero Q₂ has no first step either, in its norm preorder; ' 'globally that preorder is not dense, and Q₂ is totally disconnected where ' 'ℝ is connected. Its zero is ' 'distinguished in two charts: by its valuation, v₂(0) = +∞ while every ' 'non-zero element carries a finite valuation, and as a limit the doubling orbit ' 'approaches and does not reach in finite time. Neither supplies the first step AX-B1 ' 'commits to, a cover of ⊥ on the state carrier; t_snap_given_cover assumes the ' - 'run\'s first step is a cover, and with CC-1 (the run starts at ⊥) that step is a ' + 'run\'s first transition is a cover, and with CC-1 (the run starts at ⊥) that transition is a ' 'cover of ⊥. MachinePhase meets the commitment (c₁ covers its ⊥, ' 'c₀).')) diff --git a/scripts/build_zpg.py b/scripts/build_zpg.py index 15d0ee63..405db821 100644 --- a/scripts/build_zpg.py +++ b/scripts/build_zpg.py @@ -1,12 +1,12 @@ """ Zero Paradox — ZP-G: Category Theory PDF Builder -Version 1.23 | October 2026 +Version 1.27 | November 2026 """ import os from zp_utils import * -VERSION = '1.23' +VERSION = '1.27' FIRST_RELEASED = 'April 2026' # ZP-G uses a slightly different amber shade; override zp_utils default @@ -271,8 +271,10 @@ def build(): 'Remark R2 — Categorical Expression of Self-Containment', 'Status: Remark — connecting note to ZP-A CC-2', [ - 'R1 frames the structural inversion of 0. This remark connects that structure to ZP-A CC-2: ' - '⊥ = {⊥}: read this way, ⊥ is its own extension — a Quine atom. A self-containing object has ' + 'R1 frames the structural inversion of 0. This remark connects that structure to ZP-A CC-2, the Quine atom: ' + 'a role, a point that steps to itself and to nothing else (Motion.SelfOnlyAt, ZeroParadox/Die.lean). Where a set ' + 'steps to its members, a set occupies it exactly when x = {x} (zfset_selfOnlyAt_mem_iff); in a ZP-A lattice under a ' + 'self-application map supplied by AbstractSelfApp, ⊥ of L is its only occupant (selfApp_quine_role_iff). An occupant has ' 'no external interpreter by structure; it IS its own interpretation.', 'In categorical terms, this corresponds to two conditions together: (1) AX-G2: ' 'hom(X, 0) = ∅ for all X ≠ 0 — no morphism can reach inside 0 from outside; and ' @@ -284,7 +286,7 @@ def build(): 'ιX is not a choice among alternatives; it is the absence of internal ' 'structure that would allow differentiation among morphisms.', 'This remark bridges ZP-G to ZP-A CC-2. The formal correspondence between the categorical ' - 'initial object structure and the set-theoretic Quine atom ⊥ = {⊥} is made explicit in ZP-H.', + 'initial object structure and the Quine-atom role (ZP-A CC-2) is made explicit in ZP-H.', ] )) @@ -454,7 +456,10 @@ def build(): '(2) T6-c subadditivity — K(xn|x0) ≤ ' '∑ K(xk+1|xk) + O(n·c) (total surprisal along a chain). ' 'These are standard and correct results from algorithmic information theory, but they require ' - 'a K-formalization that does not exist in Lean 4 / Mathlib.', + 'a K-formalization this corpus does not have: none was located in the pinned Mathlib as of ' + '2026-10-04 (search record in ZeroParadox/Information/Disjunctive.md), Lean developments ' + 'outside Mathlib that define K are named at the ZPSurprisal entry of LEAN_CUSTOM_REGISTRY.md, ' + 'and leaving K unformalized here is a scope decision recorded there.', 'What IS Lean-verified: T6-a (identity morphism has zero surprisal — from surp_id), ' 'T6 Part II (inward surprisal is undefined — from AX-G2 and the absence of morphisms to 0), ' 'and T7 insofar as it depends on Parts II, III, V, VI. T6 Part I (outward accumulation) ' @@ -638,7 +643,7 @@ def build(): ['R1: Structural inversion', 'Valid — Remark. Unchanged.'], ['R2: Categorical expression of self-containment', - 'Valid — Remark. Connects T2 + AX-G2 to ZP-A CC-2 (⊥ = {⊥}). ' + 'Valid — Remark. Connects T2 + AX-G2 to ZP-A CC-2 (the Quine atom, a role). ' 'No new derivation; explanatory bridge note.'], ['Proposition T4: Chains are forward-only', 'Valid — Derived. Relabelled Proposition. Unchanged. ✓'], @@ -653,7 +658,9 @@ def build(): ['Proposition T6-c: Surprisal accumulates along chains', 'Valid (PDF-level) — Derived from D5, T6-b, subadditivity of K. ' 'NOT Lean-verified: Lean proof reduces to Nat.zero_le _. ' - 'Subadditivity of K is a standard AIT result but requires K-formalization absent from Mathlib.'], + 'Subadditivity of K is a standard AIT result but requires a formalization of K, none located ' + 'in the pinned Mathlib as of 2026-10-04 (the search is recorded in ' + 'ZeroParadox/Information/Disjunctive.md).'], ['Theorem T6: Informational singularity', 'Valid — Derived. Does not depend on BA-G1. ' 'Part II: undefined domain (AX-G2) — fully Lean-verified. ' diff --git a/scripts/build_zpg_companion.py b/scripts/build_zpg_companion.py index f8dd5525..0fd6b923 100644 --- a/scripts/build_zpg_companion.py +++ b/scripts/build_zpg_companion.py @@ -1,5 +1,5 @@ """ -Build ZP-G Illustrated Companion (v1.14) +Build ZP-G Illustrated Companion (v1.16) Standalone companion for ZP-G Category Theory only. ZP-H gets its own companion (build_zph_companion.py). @@ -139,7 +139,7 @@ def functor_diagram(): fontSize=8.5, fontName='DV-I', fillColor=colors.HexColor('#555555'))) return d -VERSION = '1.14' +VERSION = '1.16' FIRST_RELEASED = 'April 2026' @@ -258,7 +258,8 @@ def footer_cb(canvas, doc): # ── What ZP-G is doing ───────────────────────────────────────────────────── E.append(Paragraph('What Is ZP-G Doing?', CS['h1'])) E.append(cbody( - 'ZP-G constructs a single abstract category C whose structure captures everything ' + 'ZP-G does not build one particular category: it axiomatises a class of abstract categories (the class ' + 'ZPCategory), and a category C in that class has a structure that captures everything ' 'essential about the Zero Paradox: there is a privileged starting point (the initial ' 'object), all structure flows forward from it, and no morphism ever returns to it. ' 'These properties are stated as two axioms within ZP-G. The initial object is grounded in structure ' @@ -282,9 +283,11 @@ def footer_cb(canvas, doc): 'It does not hold in every category: in ModuleCat ℂ, the category of complex vector spaces, the zero ' 'space (the zero module fD_functor.obj 0) is a zero object, and every space has an arrow into it, the zero map.')) E.append(cbody( - 'The connection to ⊥ = {⊥}: ZP-A CC-2 characterizes ⊥ as a ' - 'Quine atom — ⊥ = {⊥}, meaning ⊥ is its own only member. ' - 'A self-containing object has no external interpreter: it IS its own interpretation. ' + 'The connection to the Quine atom: ZP-A CC-2 names a role, the ' + 'Quine atom: a point that steps to itself and to nothing else. Where a set steps to its ' + 'members, a set fills the role exactly when x = {x}, its own only member; in a ZP-A lattice under a ' + 'self-application map supplied by AbstractSelfApp, ⊥ is the only occupant. ' + 'An occupant has no external interpreter: it IS its own interpretation. ' 'In categorical terms, this is exactly what AX-G1 and AX-G2 together express: ' 'nothing can reach inside 0 from outside (AX-G2), yet 0 constitutes every object ' 'in C through a unique outgoing morphism (T2). ' diff --git a/scripts/build_zph.py b/scripts/build_zph.py index 3a7f7fd6..44cc31df 100644 --- a/scripts/build_zph.py +++ b/scripts/build_zph.py @@ -1,41 +1,12 @@ """ Zero Paradox — ZP-H: Categorical Bridge PDF Builder -Version 1.27 | October 2026 -v1.23: DECISION BATCH REMEDIATION ROUND 2 (Tim rulings, 2026-09-15): the T-H3 status said 'That the transition is taken remains a framework commitment, not a consequence of any of the four'; now the Snap occurring follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2), not from any of the four. -v1.22: OCCURRENCE COMMITMENT DEFINED, T5 RESTATED, T-SNAP RESIDUE (Tim decision batch, 2026-09-14): the occurrence commitment is instantiation occurs, and that the Snap occurs follows from it together with DA-1 (closed given DP-2). The ZP-E import line, the Open Items AX-1 row (whose status cell now reads 'the snap occurs given the occurrence commitment and DA-1'), the IR-ZP and IR-2 validation rows and the AX-1 validation row replace 'stated separately, as the occurrence commitment' / 'which ZP-E's DA-1 argues for' / 'occurrence is the occurrence commitment' with that sentence. The Open Items row says 'with no Lean kernel axioms' where it said 'with no axioms' (A4 and AX-B1 are called axioms on the same pages). T-SNAP's readable name 'Binary Snap Causality' is glossed once, at its first use in T-H3: 'Causality' refers to the shape of the step, not to its occurrence. -v1.21: AX-1 SPLIT (Tim, 2026-09-14): AX-1 bundled the SHAPE of the Snap with its OCCURRENCE. The shape half is Theorem T-SNAP; the occurrence half was never retired and is a framework commitment (tsnap_holds_but_nothing_moves). These sites said AX-1 whole was derived or no longer an axiom: the ZP-E import line, the Open Items AX-1 row ("Derived as Theorem T-SNAP ... No longer an axiom"), the IR-ZP and IR-2 validation rows, and the AX-1 validation row. Each now scopes the derivation to the shape half and names the occurrence half as a commitment. T-H3's own row, which says T-SNAP is inherited as a derived theorem, is unchanged: T-SNAP is the shape theorem. AX-1 WORDING CORRECTED (Tim, 2026-09-14): retired, split into T-SNAP (shape, proved) and the occurrence commitment (stated separately); the earlier 'occurrence half was never retired' was a paraphrase error. ROUND 2 GATES (Tim rulings: title, ZP-C label, DA-1 credit): the Open Items AX-1 row credited the shape to 'the P0 / L-RUN / TQ-IH / DA-1 chain'; DA-1 argues for occurrence, not the shape, so the row now carries Tim's sentence: the shape is proved as T-SNAP from L-RUN, TQ-IH and the bottom law with no axioms, and occurrence is the occurrence commitment, which ZP-E's DA-1 argues for. -v1.20:CC-1 STATUS SYNC (Tim, 2026-09-13: everything in one arc). "CC-1 derived / closed / no longer a freestanding commitment" collapsed two readings: cc1_derived proves the CONDITIONAL (a state sequence starting at a Quine atom starts at bottom), and with t_exec_iff the converse holds, so the starting-point choice is RESTATED through the Quine-atom role, not forced; every ZP-A lattice carries AFAStructure trivially. Every site now keeps both halves, matching ZP-J v2.7. The AX-G2 verification note no longer places a Lean result 'within the ZF+AFA setting'. ADVERSARY ROUND 1 (FAIL-BEDROCK, D1): that note's 'It remains a stated commitment, not a freestanding one' kept the retracted reading ('freestanding' is CLAIMS.md's word for a free modelling choice, which CC-1 is); it now says the check holds given CC-1. -v1.19: AX-B1 OVERCLAIM RETRACTED (bedrock). The closing line read "No novel axioms: AX-B1 decidable, AX-G1 and AX-G2 grounded in prior layers". AX-B1 is the framework's ONE substantive modelling commitment - discrete Boolean existence rather than a continuum of partial states - and the `decide` proof only checks the two states are distinct GIVEN the two-element type; it does not verify the commitment. The Foreword retracted this exact wording at v2.12; ZP-H was the surviving twin. -v1.18: FORCING OVERCLAIM RETRACTED (Remark R-FORCING). F_B was said to "force an irreversible jump at 0"; Valuation/Padic.lean retracts exactly that - the 2-adic topology proves irreversibility and a clopen gap, never a first step, and no metric result could. The closing "structurally forced across all four" now reads as the SHAPE being constrained; occurrence stays a framework commitment. -v1.16: Rendered version removed from endnote (C1 sweep — no version changelogs in rendered PDF content). -v1.15: CC-1 framing updated — CC-1 is a derived theorem in ZP-J (cc1_derived, Lean 4), -no longer a freestanding modelling commitment. -v1.14: K-13 vocabulary fix — "topological isolation" → "clopen separation" throughout; -updated DP-1 and related prose to use precise vocabulary. -v1.13: Version number removed from Open Items Register section header. -v1.12: Scaffolding note removed from preamble — "ZP-H cannot be written until ZP-G is internally -closed" was a development artifact not appropriate in a public document. -v1.11: Remark R-FORCING added between Sections V and VI — addresses the "renaming" concern; -explains that the four domain functors each independently ground the snap through their own -domain logic, verified sorry-free in Lean 4; structural forcing, not categorical re-description. -v1.10: fc_functor and fd_functor added — F_C and F_D now have concrete Lean Functor terms -(InfoDepth and HilbDimDepth appendices in ZPH.lean). OQ-G3 fully closed for all four functors. -C-H3/C-H4 status, OQ-G3 register, and Validation table updated to reflect sorry-free status. -v1.9: C-H3 AX-G1 no-terminal argument corrected — replaced "larger alphabets" appeal with -Lean-verified argument: ℝ≥0 has no greatest element (t + 1 > t), categorical expression of ZP-A R1. -v1.8: C-H1 AX-G2 verification note added — ⊥-to-0 identification depends on CC-1/DA-2. -v1.7: T-H3 consistency note strengthened — independence of null-analog discovery foregrounded. -v1.5: fb/fc/fd shared witness consolidated into nnreal_initial_grounding. -v1.4: OQ-G3 register updated — fb/fc/fd share proof term nnrealZPCategory.zpIsInitial. -v1.3: T-H3 cross-framework consistency caveat expanded. -v1.1: AX-1 updated to T-SNAP; Import Registry updated to ZP-G v1.1; OQ-G1 closed. -v1.0: Initial release. +Version 1.35 | November 2026 """ import os from zp_utils import * -VERSION = '1.27' +VERSION = '1.35' FIRST_RELEASED = 'April 2026' @@ -158,7 +129,7 @@ def build(): 'From ZP-E: Universal constituent cross-framework (T1). Hamming/JSD consistency (T2). ' 'Landauer bridge BA-1. Processing bounds T3. Unified Snap description T4. ' 'Iterative forcing T5. State representations T6. Zero Paradox T7. ' - 'T-SNAP: the shape of the Binary Snap is a derived theorem — AX-1 is retired, and that the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2).', + 'T-SNAP: the shape of the Binary Snap is a derived theorem — AX-1 is retired, and that the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII).', ] )) E.append(sp(8)) @@ -235,7 +206,7 @@ def build(): 'which has no greatest element (natZPCategory, ZeroParadox/Multihomed/CategoricalBridge.lean). ✓', 'AX-G2 respected: No join operation in L can return to ⊥ from a strictly larger state (ZP-A T3, ' 'monotonicity). Therefore FA sends no non-initial morphism to a map terminating at ⊥. ' - 'Note: this verification depends on CC-1 / DA-2 to identify L\'s ⊥ with C\'s initial object 0. ' + 'Note: this verification depends on CC-1 / DA-2 for FA to send C\'s initial object 0 to L\'s ⊥. ' 'CC-1 is restated in ZP-J, not forced: given AFAStructure, starting at a Quine atom and starting at ⊥ are the same condition (cc1_derived, t_exec_iff, Lean 4). The choice of starting point remains a ZP-A modelling commitment, so this check holds given CC-1. ✓', ] )) @@ -262,14 +233,14 @@ def build(): 'ZeroParadox/Multihomed/CategoricalBridge.lean). ✓', 'AX-G1 fails in TopCat: TopCat has a terminal object, the one-point space (the example after kleisli_bottom_not_terminal in ' 'ZeroParadox/Category/TreeSeam.lean). The TopCat realization fB_functor presents 0 as the limit of the shrinking balls, and that ' - 'floor {0} is itself a one-point space, terminal and not initial (padic_bottom_not_initial and the first example after it, ' + 'floor {0} is itself a one-point space, so it is terminal and not initial (padic_bottom_isTerminal and padic_bottom_not_initial, ' 'ZeroParadox/Multihomed/TreeObstructions.lean).', 'AX-G2 respected in the stand-in category: in Q₂BallDepth a morphism m → 0 means m ≤ 0, so m = 0 by antisymmetry ' '(q2BallZPCat). ZP-B C3, that no continuous path in Q2 returns to 0 from any non-zero element, is the domain analogue of ' 'this stand-in, proved in its own layer. ✓', 'AX-G2 in TopCat is stated at the initial object, which is not the floor {0}. TopCat\'s initial object is the empty space, and it ' - 'satisfies the AX-G2 shape: a space with a morphism into the empty space is empty, so it is isomorphic to it (the second example ' - 'after padic_bottom_not_initial in ZeroParadox/Multihomed/TreeObstructions.lean).', + 'satisfies the AX-G2 shape: a space with a morphism into the empty space is empty, so it is isomorphic to it (the example ' + 'after padic_bottom_isTerminal in ZeroParadox/Multihomed/TreeObstructions.lean).', ] )) E.append(sp(6)) @@ -319,7 +290,7 @@ def build(): 'Status: PDF construction complete — Lean: full functor (fd_functor, sorry-free)', [ 'Object map: FD sends each object of C to a state space: in Lean, with C realized as ℕ, object n goes to depth n of ' - 'HilbDimDepth (fd_functor.obj n) and to the module StateSpace n of ModuleCat ℂ (fD_functor.obj n).The initial object 0 maps to FD(0): depth 0 of HilbDimDepth ' + 'HilbDimDepth (fd_functor.obj n) and to the module StateSpace n of ModuleCat ℂ (fD_functor.obj n). The initial object 0 maps to FD(0): depth 0 of HilbDimDepth ' '(fd_functor.obj 0) and the zero module ℂ0 (fD_functor.obj 0). ZP-D\'s vector model reads a point x of Q2 as the ' 'vector T(x) ∈ H = ℂn, through the transition operator T: Q2 → H constructed in ZP-D (T2); there 0 of ' 'Q2 is read as the unit vector T(0) = e0 (ZP-D D2(i), met by T2), which ℂ0 does not contain, so the two ' @@ -334,7 +305,7 @@ def build(): 'fd_functor.map_comp and fD_functor.map_comp. ✓', 'Remark (ZP-D T5, not composition): every state vector is a unit vector by ZP-D D2(v), so along T(xA) → T(xB) → ' 'T(xC) the norms are all 1 and ZP-D T5\'s non-decreasing norms hold with equality.', - 'Preservation of identity: FD(idA) maps to the trivial orthogonal extension T(xA) → T(xA), which is the identity on the basis vector ek. ✓', + 'Preservation of identity: FD(idA) is the identity on FD(A), the functor law map_id of the Lean functors, fd_functor.map_id and fD_functor.map_id; in the vector model it is the trivial extension T(xA) → T(xA). ✓', 'In the vector model, T(0) = e0 (ZP-D D2(i), met by T2) is the anchor vector from which all other state vectors are orthogonal extensions.', 'AX-G1 respected in the stand-in category: the Lean functor fd_functor lands in HilbDimDepth, the ℕ-indexed dimension-depth ' 'category, which has no terminal object because the depth index has no maximum: n + 1 > n (hilbDimZPCat, ' @@ -375,7 +346,7 @@ def build(): 'FB: FB(0) = 0 ∈ Q2. For any x ∈ Q2, the unique morphism 0 → x is the discrete jump from 0 to x ' 'across the clopen boundary. Uniqueness: 0 is clopen-separated from all nonzero elements (ZP-B T3); the only clopen-respecting transition from 0 to x is the direct jump. ' 'This leg holds in the stand-in Q₂BallDepth (fb_preserves_initial, ZeroParadox/Multihomed/CategoricalBridge.lean). In TopCat it ' - 'does not: the floor {0} is terminal and not initial there (padic_bottom_not_initial and the first example after it, ' + 'does not: the floor {0} is a one-point space, so it is terminal and not initial there (padic_bottom_isTerminal and padic_bottom_not_initial, ' 'ZeroParadox/Multihomed/TreeObstructions.lean). ✓', 'FC: FC(0) = P = (1, 0). For any distribution PY, the unique morphism P → PY is the informational ' 'transition with work E = JSD(P ∥ PY). Uniqueness: JSD is symmetric and uniquely determined by P ' @@ -439,11 +410,13 @@ def build(): 'from 0 irreversible (it does not supply the departure — ZP-B cannot force the snap, and ' 'the first step is AX-B1); FC shows the information-theoretic transition costs exactly 1 bit; ' 'FD shows the Hilbert space snap is an orthogonal shift.', - 'That the same structural singularity appears across four independently grounded domain categories ' - '— each confirmed sorry-free in Lean 4 (fb_snap_q2_grounded, fc_snap_info_grounded, ' - 'fd_snap_hilb_grounded) — is not re-description. It is the theorem: the phenomenon\'s ' - 'shape is structurally constrained across all four canonical mathematical languages for ' - 'state description. That the transition is taken follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2), not from ' + 'That a transition of the snap\'s shape appears in each of the four domain categories, with the ' + 'groundings sorry-free in Lean 4 (the lattice conjunct join c0 c1 = c1 of ' + 'th3_snap_all_functors for FA; fb_snap_q2_grounded, fc_snap_info_grounded and ' + 'fd_snap_hilb_grounded for FB, FC and FD), ' + 'is more than re-description: in each of the four canonical mathematical languages for state ' + 'description, the phenomenon\'s shape is constrained by that domain\'s own structure. That the ' + 'four are one structural singularity is the framework\'s reading, not a theorem. That the transition is taken follows from the occurrence commitment together with DA-1 (closed given DP-2), not from ' 'any of the four.', ] )) @@ -475,10 +448,26 @@ def build(): 'framework located its null-analog through its own domain logic — ⊥ through A4 (ZP-A), ' '0 ∈ Q2 through T3 (ZP-B), P = (1,0) through D1/RP-1 (ZP-C) — prior to and without ' 'reference to the others. ZP-D\'s e0 is not independent in this sense: it is reached by transport ' - 'of ZP-B\'s 0 along T (ZP-D D2(i), T(0) = e0). The modeling commitment is the ' - 'identification of these independently-located objects under the functors, not the claim that ' - 'any domain forced the others\' choices. Their agreement confirms coherence across mathematical ' - 'representations of a shared foundation, not external replication. ' + 'of ZP-B\'s 0 along T (ZP-D D2(i), T(0) = e0). No identification of these objects is ' + 'made, under the functors or otherwise: they live in different types, and an equation across them ' + 'is ill-typed (MC-1, the bottom family). Where a shared role is checked, it is checked in one ' + 'framework at a time, and the occupant depends on the step chosen there. In the die ' + '(ZeroParadox/Die.lean) the role Motion.SelfOnlyAt is a point that steps to itself and to nothing ' + 'else. In ZP-A, under a self-application map supplied by AbstractSelfApp, ⊥ is its only ' + 'occupant by that class’s own fields (selfApp_quine_role_iff, ' + 'ZeroParadox/Settheory/QuineDichotomy.lean), which the constant map onto ⊥ also meets. In ZP-B, ' + 'under doubling, 0 is its only occupant, on the 2-adic integers (z2_double_selfOnlyAt_iff, ' + 'ZeroParadox/Ordinal/Incompleteness.lean) and on Q2 (the doubling example after ' + 'c_t_iz_null_balance, ZeroParadox/Valuation/SemilatticeInstance.lean). For ZP-C’s P = (1,0) and ZP-D’s e0 no die ' + 'statement was located as of 2026-11-03 (searched: every file under ZeroParadox/ for Motion, ' + 'SelfOnlyAt, NoStepAt and LeavesAt beside those objects). What the categorical bridge checks for ' + 'FC and FD is a different role, initiality: they send the initial object 0 to ' + 'the empty type Fin 0 and the zero module (fC_zero_isInitial, fD_zero_isInitial). On the empty type ' + 'no point occupies the die role at all (the control in ZeroParadox/Category/SeamComparisonMap.lean); ' + 'on the zero module, which has one point, every endomorphism has exactly one point that steps to itself ' + 'only (hilbert_zero_seam_role_unique), which restates that it is a zero object. ' + 'This is not the claim that any domain forced the others’ choices. Their agreement confirms ' + 'coherence across mathematical representations, not external replication. ' 'T-SNAP (Binary Snap Causality) is a derived ' 'theorem in ZP-E v2.0 and is inherited here with derived status. “Causality” in this name refers to the shape of the step, not to its occurrence. DP-1 remains the only design premise. ✓', ] @@ -549,7 +538,7 @@ def build(): 'Retired —\nshape: T-SNAP\n(ZP-E v2.0);\nthe snap occurs\ngiven the occurrence\ncommitment and DA-1', 'Binary Snap Causality. AX-1 is retired. Its content was split in two: the shape of the Snap is ' 'proved, as Theorem T-SNAP (from L-RUN, TQ-IH and the bottom law, with no Lean axioms), and that the Snap ' - 'occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2). ' + '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 occurrence.) T-H3 inherits T-SNAP as a derived result. Not a gap.'], ['AX-G1', 'Axiom —\ninitial half\nnot novel', @@ -620,7 +609,7 @@ def build(): 'Valid — from AX-B1, RP-1; all four requirements verified; AX-G1 and AX-G2 checked in the stand-in InfoDepth (KleisliCat PMF has a ' 'terminal object). Lean: full functor (fc_functor, sorry-free). ✓'], ['C-H4: FD: C → Hilb', - 'Valid — from DP-1; all four requirements verified; AX-G1 and AX-G2 checked in the stand-in HilbDimDepth (both fail in ModuleCat ' + 'Valid — the object map at 0 by assignment (ZP-D D2(i)), the morphism map from ZP-D D2(iii) and D2(iv), D2(iv) under DP-1; all four requirements verified; AX-G1 and AX-G2 checked in the stand-in HilbDimDepth (both fail in ModuleCat ' 'ℂ). Lean: full functor (fd_functor, sorry-free). ✓'], ['T-H1: Universal property preserved', 'Valid — OQ-G2 closed. ZP-G T5 is now unconditional for all four instantiation functors, for FB in its stand-in. ✓'], @@ -637,7 +626,7 @@ def build(): ['AX-1 (Binary Snap Causality)', 'Retired — the shape is derived as T-SNAP in ZP-E v2.0 and is no longer an axiom; ' 'T-H3 and all downstream results inherit the derived status for the shape. ' - 'That the Snap occurs is stated separately: it follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2).'], + 'That the Snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2).'], ['AX-G1, AX-G2', 'AX-G2 and the initial-object half of AX-G1 are grounded, not novel: AX-G2 by antisymmetry in categories built from a partial ' 'order with a least element, and it fails in ModuleCat ℂ (see the Open Items register). The no-terminal half of AX-G1 is ' @@ -662,7 +651,7 @@ def build(): 'fb_functor (Q₂BallDepth), fc_functor (InfoDepth), fd_functor (HilbDimDepth), FA via NatSLat | ' 'OQ-G3 fully closed | ' 'T-SNAP inherited as derived theorem | ' - 'T-H3 independence-of-discovery note: null-analog in each domain located independently | ' + 'T-H3 independence-of-discovery note: the null-analogs of ZP-A, ZP-B and ZP-C located independently, ZP-D’s e0 by transport of ZP-B’s 0 | ' 'AX-G2 and the initial-object half of AX-G1 are grounded in prior layers where they hold, and the no-terminal half of ' 'AX-G1 is ZP-G\'s own commitment; AX-B1 is the framework\'s one ' 'substantive modelling commitment — discrete Boolean existence rather than a ' diff --git a/scripts/build_zph_companion.py b/scripts/build_zph_companion.py index 79a2eaf0..7ae3ac0e 100644 --- a/scripts/build_zph_companion.py +++ b/scripts/build_zph_companion.py @@ -1,19 +1,5 @@ """ -Build ZP-H Illustrated Companion (v1.21) -v1.16: DECISION BATCH REMEDIATION (Tim, 2026-09-15): the T-H3 page said the transition 'was derived as a theorem (T-SNAP), not assumed as an axiom' and called the Binary Snap 'a structural fact that survives translation'; both are scoped to the shape with the canonical AX-1 sentence. -v1.15: CC-1 STATUS SYNC (Tim, 2026-09-13: everything in one arc). "CC-1 derived / closed / no longer a freestanding commitment" collapsed two readings: cc1_derived proves the CONDITIONAL (a state sequence starting at a Quine atom starts at bottom), and with t_exec_iff the converse holds, so the starting-point choice is RESTATED through the Quine-atom role, not forced; every ZP-A lattice carries AFAStructure trivially. Every site now keeps both halves, matching ZP-J v2.7. Four sites; the key-result box no longer calls CC-1 'not a free commitment' (ZP-A calls it a modelling choice). ROUND 1 (editorial + claim-review + adversary FAIL-BEDROCK; prior-art PASS): the sync first gave the wrong REASON for "not forced" ("every ZP-A lattice carries AFAStructure trivially, so ..."), which does not follow; the reason is that a valid state sequence can start above bottom (T2 fixes only bottom <= S0; an example on OntologicalStates in OntBridge.lean). Also CC-1 is 'the modelling commitment CC-1', not 'the structural identification CC-1', at three sites. -v1.13: Scope "any state change" to "transition from bottom state in this framework (ZP-C T1b)" — Category 5 precision fix. -v1.12: T-SNAP endpoint circles — open (white fill, colored stroke) with colored text for legibility. -v1.11: subtitle/footer 'Categorical Bridge' → 'Functor Coherence'; footer date April → May 2026. -v1.10: CC-1 described as derived (not free commitment) throughout; 'independent' → 'distinct'; T-H2 surprisal claim descoped. -v1.9: snap diagram — '(null)' → '(⊥)'; scope 'any sequence' to Q₂ in T-H2 prose; fix four_functor cy to constant. -v1.8: T-SNAP diagram — ε₀ Unicode label; shorten right-side framework labels; fix cy to constant. -v1.7: vocab fix: null state → ⊥. -v1.6: K-15 vocabulary fix — "topological isolation" → "clopen separation" in DP-1 description. -v1.5: Strip version number from companion footer. -v1.4: Add structural floor section — power set lattice as primary example; bridge to ZP-specific - structural floor; new section placed before morphism/functor content. -v1.3: Disclaimer updated — "formal ontology" replaced with "formal document"; "proven" → "proved". +Build ZP-H Illustrated Companion (v1.26) Standalone companion for ZP-H: Categorical Bridge only. ZP-G has its own companion (build_zpg_companion.py). @@ -143,7 +129,7 @@ def snap_convergence_diagram(): return d -VERSION = '1.21' +VERSION = '1.26' FIRST_RELEASED = 'April 2026' @@ -270,7 +256,7 @@ def footer_cb(canvas, doc): 'approached but not reached in finitely many steps: the doubling orbit of any nonzero point ' 'converges to 0 in the 2-adic metric (doubling_orbit_tendsto_zero) and still never lands on 0 ' 'at any finite step (padic_orbit_never_reaches_zero). That ⊥ has nothing below it holds in ' - 'every setting by A1–A4 (T1, T2); the four settings also share AX-B1 and the modelling ' + 'every setting by A1–A4 (ZP-A T1, T2); the four settings also share AX-B1 and the modelling ' 'commitment CC-1 (S₀ = ⊥, restated in ZP-J, not forced). ' 'ZP-H verifies that these four reasons are consistent.')) E.append(sp(6)) @@ -395,7 +381,7 @@ def footer_cb(canvas, doc): 'to exist by AX-G1 and to be unique by the definition of an initial object. ' 'In ZP-E, 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).')) + 'together with DA-1 (closed given DP-2). The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII).')) E.append(cbody( 'T-H3 shows that all four functors agree on what the Snap is:')) E.append(cbody( diff --git a/scripts/build_zph_native_addendum.py b/scripts/build_zph_native_addendum.py index d97a6ffd..923d5d07 100644 --- a/scripts/build_zph_native_addendum.py +++ b/scripts/build_zph_native_addendum.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-H Addendum: The Snap Floor in Native Categories -Version 1.7 | October 2026 +Version 1.14 | November 2026 Reads after ZP-H Categorical Bridge. """ import os from zp_utils import * -VERSION = '1.7' +VERSION = '1.14' FIRST_RELEASED = 'June 2026' # ── fix() guard: route all bare Paragraph() text through Unicode-to-entity conversion ── @@ -59,20 +59,35 @@ def build(): 'so that depth 0 is the initial object. This addendum does the stronger thing: it ' 'drops the snap floor into each framework\'s own category, taken directly from ' 'Mathlib, where the floor appears in that field\'s native syntax. A topologist, a ' - 'functional analyst, and a probabilist each meet the same bottom, each in their own ' - 'category and their own language.')) + 'functional analyst, and a probabilist each meet the floor in their own category and ' + 'their own language, in the role that category supports: the zero object, initial and ' + 'terminal, in ModuleCat ℂ (fD_zero_isInitial, fD_zero_isTerminal); an initial object ' + 'that is not terminal in the Kleisli category of PMF (fC_zero_isInitial, ' + 'kleisli_bottom_not_terminal); in TopCat the floor {0} is 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, ZeroParadox/Order/PadicLimitCone.lean). ' + 'The three full positions are stated together in floor_positions_full ' + '(ZeroParadox/Category/TreeSeam.lean: a zero object; initial and not terminal; terminal ' + 'and not initial). They are members of the bottom family (MC-1), and not one ' + 'object, since an equation across categories is ill-typed. mc1_correspondence bundles the ' + 'two initial objects, fC_no_return (no morphism into the floor from any later stage of the ' + 'functor), and the set equation in ' + 'Q2 fB_bottom_is_limit; floorConeIsLimit sits outside it.')) E.append(body( 'Three genuine Lean functors realize the snap chain inside the standard categories: ' 'F_B into TopCat (topological spaces), F_D into ModuleCat ℂ (ℂ-modules), ' 'and F_C into the Kleisli category of the probability monad PMF (stochastic maps). ' - 'Each is sorry-free, and each carries the snap floor to its category\'s categorical ' - 'bottom — an inverse limit in TopCat, an initial object in ModuleCat ℂ ' - 'and in the Kleisli category. The bundled witness is mc1_correspondence ' - '(MC1Bridge.lean).')) + 'Each is sorry-free. F_D and F_C send depth 0 to an initial object of their categories ' + '(fD_zero_isInitial, fC_zero_isInitial), and F_D\'s is terminal as well, a zero object ' + '(fD_zero_isTerminal); for F_B the floor {0} is the inverse limit of ' + 'its ball tower in TopCat (floorConeIsLimit), the limit of the functor\'s diagram rather ' + 'than an object in its image. The bundled witness is mc1_correspondence ' + '(MC1Bridge.lean); its F_B field is the set equation in Q2 beneath ' + 'that limit (fB_bottom_is_limit).')) E.append(body( 'Two honesty boundaries hold throughout. The realized claim is correspondence, ' - 'not identity. What is proved is that each bottom is its own category\'s ' - 'categorical bottom, agreeing on the snap; that the four bottoms are numerically ' + 'not identity. What is proved is, category by category, the characterization ' + 'named above, the floors agreeing on the snap; that the four bottoms are numerically ' 'one object is 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, for the named bottoms, in a lattice with no top). The native ' 'categories are the honest target. Mathlib has no bespoke category of p-adic ' 'spaces, Hilbert spaces, or information spaces, so the general-purpose categories ' @@ -103,8 +118,10 @@ def build(): 'ZeroParadox/Category/TreeSeam.lean). Of the categories on this page, AX-G1 holds only in the three ' 'depth-proxy categories, where the depth index has no maximum. So the snap floor cannot be "the initial object of a ' 'ZPCategory" here. The honest statement is the one each category supports natively: ' - 'in TopCat the floor is the limit of the shrinking system, and in ModuleCat ℂ ' - 'and the Kleisli category it is the genuine initial object. Each is stated below.')) + 'in TopCat the floor is terminal, since it has one point, and not initial, and separately ' + 'the limit of the shrinking system; in ModuleCat ℂ it is the ' + 'zero object (initial and terminal), and in the Kleisli category it is initial and not ' + 'terminal. Each is stated below.')) E.append(sp(6)) # ── Section II: F_B / TopCat ────────────────────────────────────────────────── @@ -131,20 +148,23 @@ def build(): 'larger.', '', 'fB_bottom_is_limit: ∩n B(0, 2−n) = {0}', - 'The snap floor is the inverse limit of the tower — the one point common ' - 'to every ball.', + 'The one point common to every ball is 0: a set equation in Q2.', + 'floorConeIsLimit (ZeroParadox/Order/PadicLimitCone.lean): the floor {0}, with the ' + 'inclusions into each ball, is a limit cone, so the snap floor is the inverse limit ' + 'of the tower in TopCat; fB_limit_iso_floor identifies Mathlib\'s limit object with it.', 'Sorry-free. Purity [propext, Classical.choice, Quot.sound].', ] )) E.append(sp(4)) E.append(body( 'TopCat has both a terminal object (the one-point space) and an initial object (the ' - 'empty space). The snap floor {0} is a one-point space, so it is terminal (the first example after ' - 'padic_bottom_not_initial in ZeroParadox/Multihomed/TreeObstructions.lean) and not initial ' + 'empty space). The snap floor {0} is a one-point space, so it is terminal (padic_bottom_isTerminal, ' + 'ZeroParadox/Multihomed/TreeObstructions.lean) and not initial ' '(padic_bottom_not_initial). It is also the limit of the ball tower ' - '— the categorical expression a topologist would expect for "the point ' + '(floorConeIsLimit) — the categorical expression a topologist would expect for "the point ' 'everything converges to." This is the honest realization in a category that is not ' - 'a ZPCategory: not an initial object, but a limit.')) + 'a ZPCategory: not an initial object: terminal, since it has one point, and separately ' + 'a limit.')) E.append(sp(6)) # ── Section III: F_D / ModuleCat ℂ ──────────────────────────────────────────── @@ -193,10 +213,13 @@ def build(): E.append(body( 'The information layer measures the snap as one bit of divergence between ' 'distributions (ZP-C, JSD = log 2). Its native category is the Kleisli category of ' - 'the finite-distribution monad PMF: objects are finite types, and a morphism A ' - '→ B is a stochastic map (a Markov kernel), assigning to each a ∈ A a ' - 'probability distribution on B. Mathlib supplies this category for free, since PMF ' - 'is a lawful monad.')) + 'the probability-mass-function monad PMF: its objects are types, finite or not (PMF is ' + 'defined on any type), and a morphism A → B is a stochastic map (a Markov kernel), ' + 'assigning to each a ∈ A a probability distribution on B; the functor uses only ' + 'finite ones, the types Fin n. Mathlib supplies this category for free, since PMF ' + 'is a lawful monad; it is a Markov category in the sense of Fritz (T. Fritz, A synthetic ' + 'approach to Markov kernels, conditional independence and theorems on sufficient ' + 'statistics, Adv. Math. 370 (2020) 107239, arXiv:1908.07021, Cor. 3.2 and fn. 10).')) E.append(result_box( 'Functor: fC_functor : ℕ → KleisliCat PMF (InfoFunctor.lean)', [ @@ -207,7 +230,7 @@ def build(): 'fC_zero_isInitial: Fin 0 (the empty type) is the initial object.', 'fC_no_return: for n > 0 there is NO stochastic map Fin n → Fin 0.', 'AX-G2 as a theorem: no probability distribution lives on the empty type, so ' - 'nothing returns to the floor.', + 'no later stage returns to the floor.', 'Sorry-free. Purity [propext, Classical.choice, Quot.sound].', ] )) @@ -216,8 +239,10 @@ def build(): 'The empty type is the snap floor here, and it carries the snap\'s irreversibility ' 'for free. A stochastic map into Fin 0 would be a probability distribution on the ' 'empty type, and there is none. So while every object has a unique map out of ' - 'Fin 0 (it is initial), no nonempty object has any map back — AX-G2 ' - '(source asymmetry) is not assumed but proved, as fC_no_return. Of the three native ' + 'Fin 0 (it is initial), no later stage Fin n with n > 0 has any map back — AX-G2 ' + '(source asymmetry) is not assumed but proved, as fC_no_return. For the same reason Fin 0 ' + 'is not terminal: a terminal object needs a map into it from every object, and Fin 1 has ' + 'none (kleisli_bottom_not_terminal). Of the three native ' 'categories, this is the one where the framework\'s irreversibility axiom becomes a ' 'theorem of the ambient mathematics.')) E.append(sp(6)) @@ -230,23 +255,30 @@ def build(): hr(), ] E.append(body( - 'The three functors, together with F_A (the join-semilattice ℕ of the main ' - 'document, where 0 is already the initial object), are bundled as a single witness.')) + 'The fields below are bundled as a single witness, mc1_correspondence; the TopCat limit ' + 'cone floorConeIsLimit is named beside them, outside the bundle, and F_A (the ' + 'join-semilattice ℕ of the main document, where 0 is already the initial object) ' + 'is not a field of it.')) E.append(result_box( 'Definition: mc1_correspondence : MC1Correspondence (MC1Bridge.lean)', [ 'A record collecting the native-category realizations:', - '• F_D: StateSpace 0 is initial in ModuleCat ℂ.', - '• F_C: Fin 0 is initial in KleisliCat PMF, with no return morphism.', - '• F_B: the clopen-ball tower has inverse limit {0} in TopCat.', + '• F_D: StateSpace 0 is initial in ModuleCat ℂ; it is terminal as well, the ' + 'zero object (fD_zero_isTerminal, outside the bundle).', + '• F_C: Fin 0 is initial in KleisliCat PMF, with no morphism into it from any ' + 'later stage of the functor (fC_no_return).', + '• F_B: the clopen balls meet in exactly {0}, a set equation in ' + 'Q2 (fB_bottom_is_limit); the limit cone in TopCat is floorConeIsLimit, ' + 'outside the bundle.', 'Sorry-free. Purity [propext, Classical.choice, Quot.sound].', ] )) E.append(sp(4)) E.append(body( 'This settles the correspondence half of MC-1: across the native categories, ' - 'the snap floor is each category\'s own categorical bottom, and the four agree on ' - 'the snap. The identity half, that the algebraic ⊥, the 2-adic 0, the ' + 'the snap floor is realized by each category\'s own characterization (the zero object in ' + 'ModuleCat ℂ; initial and not terminal in the Kleisli category; in TopCat terminal, since ' + 'it has one point, and not initial, and separately the inverse limit of the ball tower), and the four agree on the snap. The identity half, that the algebraic ⊥, the 2-adic 0, the ' 'zero module, and the empty type are numerically one object, is 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 ' @@ -271,11 +303,17 @@ def build(): 'Lean Source Files', [ 'TopFunctor.lean — fB_functor, fB_bottom_is_limit (F_B into TopCat).', + 'PadicLimitCone.lean — floorCone, floorConeIsLimit, fB_limit_iso_floor (the ' + 'TopCat limit cone).', 'HilbFunctor.lean — fD_functor, fD_zero_isInitial, fD_embed_inner ' '(F_D into ModuleCat ℂ).', 'InfoFunctor.lean — fC_functor, fC_zero_isInitial, fC_no_return ' '(F_C into KleisliCat PMF).', 'MC1Bridge.lean — mc1_correspondence (the bundled witness).', + 'TreeSeam.lean — floor_positions_full (the three full positions: a zero ' + 'object; initial and not terminal; terminal and not initial), fork_positions_distinct, ' + 'kleisli_bottom_not_terminal; TreeObstructions.lean — padic_bottom_isTerminal, ' + 'padic_bottom_not_initial, fD_zero_isTerminal.', 'All in ZeroParadox/ in the public repository.', ] )) @@ -284,9 +322,17 @@ def build(): E.append(Paragraph( 'Endnote: This document is an addendum to ZP-H Categorical Bridge and reads after ' 'it. ZP-H locates the snap floor as the categorical bottom across four frameworks ' - 'using depth-index proxy categories; this addendum realizes the same floor inside ' - 'each framework\'s native Mathlib category — TopCat, ModuleCat ℂ, and ' - 'the Kleisli category of distributions. All results sorry-free in Lean 4 as of June ' + 'using depth-index proxy categories; this addendum realizes the floor inside each ' + 'framework\'s native Mathlib category by that category\'s own characterization ' + '— in TopCat the floor {0}, terminal since it has one point and not initial ' + '(padic_bottom_isTerminal, padic_bottom_not_initial), and separately the inverse limit of ' + 'the ball tower (floorConeIsLimit, outside the bundle); the zero object in ModuleCat ' + 'ℂ; and an initial object that is not terminal in the Kleisli category of ' + 'distributions (fC_zero_isInitial, kleisli_bottom_not_terminal); the three full positions ' + 'are stated together in floor_positions_full; mc1_correspondence ' + 'bundles the two initial objects, fC_no_return (no morphism into the floor from a later ' + 'stage), and the set equation in Q2 fB_bottom_is_limit; ' + 'floorConeIsLimit sits outside it. The floors are not one object, since an equation across categories is ill-typed. All results sorry-free in Lean 4 as of November ' '2026, footprint [propext, Classical.choice, Quot.sound].', S['endnote'])) diff --git a/scripts/build_zpi.py b/scripts/build_zpi.py index 850d00f7..99ca2e11 100644 --- a/scripts/build_zpi.py +++ b/scripts/build_zpi.py @@ -1,12 +1,12 @@ """ Zero Paradox — ZP-I: Inside Zero PDF Builder -Version 1.28 | October 2026 +Version 1.44 | November 2026 """ import os from zp_utils import * -VERSION = '1.28' +VERSION = '1.44' FIRST_RELEASED = 'April 2026' # ZP-I uses justified body text; override the left-aligned zp_utils defaults @@ -95,14 +95,17 @@ def build(): 'is a separate carrier. No ' 'new axioms are required for what it PROVES, which is that convergence, together with the ' 'separate fact that anything filling the bottom role IS the bottom of its own semilattice. ' - 'Reading the 2-adic limit as the thing filling that role is a modelling commitment, not a ' - 'theorem: the two live in different types, and Q2’s field structure supplies no join and the corpus defines none on Q2, so the role ' - 'condition is not statable of the limit at all — they are distinct MEMBERS of the bottom ' + 'Reading the 2-adic limit as the thing filling that role takes a choice, not a ' + 'theorem: the two live in different types, and Q2’s field structure supplies no join and the corpus registers none on Q2, so the role ' + 'condition is not statable of the limit until a join on Q2 is chosen — they are distinct MEMBERS of the bottom ' 'family, not one object, and that identity is retired as ill-typed (MC-1). ' + 'Choosing a join on Q2 is well-typed, and in the semilattice it makes, anything filling the bottom role is ' + 'that semilattice’s ⊥ by theorem (t_iz_limit_is_new_null); what is retired is identifying the 2-adic 0 with ' + '⊥ of another semilattice. ' 'Reading the bottom so reached as a NEW one ' 'rather than the one already there is a further commitment (C-DA2 in ZP-E), and in the 2-adic ' - 'chart the arc returns to the SAME 0 (snap_arc_z2_loop). T-IZ extends T-SNAP: where T-SNAP fixes the shape of the first transition ' - '⊥ → ε0, and not that it is taken, T-IZ establishes, for a depth index that climbs at every step, ' + 'chart the arc returns to the SAME 0 (snap_arc_z2_loop). T-IZ and T-SNAP are separate results: T-SNAP fixes the shape of the first transition ' + '⊥ → ε0, and not that it is taken; T-IZ establishes, for a depth index that climbs at every step, ' 'that the 2-adic chain the IsDepthChain modelling commitment links to it converges to 0, as a Cauchy sequence result.')) E.append(body( 'The key insight: the no-top property is not an obstacle to T-IZ. In a carrier that has it ' @@ -139,8 +142,9 @@ def build(): 'section below); one label over two propositions is a citation nothing can check. What no-top ' 'supplies is ROOM: a chain never halts for want of a strictly greater element. The ascent ' 'itself is IsStrictStateSequence — see the NO-GO gauge in §Ib. Reading the limit as ' - 'occupying the bottom role is a commitment, and calling the occupant a successor null is ' - 'C-DA2, a further one.')) + 'filling the bottom role takes a choice of join on Q2 (then it is that semilattice’s ' + '⊥ by theorem, t_iz_limit_is_new_null), and reading the occupant as a successor null is ' + 'C-DA2, a commitment.')) E.append(body( 'The reasoning is direct. An ascending chain (Sn)n<ω in L ' 'is a sequence satisfying Sn ≤ Sn+1 for all n (ZP-A T3 — monotonicity). ' @@ -174,8 +178,9 @@ def build(): 'the direction of that index is monotonicity (ZP-A T3) and irreversibility (ZP-B C3). ' 'Neither is a clock. ' 'What the chain reaches at the limit ordinal ω, after ω state changes, is Q2’s 0, ' - 'and not at any clock time. Reading that 0 as filling the bottom role is a commitment, and reading it ' - 'as a NEW bottom rather than the same one is a further commitment (C-DA2).')) + 'and not at any clock time. Reading that 0 as filling the bottom role takes a choice of join on ' + 'Q2 (then it is that semilattice’s ⊥ by theorem, t_iz_limit_is_new_null), and ' + 'reading it as a successor null is C-DA2, a commitment.')) E.append(body( 'Remark R-I.1: ω is the first infinite ordinal — the smallest ordinal greater than ' 'every natural number. An ascending chain indexed by ω is a countable sequence with ' @@ -239,7 +244,7 @@ def build(): '(1) The norms ‖S(n)‖2 → 0 (squeeze between 0 and the ' 'geometric sequence 2-n, both tending to 0).', '(2) S(n) → 0 in Q2 (norm → 0 iff sequence → 0 in a normed group).', - 'Lean: t_iz_cauchy — proved (sorry-free) in SemilatticeInstance.lean; footprint carries Classical.choice inherited from Mathlib’s p-adic analysis (see § III). This is the topological core of T-IZ.', + 'Lean: t_iz_cauchy — proved (sorry-free) in SemilatticeInstance.lean; carries Classical.choice (§ III). This is the topological core of T-IZ.', ] )) E.append(sp(6)) @@ -306,16 +311,16 @@ def build(): E.append(sp(6)) E.append(body( 'Remark R-II.2: The formal spine of T-IZ is Steps 1 and 6. Step 1 (Cauchy convergence ' - 'to 0 in Q2, t_iz_cauchy) is proved in Lean carrying Classical.choice from Mathlib’s ' - 'p-adic analysis. Step 6 (anything filling the ⊥ ROLE IS that lattice’s ⊥) ' + 'to 0 in Q2, t_iz_cauchy) is proved in Lean and carries Classical.choice (§ III). ' + 'Step 6 (anything filling the ⊥ ROLE IS that lattice’s ⊥) ' 'is proved axiom-free in Lean via t_iz_limit_is_new_null — ' 'which establishes the role identification ONLY and must not be cited as a witness for the ' 'successor reading (t_iz_limit_is_new_null, declared in ZeroParadox/Valuation/SemilatticeInstance.lean and indexed in ZeroParadox/Order/SnapCannotBe.lean). ' '• The two steps are not joined. Step 1 is about 0 ∈ Q2; Step 6 is about a ' 'terminal in a semilattice L′, and takes the role property as its hypothesis h_role. ' 't_iz_complete conjoins them without identifying the two objects, and the identification is ' - 'not merely unproved — Q2’s field structure supplies no join and the corpus defines none on Q2, so the role condition cannot be ' - 'stated of the limit at all. That junction is not an open gap: the 0 of Q2 and the ' + 'not merely unproved — Q2’s field structure supplies no join and the corpus registers none on Q2, so the role condition cannot be ' + 'stated of the limit until a join on Q2 is chosen. That junction is not an open gap: the 0 of Q2 and the ' 'algebraic ⊥ are distinct MEMBERS of the bottom family, and the cross-category identity ' 'is retired as ill-typed rather than outstanding (MC-1, CLAIMS.md). Steps 2–5 describe the original ' 'ZP-E informational argument connecting 2-adic depth to Kolmogorov complexity and DA-1 ' @@ -339,9 +344,9 @@ def build(): 'Statement: Every 2-adic depth chain (Sn)n<ω in Q2, ' 'nowhere zero, whose valuation equals a depth index in ℕ that climbs at every step, so that ' 'its 2-adic valuation grows without bound, is a Cauchy sequence that converges, in the 2-adic metric, to 0. ' - 'Reading that limit as an OCCUPANT of the bottom role is a modelling commitment and not ' - 'part of the statement — Q2’s field structure supplies no join and the corpus defines none on Q2, so the role condition is not ' - 'statable of it. Reading that occupant as a SUCCESSOR null is C-DA2, a further commitment.', + 'Reading that limit as an OCCUPANT of the bottom role takes a choice and is not ' + 'part of the statement — Q2’s field structure supplies no join and the corpus registers none on Q2, so the role condition is not ' + 'statable of it. Reading that occupant as a SUCCESSOR null is a commitment (C-DA2).', 'Formal hypotheses (t_iz_complete): S : ℕ → Q2 with ' '‖S(n)‖2 ≤ 2-n for all n; for S(n) ≠ 0 this is v2(S(n)) ≥ n, and at S(n) = 0 it ' 'matches only under the convention v2(0) = ∞ (Mathlib’s valuation of 0 is 0). ' @@ -373,7 +378,7 @@ def build(): E += [ li('Step 1 — Cauchy convergence: The 2-adic depth chain has ‖S(n)‖2 ≤ 2-n ' '(from v2(S(n)) ≥ n — Lean-derived via h_strict_from_r1_t3 given IsDepthChain; R-IZ-A closed). ' - 'By T-IZ-A (§ II.A), S(n) → 0 in Q2. Proved in Lean: t_iz_cauchy (carries Classical.choice from Mathlib p-adic analysis, § III). ✓'), + 'By T-IZ-A (§ II.A), S(n) → 0 in Q2. Proved in Lean: t_iz_cauchy (carries Classical.choice, § III). ✓'), li('Step 2 — Valuation-complexity bridge (REFUTED): the claim that v2(S(n)) → ∞ ' 'gives K(S(n)|n)/|S(n)| → 1 fails at S(n) = 2n, whose valuation is n and whose ' 'complexity given n is bounded (§ II.B). ' @@ -381,7 +386,7 @@ def build(): li('Step 3 — P0 at the limit (informational context): ZP-C D1’s threshold ' 'K(c1|n)/|c1| = 1. Step 2 is this step’s only route from the chain to that ' 'threshold, and with Step 2 refuted nothing here establishes that the limit meets the threshold.'), - li('Occurrence fence. T-SNAP fixes the SHAPE of each step. It does not establish that any step is taken: tsnap_holds_but_nothing_moves exhibits a model in which T-SNAP holds and nothing moves. Throughout this document, "fires" narrates the commitment that instantiation occurs - before this note as well as after it - not a consequence of the theorem.'), + li('Occurrence fence. T-SNAP fixes the SHAPE of each step. It does not establish that any step is taken: tsnap_holds_but_nothing_moves exhibits a model in which T-SNAP holds and nothing moves. Throughout this document, "fires" narrates the occurrence commitment - before this note as well as after it - not a consequence of the theorem.'), li('Step 4 — DA-1, CONDITIONALLY: DA-1 needs DP-2 and DP-2’s precondition, that the configuration ' 'reaching P0 is there in Sense B (a running machine’s current configuration) and not in ' 'Sense A (an inert string); that precondition is what the occurrence commitment asserts, and DA-1 ' @@ -399,9 +404,12 @@ def build(): '∀ x, S ∨ x = x IS the ⊥ of its own lattice. ' 'That the Cauchy limit 0 ∈ Q2 satisfies that condition is a HYPOTHESIS, never a result: ' 't_iz_complete takes it as the argument h_role, about a terminal in a separate semilattice L′, ' - 'and does not identify that terminal with the limit. Q2’s field structure supplies no join, and the corpus defines none on Q2 — ' - 'its ring structure supplies none with 0 as bottom (ZeroParadox/Valuation/ScaleBridge.lean) — ' - 'so the condition is not statable there. ' + 'and does not identify that terminal with the limit. Q2’s field structure supplies no join, and the corpus registers none on Q2. ' + 'For the 2-adic integers ℤ2 one with 0 as bottom is built but not registered, ' + 'where 0 meets the condition because it was chosen as the bottom ' + '(ZeroParadox/Valuation/Scale.lean § V); on Q2 the condition is stated of no ' + 'structure the corpus registers (that some join on Q2 makes any chosen point its bottom is the ' + 'first CONTROL example after c_t_iz_null_balance, ZeroParadox/Valuation/SemilatticeInstance.lean). ' 'Lean: t_iz_limit_is_new_null, proved directly from da2_bottom_characterization. ✓ — ' 'the checkmark covers the ROLE identification only, and only inside L′. It is NOT a novelty witness and must not be cited as one; reading the occupant as the ⊥ of a SUCCESSOR instantiation is C-DA2.'), sp(4), @@ -419,7 +427,7 @@ def build(): '— a separation result that says nothing about a valuation growing. ' 't_iz_cauchy itself binds none of them, and no lattice at all.', 'Follows from existing structure — no new axiom', - 'Lean: t_iz_cauchy ✓ (proved; carries Classical.choice, Mathlib p-adic)'], + 'Lean: t_iz_cauchy ✓ (proved; carries Classical.choice, § III)'], ['‖S(n)‖2 → 0 (Cauchy limit = 0)', 'The geometric norm bound alone. Completeness of Q2 is NOT consumed here: the ' 'limit is exhibited as 0 rather than obtained from a Cauchy criterion, so the proof runs ' @@ -430,7 +438,7 @@ def build(): 'Strict ascent (IsStrictStateSequence) + IsDepthChain (the valuation tracks the depth index). ' 'NOT no-top: a chain can satisfy HasNoTop and IsDepthChain with its valuation BOUNDED.', 'Follows from strict ascent + T3 — no-top supplies the room, not the growth', - 'Lean: t_iz_valuation_unbounded ✓ (proved; carries Classical.choice, Mathlib p-adic)'], + 'Lean: t_iz_valuation_unbounded ✓ (proved; carries Classical.choice, § III)'], ['v2 → ∞ ⟹ K/|S| → 1 (REFUTED)', 'Counterexample Sn = 2n: valuation n (scaleChain_isDepthChain), ' 'complexity given n bounded by the length of one fixed program printing 2n from n (not Lean)', @@ -448,14 +456,14 @@ def build(): 'Lean: t_snap_derived ✓ (axiom-free)'], ['The limit occupies the ⊥ role (READING; ⊥\' a further READING)', 'DA-2 (ZP-E)', - 'Role-recognition: already in framework. Occupancy and novelty: COMMITMENTS', + 'Role-recognition: already in framework. Occupancy: takes a choice of join. Novelty: COMMITMENT (C-DA2)', 'Lean: t_iz_limit_is_new_null, c_da2_novelty ✓ — these prove role ⟹ identity with the ' 'bottom ALREADY THERE. Neither is a novelty witness and neither may be cited as one.'], ] E.append(data_table( ['Claim', 'Source', 'New axiom?', 'Lean status'], proof_rows, - [TW*0.26, TW*0.26, TW*0.24, TW*0.24] + [TW*0.20, TW*0.36, TW*0.16, TW*0.28] )) E.append(sp(6)) @@ -475,8 +483,12 @@ def build(): 'Polynomial (ZMod 5) is no kind of completion and reports the same footprint, while ZMod 5 ' 'reports [propext, Quot.sound]. Mathlib’s analytic lemmas (squeeze_zero, the ' 'geometric-limit lemma, tendsto_zero_iff_norm_tendsto_zero) carry it too, so the ' - 'footprint cannot separate the two. ⚠ A footprint is a fact about the PROOF, never about the ' - 'type: the same statement (1 : ℚ) ≠ 0 reports Classical.choice through one_ne_zero ' + 'footprint cannot separate the two. ⚠ A footprint follows the STATEMENT and the PROOF. A ' + 'statement whose type carries choice reports it under every proof (the statement control on ' + 'tower_converges_to_zero, ZeroParadox/Ordinal/SyntacticCollapse.md; decoration_unique, ' + 'ZeroParadox/Settheory/APG.lean); a statement that does not can still report it through its proof. ' + 'Switching carrier from Q2 to the rationals ℚ for the proof half: the statement ' + '(1 : ℚ) ≠ 0 reports Classical.choice through one_ne_zero ' 'and [propext, Quot.sound] through decide. ⚠ The corpus’s choice-free valuation facts are NOT a ' 'counterexample here: v2_bot is [propext] because v2 : ℕ → ℕ∞ is stated over ' 'the NATURALS, so that contrast is between two carriers and not between algebra and analysis. ' @@ -494,13 +506,13 @@ def build(): E += [ li('t_iz_limit_is_new_null: anything satisfying the DA-2 ⊥ role IS that lattice’s ⊥ ' '(the structural core of the snap-arc; axiom-free). The role property is its HYPOTHESIS; ' - 'that the Cauchy limit satisfies it is not established here, and is not statable in Q2.'), + 'that the Cauchy limit satisfies it is not established here, and is not statable of the limit until a join on Q2 is chosen.'), li('c_t_iz_null_balance: a non-bottom state cannot satisfy the ⊥ role (choice-free, [propext]).'), - li('t_iz_cauchy: a sequence in Q2 with ‖S(n)‖2 ≤ 2-n converges to 0 (topological core; carries Classical.choice from ' - 'Mathlib’s p-adic convergence, not a framework commitment).'), - li('t_iz_valuation_unbounded: sup v2(S(n)) = ∞ (carries Classical.choice, Mathlib p-adic).'), + li('t_iz_cauchy: a sequence in Q2 with ‖S(n)‖2 ≤ 2-n converges to 0 (topological core; carries Classical.choice, ' + 'as measured above; not a framework commitment).'), + li('t_iz_valuation_unbounded: sup v2(S(n)) = ∞ (carries Classical.choice, as measured above).'), li('t_iz_c3_compatible: C3 irreversibility is preserved — Cauchy sequences ≠ continuous paths ' - '(carries Classical.choice, Mathlib p-adic).'), + '(carries Classical.choice, as measured above).'), li('t_iz_h_bound_from_depth_chain: h_bound derived from THREE hypotheses, of which exactly one is a ' 'ZP-A lattice condition — IsStrictStateSequence, and it is a condition on the DEPTH INDEX. The ' 'other two live in Q2: that the chain is nowhere zero, and IsDepthChain, the BRIDGE ' @@ -517,8 +529,8 @@ def build(): sp(4), ] E.append(derived( - 'Status: DERIVED THEOREM — formal spine: t_iz_cauchy (Step 1, proved; carries Classical.choice ' - 'from Mathlib p-adic analysis) + ' + 'Status: DERIVED THEOREM — formal spine: t_iz_cauchy (Step 1, proved; carries Classical.choice, ' + '§ III) + ' 't_iz_limit_is_new_null (Step 6, axiom-free via DA-2). These two steps ' 'are the formal spine, carried as a conjunction and not joined to one another. ' 't_iz_valuation_unbounded, c_t_iz_null_balance, t_iz_c3_compatible also proved. ' @@ -595,13 +607,16 @@ def build(): 'algebraic subtraction, no continuous topological return, no categorical reversal. ' 'T-IZ governs what happens at the branch\'s ordinal limit: the 2-adic depth chain converges, by Cauchy ' 'convergence, to 0 ∈ Q2 — a structure that none of the irreversibility ' - 'results governs or addresses. Reading that 0 as filling the bottom role is a commitment, and ' - 'reading it as a successor null is C-DA2, a further one.')) + 'results governs or addresses. Reading that 0 as filling the bottom role takes a choice of join on ' + 'Q2 (then it is that semilattice’s ⊥ by theorem, t_iz_limit_is_new_null), and ' + 'reading it as a successor null is C-DA2, a commitment.')) E.append(callout( 'The inside approach is not a violation of irreversibility. It is the discovery of a ' 'structure that irreversibility does not reach. Three doors to zero are closed (R1, C3, ' 'AX-G2). T-IZ uses a fourth passage — Cauchy sequence convergence — that none of the ' - 'three irreversibility theorems govern.', + 'three irreversibility theorems govern. (A picture, not a theorem: the three doors are statements about ' + 'three different objects, and the fourth passage reaches 0 ∈ Q2 only as a limit; reading that 0 ' + 'as filling the bottom role takes the choice of join stated above.)', bg=GREEN_LITE, border=GREEN_DARK )) E.append(sp(6)) @@ -645,9 +660,9 @@ def build(): E.append(body( 'The null balance 0 + x + (−x) = 0 is an arithmetic READING of the cycle of an ' 'instantiation branch, never a theorem of the structure: a ZPSemilattice carries join and ' - '⊥ and no additive inverse, so the identity is not statable there at all. The cycle it reads ' + '⊥ and no additive inverse, so the identity is not statable in that signature. The cycle it reads ' 'is itself a reading; its premises are stated in § V.III. As a reading the balance strings its ' - 'three terms across ω state changes: the branch begins at ⊥ (0), generates ' + 'three terms across ω state changes: the branch begins at its semilattice’s ⊥ (read as the 0 of the balance), generates ' 'ε0 and successors (+x), and at the ordinal limit the 2-adic chain converges to ' 'Q2’s 0 (−x).')) E.append(body( @@ -660,7 +675,7 @@ def build(): 'DISTINCT ⊥\' rather than the ⊥ it began at is C-DA2, and in the ' '2-adic realization the arc returns to the same 0 (snap_arc_z2_loop).')) E.append(callout( - 'Null Balance (role-RECOGNITION derived; occupancy and novelty COMMITTED): For every sequence ' + 'Null Balance (role-RECOGNITION derived; occupancy takes a choice of join; novelty COMMITTED): For every sequence ' '(Sn)n<ω in Q2, nowhere zero, with ‖S(n)‖2 ≤ 2-n ' '(derived via t_iz_h_bound_from_depth_chain from IsDepthChain and IsStrictStateSequence on a depth index in ℕ — R-IZ-A closed): ' 'the sequence converges to 0 in Q2. CC-1’s start at ⊥ belongs to the semilattice chain, not to S. ' @@ -681,8 +696,8 @@ def build(): 't_iz_cauchy), together with the separate implication that anything filling the bottom ' 'role of a semilattice IS that semilattice’s ⊥ (t_iz_limit_is_new_null). For the cycle to ' 'begin again or close at the limit, it needs every one of the following further premises, and none is ' - 'established here: (a) the reading that the limit fills the ⊥ role, a modelling commitment and a ' - 'reading across two carriers, since the role condition is not statable in Q2 (MC-1); ' + 'established here: (a) the reading that the limit fills the ⊥ role, which takes a choice of join on ' + 'Q2 (then the role half is a theorem, t_iz_limit_is_new_null), since the role condition is not statable of the limit until a join on Q2 is chosen (MC-1); ' '(b) the limit reaching the incompressibility threshold P0, which nothing here establishes, ' 'since its only route in this document, the valuation-complexity bridge, is refuted (§ II.B); ' '(c) what DA-1 needs: DP-2 and DP-2’s precondition, that the configuration reaching P0 ' @@ -715,7 +730,7 @@ def build(): 'being nowhere zero (t_iz_h_bound_from_depth_chain, §Ib — R-IZ-A closed). Given that condition, two charts, two carriers. ' 'In Q2: the 2-adic depth chain converges to Q2’s 0 (t_iz_cauchy), and 0 is the LIMIT, ' 'not a term, since the chain is nowhere zero. Q2’s field structure supplies no join, and the ' - 'corpus defines no ZPSemilattice on Q2, so the role condition is not statable of the limit here. ' + 'corpus registers no ZPSemilattice instance on Q2, so the role condition is not statable of the limit here. ' '(A join could be chosen: every inhabited carrier admits one, ZeroParadox/Order/Lattice.lean. On ℤ2, ' 'the 2-adic integers, the corpus supplies one with 0 as its bottom (the example at ' 'ZeroParadox/Valuation/Scale.lean § V); 0 filling that bottom is a choice of operation, ' @@ -728,11 +743,11 @@ def build(): E.append(key_result_box([ 'T-SNAP: ⊥ → ε0, shape derived and occurrence committed (existence emerges from null).', 'T-IZ: a nowhere-zero 2-adic depth chain S0, S1, S2, ... → 0 ∈ Q2 at ω, ' - 'ROLE-RECOGNITION derived; OCCUPANCY and NOVELTY committed. What is proved is the 2-adic ' + 'ROLE-RECOGNITION derived; OCCUPANCY takes a choice of join; NOVELTY committed. What is proved is the 2-adic ' 'convergence (t_iz_cauchy) and, separately, that anything playing the bottom role IS the ' - 'bottom (t_iz_limit_is_new_null). That the limit is a thing playing that role is a ' - 'commitment, not a theorem — the role condition is not statable in Q2; that the ' - 'bottom so reached is a NEW one is a further commitment.', + 'bottom (t_iz_limit_is_new_null). That the limit is a thing playing that role takes a choice ' + 'of join on Q2 (then the role half is a theorem, t_iz_limit_is_new_null) — the role condition is not statable of the limit until a join on Q2 is chosen; that the ' + 'bottom so reached is a NEW one is a commitment (C-DA2).', 'The cycle and its closure are a reading, not a theorem; its premises are stated in § V.III. ' 'Strict valuation growth is ' 'Lean-derived from IsDepthChain (a modelling commitment) + IsStrictStateSequence (h_strict_from_r1_t3). ' @@ -746,12 +761,13 @@ def build(): oq_rows = [ ['T-IZ: Inside Zero Theorem', - 'CONVERGENCE + ROLE-RECOGNITION DERIVED — occupancy and novelty COMMITTED', + 'CONVERGENCE + ROLE-RECOGNITION DERIVED — occupancy takes a choice of join; novelty COMMITTED', 'Every nowhere-zero 2-adic depth chain S0, S1, ... in Q2 whose ' 'valuation equals a depth index in ℕ that climbs at every step converges to 0 in ' 'Q2; reading that limit as the ' - 'occupant of the bottom role, and that occupant as a successor null, are commitments. ' - 'Formal spine: Step 1 (t_iz_cauchy, carries Mathlib p-adic Classical.choice) + Step 6 ' + 'occupant of the bottom role takes a choice of join on Q2 (then the role half is a ' + 'theorem, t_iz_limit_is_new_null), and reading that occupant as a successor null is a commitment (C-DA2). ' + 'Formal spine: Step 1 (t_iz_cauchy, carries Classical.choice, § III) + Step 6 ' '(t_iz_limit_is_new_null, axiom-free via DA-2). Steps 2–5 are informational context — the ZP-E path, whose valuation-complexity bridge is refuted (§ II.B); ' 'DA-1 is closed given DP-2 (ZP-E), with ZP-K witnessing Path 1 and carrying Path 3 as a KleeneStructure requirement. No new axioms required.'], ['OQ-E2: Cardinality-semilattice correspondence', @@ -760,11 +776,11 @@ def build(): 'Internal/external perspective relativity is ordinal, not set-theoretically free. ' 'Formal connection to specific CH instances: still open — deferred to future work.'], ['Null balance: 0 + x + (−x) = 0', - 'CLOSED for ROLE-RECOGNITION — occupancy and novelty COMMITTED', + 'CLOSED for ROLE-RECOGNITION — occupancy takes a choice of join; novelty COMMITTED', 'The convergence half is derived from T-IZ: the lattice chain starts at its semilattice’s ⊥ ' '(CC-1) and ascends under T3, and the nowhere-zero 2-adic depth chain converges to 0 ∈ Q2. Reading that ' - 'limit as an occupant of the bottom role is a COMMITMENT, not a consequence — the ' - 'join-identity is not statable in Q2. On that reading, DA-2 identifies the ' + 'limit as an occupant of the bottom role takes a choice of join on Q2 (then the role half is a ' + 'theorem, t_iz_limit_is_new_null). On that reading, DA-2 identifies the ' 'occupant with the ⊥ already there. ' '"−x" is not subtraction in L — it is the 2-adic approach to 0 by forward motion; reading it as a ' 'return in the cycle is the reading whose premises are stated in § V.III. ' @@ -776,18 +792,18 @@ def build(): 'fails at Sn = 2n (§ II.B): valuation n, complexity given n bounded, ' 'ratio → 0. The valuation half is checked (scaleChain_isDepthChain); the complexity half is ' 'outside Lean scope: one fixed program prints 2n from n, which bounds K(2n | n) by its length. ' - 'Not a proof dependency for T-IZ: formal spine is Steps 1 + 6 (Step 6 axiom-free; Step 1 carries Mathlib p-adic choice); ' + 'Not a proof dependency for T-IZ: formal spine is Steps 1 + 6 (Step 6 axiom-free; Step 1 carries Classical.choice, § III); ' 'DA-1 is closed given DP-2 (ZP-E), with ZP-K witnessing Path 1 and carrying Path 3 as a KleeneStructure requirement.'], ['T-IZ Lean sorry fill', 'CLOSED — ZeroParadox/Valuation/SemilatticeInstance.lean', - 't_iz_norm_tendsto_zero and t_iz_conv_zero filled; t_iz_cauchy proved (carries Mathlib p-adic Classical.choice). ' + 't_iz_norm_tendsto_zero and t_iz_conv_zero filled; t_iz_cauchy proved (carries Classical.choice, § III). ' 'All SemilatticeInstance.lean theorems compile with no sorry. ' 'Axiom footprint: standard foundational axioms only (propext, Quot.sound, and Classical.choice ' - 'from Mathlib p-adic analysis on the convergence theorems; the DA-2 step is axiom-free).'], + 'on the convergence theorems, § III; the DA-2 step is axiom-free).'], ['AX-1: Binary Snap Causality', 'RETIRED — shape proved as T-SNAP (ZP-E); the first snap occurs given the occurrence commitment and DA-1', - '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 first 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. ' + '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 first snap occurs is stated separately: it follows from the occurrence commitment together with DA-1 (closed given DP-2). The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII). ' + 'tsnap_holds_but_nothing_moves shows T-SNAP does not carry that the snap occurs. T-SNAP is derived in ZP-E. ' 'A snap at the ordinal limit is the cycle reading, not a consequence of T-IZ; its premises are ' 'stated in § V.III.'], ['Remaining axioms', @@ -810,7 +826,7 @@ def build(): 'here. Also ZP-B T5/C3 for the irreversibility comparison only; ZP-C L-INF, D1; ' 'ZP-E DA-1, T-SNAP, DA-2', 'None', - 'Role derived — T-IZ ✓ (formal spine Steps 1+6: Step 6 axiom-free, Step 1 carries Mathlib p-adic choice; bridge: refuted). Novelty of the successor bottom: COMMITMENT, not proved.'], + 'Role derived — T-IZ ✓ (formal spine Steps 1+6: Step 6 axiom-free, Step 1 carries Classical.choice, § III; bridge: refuted). Novelty of the successor bottom: COMMITMENT, not proved.'], ['Null Balance 0 + x + (−x) = 0', 'T-IZ + T-SNAP + DA-2 (ZP-E)', 'None', @@ -827,7 +843,7 @@ def build(): ['t_iz_cauchy (Lean)', 'ZP-B (Q2 normed field); geometric tendsto; Mathlib.Analysis.SpecificLimits.Basic', 'None', - 'Lean: proved ✓ (t_iz_norm_tendsto_zero, t_iz_conv_zero filled; carries Mathlib p-adic Classical.choice)'], + 'Lean: proved ✓ (t_iz_norm_tendsto_zero, t_iz_conv_zero filled; carries Classical.choice, § III)'], ['t_iz_limit_is_new_null (Lean)', 'da2_bottom_characterization', 'None', @@ -843,7 +859,7 @@ def build(): ['Valuation-complexity bridge', 'ZP-C D1, L-INF, Remark R-BRIDGE; ZP-B T2; AIT (standard)', 'N/A', - 'REFUTED (§ II.B; counterexample Sn = 2n) — not load-bearing. DA-1 is closed given DP-2 (ZP-E), with ZP-K witnessing Path 1 and carrying Path 3 as a KleeneStructure requirement. ' + 'REFUTED (§ II.B; counterexample Sn = 2n) — not load-bearing, since the convergence T-IZ proves does not pass through it. Separately, DA-1 is closed given DP-2 (ZP-E), with ZP-K witnessing Path 1 and carrying Path 3 as a KleeneStructure requirement. ' 'The complexity half is outside Lean scope.'], ['t_iz_h_bound_from_depth_chain (Lean)', 'h_strict_from_r1_t3 (§Ib); t_iz_r1_t3_geometric_bound; ' @@ -865,7 +881,7 @@ def build(): E.append(data_table( ['Claim', 'Grounded In', 'Bridge Axiom?', 'Status'], trace_rows, - [TW*0.20, TW*0.32, TW*0.10, TW*0.38] + [TW*0.31, TW*0.30, TW*0.08, TW*0.31] )) # ── CLOSING ─────────────────────────────────────────────────────────────── @@ -877,7 +893,7 @@ def build(): 'R-IZ-A closed: strict valuation growth derived from IsDepthChain + IsStrictStateSequence (h_strict_from_r1_t3, §Ib) | ' 'IsDepthChain remains a modelling commitment | ' 'Framework closure: a reading; its premises are stated in § V.III | ' - 'Formal spine: Step 6 axiom-free (t_iz_limit_is_new_null), Step 1 carries Mathlib p-adic Classical.choice (t_iz_cauchy) | ' + 'Formal spine: Step 6 axiom-free (t_iz_limit_is_new_null), Step 1 carries Classical.choice, § III (t_iz_cauchy) | ' 'Valuation-complexity bridge: refuted; not load-bearing, since the convergence T-IZ proves does not pass through it | ' 'DA-1 closed given DP-2 (ZP-E), with ZP-K witnessing Path 1 and carrying Path 3 as a KleeneStructure requirement | ' 'Remaining axioms: AX-B1, AX-G1, AX-G2 | No new axioms required', diff --git a/scripts/build_zpi_companion.py b/scripts/build_zpi_companion.py index 6ed8c7ff..0cc920f3 100644 --- a/scripts/build_zpi_companion.py +++ b/scripts/build_zpi_companion.py @@ -1,6 +1,6 @@ """ Build ZP-I Illustrated Companion -Version 1.34 | October 2026 +Version 1.49 | November 2026 Standalone companion for ZP-I: Inside Zero. Accessibility target: 2 years of college math. @@ -81,7 +81,7 @@ def depth_diagram(): # Rightmost x = 311.1 + 8 = 319.1 ≪ dw = 468 ✓ state_lbls = ['S₀', 'S₁', 'S₂', 'S₃'] - # S0 is a nonzero 2-adic number (norm 1), not the bottom of anything in Q2: no '= ⊥' label. + # S0 is a nonzero 2-adic number (norm at most 1), not the bottom of anything in Q2: no '= ⊥' label. state_subs = ['', '', '', '' ] # Connecting lines between consecutive states @@ -103,7 +103,7 @@ def depth_diagram(): # Norm labels: placed BELOW each circle (sy - 8 radius - 3 gap - text baseline). # This avoids collision with the "= ⊥" sub-label which sits to the right of the circle. # S2 omitted (S3 norm nearby). S3 placed above-left (limit indicator owns the right). - norms_below = [(0, '‖S₀‖ = 1'), (1, '‖S₁‖ ≤ 2⁻¹')] + norms_below = [(0, '‖S₀‖ ≤ 1'), (1, '‖S₁‖ ≤ 2⁻¹')] for i_s, ns in norms_below: sx, sy = state_xs[i_s], state_ys[i_s] d.add(String(sx - len(ns) * 2.4, sy - 22, ns, fontSize=8, fontName='DV-I', @@ -276,7 +276,7 @@ def cycle_diagram(): return d -VERSION = '1.34' +VERSION = '1.49' FIRST_RELEASED = 'April 2026' @@ -321,8 +321,9 @@ def footer_cb(canvas, doc): Paragraph( 'This companion explains in plain language how a 2-adic depth chain S₀, S₁, S₂, ... ' 'converges, in the 2-adic metric, to zero - and why the framework READS that ' - 'limit as filling the bottom role again. Both that reading and whether the result is a ' - 'NEW bottom or the one it started from are commitments of the framework, not things the ' + 'limit as filling the bottom role again. That reading takes a choice of join on Q₂ (then ' + 'the role half is a theorem, t_iz_limit_is_new_null), and whether the result is a ' + 'NEW bottom or the one it started from is a commitment of the framework (C-DA2), not something the ' 'chain proves. This is one result in the ' 'Zero Paradox project (ZP-I), ' 'a formal framework built on lattice algebra and 2-adic topology. ' @@ -345,9 +346,9 @@ def footer_cb(canvas, doc): 'not, what comes next?')) E.append(cbody( 'ZP-I answers both questions with a single theorem: T-IZ (Inside Zero). ' - 'Every 2-adic depth chain S₀, S₁, S₂, ... with no zero term, satisfying the IsDepthChain and IsStrictStateSequence conditions, converges - in the ' + 'Every 2-adic depth chain S₀, S₁, S₂, ... with no zero term, whose 2-adic valuations track a depth index (IsDepthChain) that climbs at every step (IsStrictStateSequence, a condition on that index), converges - in the ' '2-adic metric - to zero, which the framework reads as the bottom role and then as a successor null. ' - 'The chain does not go on forever; it reaches its limit at the ordinal limit. The ' + 'The chain runs through every finite stage and reaches its limit at ω, the first limit ordinal. The ' 'convergence is proved (given the IsDepthChain modelling commitment), and so, separately, is the fact that ' 'anything filling the bottom role IS the bottom already there. That the cycle begins again at the limit ' 'is a reading, not a theorem: see the Note on closure.')) @@ -392,7 +393,7 @@ def footer_cb(canvas, doc): E.append(cbody( 'In the 2-adic metric, norms decrease geometrically: ‖S(n)‖ ≤ ‖S(0)‖ · 2−n. ' 'As n → ∞, the norm → 0. The chain converges to 0 in the 2-adic sense: ' - 'the point with 2-adic valuation +∞ under the usual convention v₂(0) = ∞. Reading that structural limit as filling the bottom role is the first commitment - the role condition is not statable in Q₂ - and calling the occupant ⊥′, a successor null, is the second; in this very chart the arc returns to the same 0.')) + 'the point with 2-adic valuation +∞ under the usual convention v₂(0) = ∞. Reading that structural limit as filling the bottom role takes a choice of join on Q₂ - the role condition is not statable of the limit until a join on Q₂ is chosen, and in the semilattice it makes, anything filling the role is that semilattice\'s ⊥ by theorem (t_iz_limit_is_new_null) - and calling the occupant ⊥′, a successor null, is C-DA2, a commitment; in this very chart the arc returns to the same 0.')) E.append(example_box('Real-world analogy - The deepest point in the well', [ 'Imagine a well that has no bottom - every level opens onto a deeper one. ' @@ -463,8 +464,8 @@ def footer_cb(canvas, doc): ['2. ⊥-role identification', 'Anything satisfying the join-identity condition IS that lattice\'s bottom. ' 'That the Cauchy limit 0 ∈ Q₂ satisfies it is the theorem\'s HYPOTHESIS, not ' - 'its conclusion, and Q₂\'s field structure supplies no join (the corpus defines none on Q₂), so the condition is not statable ' - 'there — the two are distinct members of the bottom family, not one object (MC-1). Reading the occupant as a NEW null ⊥′ is a further commitment (C-DA2).', + 'its conclusion, and Q₂\'s field structure supplies no join (the corpus registers none on Q₂), so the condition is not statable ' + 'there — the two are distinct members of the bottom family, not one object (MC-1). Reading the occupant as a NEW null ⊥′ is a commitment (C-DA2).', 'ZP-E DA-2 - proved in Lean (t_iz_limit_is_new_null, axiom-free). ' '✓ (the role only, given the hypothesis; not the novelty)'], ['3. ⊥ of L′ is its Quine atom, given a KleeneStructure', @@ -477,8 +478,9 @@ def footer_cb(canvas, doc): ['4. T-SNAP fires, conditionally', 'On the reading that the limit fills the ⊥ role, on the limit reaching P₀ (which nothing here ' 'establishes), and on what DA-1 needs (step 3), at the computational fixed point T-SNAP fires: ' - 'join ⊥ ε₀′ = ε₀′. Reading the 2-adic limit as the occupant is one commitment; ' - 'calling that occupant a NEW null ⊥′ rather than the same ⊥ is a second.', + 'join ⊥ ε₀′ = ε₀′. Reading the 2-adic limit as the occupant takes a choice of join on Q₂ ' + '(then the role half is a theorem, t_iz_limit_is_new_null); calling that occupant a NEW null ⊥′ ' + 'rather than the same ⊥ is a commitment (C-DA2).', 'ZP-A bot_join - proved in Lean. ✓ (the algebra, given the reading; ' 'neither the occupancy nor the novelty)'], ] @@ -509,7 +511,8 @@ def footer_cb(canvas, doc): 'converges to zero in the 2-adic metric. Starting at ⊥ and climbing by ZP-A T3 are statements ' 'about the depth index and the lattice chain, not about the 2-adic numbers, which have no order of ' 'that kind. Reading the limit as filling the bottom ' - 'role is a commitment, and reading the occupant as ⊥′ a further one. ' + 'role takes a choice of join on Q₂ (then it is that semilattice\'s ⊥ by theorem, ' + 't_iz_limit_is_new_null), and reading the occupant as a successor null ⊥′ is C-DA2, a commitment. ' 'On the first reading, DA-1 and then T-SNAP are CONDITIONAL on the limit reaching P₀ (which nothing ' 'here establishes) and on what DA-1 needs. DA-1 needs DP-2 and ' 'DP-2\'s precondition, that the configuration reaching the incompressibility threshold P₀ is a running ' @@ -520,7 +523,8 @@ def footer_cb(canvas, doc): 'nothing; its DA-1 conjunct, that the semilattice\'s ⊥ is its Quine atom, is the Lean counterpart of ' 'DA-1\'s Path 1, which does not derive the precondition. ' 'The CONVERGENCE needs no new axioms (its Lean proof carries Mathlib\'s Classical.choice) and rests ' - 'on the IsDepthChain modelling commitment; the two readings are commitments rather than consequences of it. ' + 'on the IsDepthChain modelling commitment; the two readings are not consequences of it: the first takes a ' + 'choice of join and the second is a commitment. ' 'That the chain generates a genuinely NEW bottom, rather than arriving back at the ' 'one it started from, is the framework\'s commitment and not something the chain proves - ' 'in the 2-adic picture the arc comes back to the same 0.')) @@ -531,7 +535,13 @@ def footer_cb(canvas, doc): E.append(cbody( 'ZP-I does not violate any of the irreversibility results already proved. ' 'The framework established three ways that return to ⊥ is blocked - three ' - '"closed doors." T-IZ uses a fourth passage that none of the three doors govern.')) + '"closed doors." T-IZ uses a fourth passage that none of the three doors govern. ' + 'The doors are a picture, not a theorem: they are statements about three different objects, and the ' + 'fourth passage reaches 0 in Q₂ only as a limit: no stage of the chain is 0, and the limit is 0, so ' + 'the chain reaches 0 without passing through any of the three doors. In this chart the arc comes back ' + 'to the same 0 (snap_arc_z2_loop). Reading that 0 as filling the bottom role takes a choice of ' + 'join on Q₂ (then it is that semilattice\'s ⊥ by theorem, t_iz_limit_is_new_null), and reading ' + 'it as a successor null is C-DA2, a commitment.')) E.append(cbody( 'Door 1 - R1 (No subtraction): In the lattice, there is no subtraction. ' 'You cannot join your way back to a smaller state. The ascending chain never ' @@ -547,7 +557,7 @@ def footer_cb(canvas, doc): 'continuous function on an interval. C3\'s prohibition covers continuous paths; ' 'it says nothing about Cauchy sequences. Proved in Lean: t_iz_c3_compatible.')) E.append(cbody( - 'Door 3 - AX-G2 (No morphism to initial object): ZP-G proved that no ' + 'Door 3 - AX-G2 (No morphism to initial object): ZP-G’s axiom AX-G2 states that no ' 'morphism within the categorical structure C leads back to the initial object. ' 'T-IZ is not a morphism within C: it is a convergence statement about 2-adic numbers. Reading ' 'its limit as the termination of C and the opening of a new C\', with its own ⊥′, is the cycle ' @@ -588,7 +598,8 @@ def footer_cb(canvas, doc): '
' 'Occurrence fence. T-SNAP fixes the SHAPE of each step and does not establish that ' 'any step is taken; a model in which T-SNAP holds and nothing moves is exhibited in the Lean ' - 'source. Throughout this document, "fires" narrates the framework’s commitment that instantiation occurs - before this note as well as after it. ' + 'source. Throughout this document, "fires" narrates the framework’s occurrence commitment - before this note as well as after it. The occurrence commitment is stated in two charts, execution and slot, in the header of ZeroParadox/Order/Snap.lean (indexed in ZeroParadox/Order/SnapCannotBe.lean § II and CLAIMS.md), the slot chart as the hypothesis hw of t_snap_of_fires_once, that the tape fires at some stage, beside the theorem trials_fires_once that, for independent stages each firing with probability p, 0 < p ≤ 1, firing at some stage has probability one, which names no tape (ZeroParadox/Information/CrossingTrials.lean § VIII).' + '
' '4. T-IZ: the chain\'s unbounded depth forces convergence to 0. That DA-1 and T-SNAP fire ' 'again there, closing the branch, is a reading: see the Note on closure.' '
' @@ -604,7 +615,7 @@ def footer_cb(canvas, doc): E.append(cbody( 'Two charts, two carriers. In the 2-adic numbers, the chain converges to 2-adic zero: zero is the ' 'LIMIT, not a term, since no term of the chain is zero. The field structure of the 2-adic numbers ' - 'supplies no join, and the corpus defines none on them, so the bottom role is not statable of the limit ' + 'supplies no join, and the corpus registers none on them, so the bottom role is not statable of the limit ' 'here. (A join could be chosen, since every inhabited set admits one; on the 2-adic integers the corpus ' 'supplies one with zero as its bottom (ZeroParadox/Valuation/Scale.lean § V), and zero filling that ' 'bottom is a choice of operation, not something T-IZ derives.) In a join-semilattice, the bottom ROLE is the element that ' @@ -620,7 +631,8 @@ def footer_cb(canvas, doc): 't_iz_complete is a conjunction of results, not a chain, and its role step takes its property as the ' 'hypothesis h_role, which nothing here grounds. For the cycle to begin again or close at the limit, it ' 'needs every one of the following further premises, and none is established here: (a) the reading ' - 'that the limit fills the ⊥ role, a commitment and a reading across two carriers (MC-1); (b) the limit ' + 'that the limit fills the ⊥ role, which takes a choice of join on Q₂ (then the role half is a theorem, ' + 't_iz_limit_is_new_null; MC-1); (b) the limit ' 'reaching the incompressibility threshold P₀, which nothing here establishes, since its only route in ' 'ZP-I is refuted (ZP-I § II.B); (c) what DA-1 needs: DP-2 and DP-2\'s precondition, that the ' 'configuration reaching P₀ is a running machine\'s current configuration and not an inert string, which ' @@ -655,7 +667,7 @@ def footer_cb(canvas, doc): 't_iz_limit_is_new_null - anything satisfying the DA-2 null role IS that ' 'lattice\'s bottom (⊥-role identification). The role property is the HYPOTHESIS; ' 'that the Cauchy limit satisfies it is not established here and is not statable ' - 'in Q₂. Reading that occupant as ⊥′ is C-DA2, a further commitment. ' + 'of the limit until a join on Q₂ is chosen. Reading that occupant as ⊥′ is a commitment (C-DA2). ' 'Proved directly from da2_bottom_characterization. ✓ (axiom-free)', 'da1_computational - proved in Lean, given the KleeneStructure instance ✓', 't_iz_complete (§III-B) - carries all four steps in one theorem: convergence, ' diff --git a/scripts/build_zpj.py b/scripts/build_zpj.py index 5d4da3da..b2ec31c7 100644 --- a/scripts/build_zpj.py +++ b/scripts/build_zpj.py @@ -1,12 +1,12 @@ """ Zero Paradox — ZP-J: Executability of Self-Reference PDF Builder -Version 2.13 | October 2026 +Version 2.19 | November 2026 """ import os from zp_utils import * -VERSION = '2.13' +VERSION = '2.19' FIRST_RELEASED = 'April 2026' @@ -31,7 +31,7 @@ def build(): E.append(body( 'This document establishes Theorem T-EXEC (Executability of Self-Reference): in any ' - 'ZP-A join-semilattice carrying the AFAStructure typeclass, whatever fills the Quine-atom ' + 'ZPSemilattice (ZP-A’s join-semilattice with least element, axioms A1–A4) carrying the AFAStructure typeclass, whatever fills the Quine-atom ' 'role — the lattice-level encoding of the set Q = {Q} of ZF+AFA (Anti-Foundation ' 'Axiom) — is provably the bottom element ⊥. This bridges the set-theoretic and ' 'order-theoretic layers of the framework at the level of that role; the set identity ' @@ -46,8 +46,8 @@ def build(): 'it generalises the AFAStructure typeclass into an abstraction chain reaching down to ' 'a pure valuation structure (Section VIII); it instantiates that chain on two concrete ' 'types (Section IX); and it proves global decoration uniqueness, into abstract ' - 'DecorationUniverses, for finite accessible ' - 'pointed graphs (Section X). All results are sorry-free in Lean 4.', + 'DecorationUniverses, for every quiver, finite or not, and by a finite, graph-side ' + 'proof for finite accessible pointed graphs (Section X). All results are sorry-free in Lean 4.', style='bodyI')) E.append(hr()) @@ -60,7 +60,7 @@ def build(): E.append(Paragraph('I. CC-1 in ZP-A', S['h2'])) E.append(body( 'ZP-A Conditional Claim CC-1 states: if the state sequence is initialised at ⊥, ' - 'then ⊥ ≤ S(n) for all n. This follows trivially from T2 (⊥ is the ' + 'then ⊥ ≤ S(n) for all n. This follows trivially from ZP-A T2 (⊥ is the ' 'global minimum), so its formal content is essentially: we are choosing ⊥ as the ' 'initial state S₀.')) E.append(body( @@ -80,9 +80,8 @@ def build(): E.append(Paragraph('II. The Implicit Identification', S['h2'])) E.append(body( - 'ZP-E\'s DA-1 Path 1 already states: ⊥ = {⊥} (Quine atom, ZF+AFA). This ' - 'identification — the bottom element is the Quine atom, the unique solution of x = {x} under ' - 'AFA — ' + 'ZP-E\'s DA-1 Path 1 already invokes the Quine atom (CC-2): the role that, under AFA, the set ' + 'Q = {Q} plays as the unique solution of x = {x}. That the bottom element fills this role ' 'was present informally but never formally bridged to CC-1. It appeared as motivation for ' 'why ⊥ is the right starting point, not as a derivation of it.')) E.append(body( @@ -97,8 +96,8 @@ def build(): 'If forced, what is the structural reason? ' 'Answer: restated (ZP-J t_exec_iff), and not forced (a countermodel). Given an AFAStructure, "starts at a Quine ' 'atom" and "starts at ⊥" are equivalent (t_exec_iff), so the starting point is named ' - 'by its role; the choice to start there remains, since on a carrier with a second point a valid sequence starts elsewhere. The AFA identification ⊥ = {⊥} is the ZF+AFA reading of the ' - 'Quine-atom role the typeclass encodes; the Lean states the role, not the set identity.', + 'by its role; the choice to start there remains, since on a carrier with a second point a valid sequence starts elsewhere. The Quine atom (CC-2) is a role, and in ZF+AFA the set Q = {Q} plays it; ' + 'the Lean states the role and its occupant chart by chart, and writes no equation between ⊥ and Q.', bg=AMBER_LITE, border=AMBER )) E.append(sp(6)) @@ -167,7 +166,7 @@ def build(): 'by at most one element (quine_unique). The third structural field — bot_self_mem — ' 'is where the bridge is built.')) E.append(body( - 'The AFAStructure typeclass in SetTheoryAFA.lean captures exactly this. Its three fields are ' + 'The AFAStructure typeclass in ZeroParadox/Settheory/SetTheoryAFA.lean captures exactly this. Its three fields are ' 'sufficient to derive T-EXEC with no additional axioms. The full AFA machinery ' '(APGs, bisimulation, decoration) motivates the fields; the formal derivation requires ' 'only the fields themselves, and every ZPSemilattice supplies them (Section III.II).')) @@ -185,7 +184,7 @@ def build(): 'encode standard AFA properties. The third is the bridge.')) E.append(def_box( - 'AFAStructure Typeclass (SetTheoryAFA.lean § I)', + 'AFAStructure Typeclass (ZeroParadox/Settheory/SetTheoryAFA.lean § I)', [ 'class AFAStructure (L : Type*) [ZPSemilattice L] with:', '(1) selfMem : L → Prop ' @@ -197,8 +196,8 @@ def build(): '— AFA uniqueness. At most one element of L plays the self-containment role.', '(3) bot_self_mem : selfMem(⊥) ' '— the bridge field. The bottom element of the lattice is self-containing. ' - 'This encodes the ROLE that ⊥ = {⊥} describes in ZF+AFA; the set identity ' - 'itself compares an element of L with a set of elements of L, so it is not stated here.', + 'This encodes the Quine-atom ROLE (CC-2), which in ZF+AFA the set Q = {Q} plays; an equation ' + 'between ⊥ of L and that set would compare an element of L with a set, so it is not stated here.', ] )) E.append(sp(6)) @@ -209,10 +208,19 @@ def build(): '(ZP-A\'s lattice) to the set-theoretic world (AFA). It says: the bottom element ⊥ ' 'of the lattice is self-containing — it satisfies selfMem(⊥).')) E.append(body( - 'In set-theoretic terms, within ZF+AFA: ⊥ = {⊥}, so in particular ' - '⊥ ∈ ⊥. This is the identification that ZP-E\'s DA-1 Path 1 invokes ' - 'informally. ZP-J encodes the role it describes as a typeclass field, so every result ' - 'that uses it states it as a hypothesis rather than leaving it as narrative motivation.')) + 'In ZF+AFA the Quine atom (CC-2) is the set Q = {Q}, its own sole member. The lattice and the ' + 'set universe are separate charts, so no equation ⊥ = Q is written. What is shared is the ' + 'ROLE, a point that steps to itself and to nothing else (Motion.SelfOnlyAt, ZeroParadox/Die.lean), ' + 'and each chart has its own occupancy theorem (ZeroParadox/Settheory/QuineDichotomy.lean, ' + 'ZeroParadox/Settheory/Wall.lean, ZeroParadox/Settheory/Coalgebra.lean): in a lattice with ' + 'AbstractSelfApp, or with the membership host an AFAStructure builds, the only occupant is ⊥ ' + '(selfApp_quine_role_iff, quineAtomHost_quine_role_iff); in Mathlib\'s ZFSet, which carries ' + 'Foundation, the role has no occupant (zfset_quine_role_unoccupied); in the final coalgebra of the ' + 'identity functor it is occupied (cofix_quine_role_occupied), a one-point chart ' + '(cofix_subsingleton), where occupancy restates that chart\'s existence fork and adds nothing ' + 'beyond it. This is what ZP-E\'s DA-1 Path 1 invokes informally. ZP-J encodes the role as a ' + 'typeclass field, so every result that uses it states it as a hypothesis rather than leaving it ' + 'as narrative motivation.')) E.append(body( 'Supplying the field is not a test a lattice can fail. Every ZPSemilattice carries an ' 'AFAStructure: take the constant-bottom self-application trivialSelfApp ' @@ -232,7 +240,7 @@ def build(): '⊥ = ⊥ holds by reflexivity.', 'This is the CIC-compatible encoding of AFA self-containment. In Lean 4 (based on ' 'the Calculus of Inductive Constructions), the set-theoretic statement ⊥ ∈ ⊥ ' - '— meaning ⊥ literally contains itself as a member under ZF+AFA — is not ' + '(ZF+AFA asserts Q ∈ Q of the set Q = {Q}, and nothing of ⊥) is not ' 'well-typed on a carrier: x : L is a member of a Set L, and no membership relation between ' 'two elements of L is in scope, so ⊥ ∈ ⊥ does not elaborate. ' 'Mathlib\'s own model of ZF sets satisfies Foundation (ZFSet.mem_wf: ∈ is well-founded, from ' @@ -241,8 +249,8 @@ def build(): 'means "equals the bottom element." The Lean proof compiles by rfl because ' 'self-containing is defined as equality with ⊥.', 'This is a structural analogy, not a set-theoretic derivation from ZF+AFA. The ' - 'full set-theoretic content of AFA — that ⊥ literally contains itself as a ' - 'member of the AFA universe — is not present in the Lean proof. What the typeclass ' + 'set-theoretic consequence of AFA used here, that the set Q = {Q} exists and is unique ' + '(Aczel 1988, Example 1.3), is not present in the Lean proof, and no equation between ⊥ and Q is written. What the typeclass ' 'encodes is the structural consequence: there is a unique element playing the Quine ' 'role, and ⊥ is that element.', ] @@ -251,7 +259,7 @@ def build(): E.append(Paragraph('III. Why a Typeclass Field Rather than a Freestanding Axiom', S['h2'])) E.append(body( - 'In the stub version of SetTheoryAFA.lean, the bridge was a freestanding axiom: ' + 'In the stub version of ZeroParadox/Settheory/SetTheoryAFA.lean, the bridge was a freestanding axiom: ' 'ax_j1_quine_join_identity. It stated directly that the Quine atom satisfies the ' 'join-identity. This compiled, but the purity check showed T-EXEC depending on ' 'ax_j1_quine_join_identity — a named axiom floating outside any typeclass.')) @@ -264,8 +272,8 @@ def build(): E.append(callout( 'The distinction: a freestanding axiom says "trust me, this is true," and the purity check ' 'records it. A typeclass field says "given this structure," and every theorem is ' - 'conditional on it. ZP-J uses the second. The literal set identity (⊥ = {⊥}) ' - 'stays in ZF+AFA; the Lean carries only the role it describes.', + 'conditional on it. ZP-J uses the second. The set Q = {Q} ' + 'stays in ZF+AFA; the Lean carries only the Quine-atom role (CC-2) that set plays.', bg=SLATE_LITE, border=SLATE )) E.append(sp(6)) @@ -283,7 +291,7 @@ def build(): 'Statement: Let L be a ZP-A semilattice with AFAStructure. ' 'If q : L is a Quine atom (selfMem(q) and q is unique among self-containing ' 'elements), then q = ⊥.', - 'Lean: ZeroParadox.t_exec — proved in SetTheoryAFA.lean. ' + 'Lean: ZeroParadox.t_exec — proved in ZeroParadox/Settheory/SetTheoryAFA.lean. ' 'Purity: does not depend on any axioms. ✓', ] )) @@ -296,7 +304,7 @@ def build(): li('hq.2 states: every self-containing element of L equals q. ' '(This is the uniqueness half of IsQuineAtom q.)'), li('AFAStructure.bot_self_mem states: ⊥ is self-containing. ' - '(This is the bridge field — the role ⊥ = {⊥} describes in ZF+AFA.)'), + '(This is the bridge field — the Quine-atom role (CC-2), played in ZF+AFA by the set Q = {Q}.)'), li('Applying hq.2 to ⊥ using bot_self_mem gives: ⊥ = q. ' 'By symmetry: q = ⊥. QED.'), sp(4), @@ -364,7 +372,7 @@ def build(): E.append(Paragraph('I. J1 — QuineJoinIdentity (Derived)', S['h2'])) E.append(body( - 'In the initial stub of SetTheoryAFA.lean, the claim "the Quine atom satisfies the join-identity" ' + 'In the initial stub of ZeroParadox/Settheory/SetTheoryAFA.lean, the claim "the Quine atom satisfies the join-identity" ' 'was stated as a freestanding axiom (ax_j1_quine_join_identity). ZP-J replaces it with ' 'a theorem.')) E.append(result_box( @@ -428,7 +436,7 @@ def build(): 'T-EXEC and its corollaries carry zero freestanding axioms in the Lean 4 purity check. ' 'The entire derivation traces to the fields of two typeclasses: ZPSemilattice (from ZP-A) ' 'and AFAStructure (new in ZP-J). No standalone axiom statement appears anywhere in the ' - 'SetTheoryAFA.lean proof obligations.')) + 'ZeroParadox/Settheory/SetTheoryAFA.lean proof obligations.')) E.append(body( 'The foundational commitments are the typeclass fields themselves. In ZPSemilattice: ' 'A1–A4 (the semilattice axioms). In AFAStructure: selfMem (a predicate), ' @@ -439,19 +447,21 @@ def build(): E.append(Paragraph('II. Where the Philosophy Lives Now', S['h2'])) E.append(body( - 'The philosophical content of ⊥ = {⊥} is not in the Lean. It lives in ZP-A as ' + 'The philosophical content of the Quine atom (CC-2) is not in the Lean. It lives in ZP-A as ' 'CC-2 (Self-Containment of ⊥), a Forced Metatheoretic Commitment with two halves: that ' 'any host of a self-membered bottom is not well-founded is proved (quineHost_not_wellFounded, ' 'zfSet_no_quine_bottom, ZeroParadox/Settheory/QuineHost.lean), and that a unique Quine atom is ' 'the right requirement is argued. It lives too in ZP-E\'s DA-1 Path 1 (one ' - 'of three informal arguments for instantiation as execution), and in ZF+AFA it remains a ' - 'set-theoretic identity. What ZP-J adds is the ROLE that identity describes, stated as the ' + 'of three informal arguments for instantiation as execution), and in ZF+AFA it is the set ' + 'Q = {Q}. What ZP-J adds is the ROLE that set plays, stated as the ' 'field bot_self_mem, and a proof (T-EXEC) that whatever fills that role is ⊥.')) E.append(body( 'Because every lattice can fill the role trivially, carrying AFAStructure is not evidence ' - 'that ⊥ = {⊥} holds of a lattice. In ZF+AFA the set Q = {Q} exists and is unique, ' - 'a consequence of the axiom (Aczel 1988, Example 1.3); identifying the framework\'s ⊥ with ' - 'that set is the commitment (ZP-E, Remark R-AFA). The role, stated as a hypothesis ' + 'about any particular lattice. In ZF+AFA the set Q = {Q} exists and is unique, ' + 'a consequence of the axiom (Aczel 1988, Example 1.3). No equation between the framework\'s ⊥ ' + 'and that set is written: they sit in different charts, and each chart\'s occupant of the role is a ' + 'theorem of that chart (Section III.II). Adopting AFA as the set chart\'s metatheory stays the ' + 'commitment (CC-2; ZP-E, Remark R-AFA). The role, stated as a hypothesis ' 'where any reader can see it, is what the Lean checks.')) E.append(Paragraph('III. The Formal Chain', S['h2'])) @@ -460,15 +470,15 @@ def build(): 'starting point, not a derived one. Sections I–VI restate that commitment in terms ' 'of the Quine-atom role, where it becomes an equivalence rather than a bare choice. ' 'Sections VII–X extend the chain further: they derive AFAStructure\'s laws from ' - 'stronger structures, provide concrete models, and prove decoration uniqueness for finite ' - 'graphs over abstract DecorationUniverses — an analogue of the uniqueness clause of ' + 'stronger structures, provide concrete models, and prove decoration uniqueness for every ' + 'quiver, with a graph-side proof for finite graphs, over abstract DecorationUniverses — an analogue of the uniqueness clause of ' 'what AFA asserts as an axiom. Every node is either a proved theorem or a typeclass field:')) E += [ li('ZP-A axioms A1–A4: semilattice structure (ZPSemilattice fields).'), li('ZP-B: 2-adic topology and irreversibility (proved from Mathlib).'), li('ZP-C: information theory, L-INF, L-RUN (proved axiom-free or from Mathlib).'), li('ZP-D: state layer, orthogonality (proved from ZP-A and ZP-B).'), - li('ZP-E: T-SNAP, DA-1, DA-2 (T-SNAP and DA-2 proved axiom-free; DA-1 Path 3 outside Lean scope).'), + li('ZP-E: T-SNAP, DA-1, DA-2 (T-SNAP and DA-2 proved axiom-free; DA-1 Path 3 not formalized).'), li('ZP-J: AFAStructure fields (selfMem, quine_unique, bot_self_mem). ' 'T-EXEC, J1, and CC-1 in conditional form: proved axiom-free. ' 'Sections VII–X (Aczel connection, abstraction chain, concrete instances, ' @@ -476,9 +486,41 @@ def build(): sp(4), ] E.append(body( - 'DA-1 Path 3 (the AIT/Kolmogorov complexity argument in ZP-E) remains outside Lean ' - 'scope for the same reason it always has: Kolmogorov complexity is uncomputable and ' - 'absent from Mathlib. ZP-J does not affect DA-1\'s status.')) + 'DA-1 Path 3 (the AIT/Kolmogorov complexity argument in ZP-E) is not formalized in this corpus: ' + 'not located as of 2026-11-07, searched over ZeroParadox/**/*.lean in three phrasings. ' + '“Path 3”: a comment in ZeroParadox/Category/Category.lean and the docstring of ' + 'da1_paths_unified (ZeroParadox/Computability/Kleene.lean). “incompressib”: ' + 'ae_incompressible (ZeroParadox/Information/MaxEntropy.lean), a bound on fair-coin tapes for ' + 'each prefix-free decoder, and prose mentions in Surprisal.lean, Disjunctive.lean and ' + 'KleeneChoiceFree.lean. “shorter”, “external” or “outside” ' + 'before “program”, “generator” or “description”, and ' + '“shortest program” or “shortest description”: the docstrings of ' + 'IsKleeneFixedPoint, da1_paths_unified and description_instantiation_gap_closed (Kleene.lean; ' + 'the last says “No external program is prior to ⊥” is a requirement the ' + 'framework imposes rather than derives) and prose in Surprisal.lean. None is a ' + 'proof of the argument. ' + 'Kolmogorov complexity itself is now in the build: plainK and KPPlain come from the Lake ' + 'dependency kolmogorov-complexity-lean (A. Milovanov) at commit 7e71116, and ' + 'ZeroParadox/Information/BrudnoBridge.lean restates three of its entropy-rate theorems and one ' + 'randomness criterion for this corpus’s trials and MLRandom. In Shen, Uspensky and ' + 'Vereshchagin, Kolmogorov Complexity and Algorithmic Randomness (AMS 2017; SUV), ' + 'brudno_of_MLRandom and brudno_fair_of_MLRandom are Theorem 148 and Problem 238 (p. 229), ' + 'pointwise forms along Martin-Löf random tapes, and brudno_ae_trials is Problem 239 ' + '(p. 229), the almost-everywhere Bernoulli case of Brudno’s theorem; the name Brudno ' + 'is this corpus’s label, used by neither SUV on those pages nor the dependency. ' + 'MLRandom_fair_iff_le_KPPlain is SUV Theorem 94(d) (p. 151), the prefix-complexity form of ' + 'the Levin–Schnorr criterion, which SUV states as Theorem 90 (p. 146) in monotone ' + 'complexity. The gap is ' + 'therefore the Path 3 argument itself, not the absence of K. Before that dependency, a ' + 'definition of K was not located in the Mathlib then pinned ' + '(5450b53) as of 2026-11-03, searched for “Kolmogorov complexity”, ' + '“KolmogorovComplexity”, “algorithmic information”, “shortest ' + 'program” and “description length” (no file), and “Kolmogorov” ' + '(Kolmogorov spaces and the Kolmogorov quotient, Kolmogorov processes and the Kolmogorov ' + 'condition, mentions of the Kolmogorov–Chentsov theorem, the Chapman–Kolmogorov ' + 'equations, the extension theorem, the zero-one law and an author credit; none a definition ' + 'of Kolmogorov complexity). ZP-J does not affect ' + 'DA-1\'s status.')) E.append(sp(6)) print('[build_zpj] Building Section VII...') @@ -489,7 +531,7 @@ def build(): ] E.append(body( - 'Formalised in AczelConn.lean as an extension of the T-EXEC typeclass encoding. The ' + 'Formalised in ZeroParadox/Settheory/AczelConn.lean as an extension of the T-EXEC typeclass encoding. The ' 'results are choice-free statements about a lattice predicate; they do not reach Aczel\'s ' 'set-theoretic question.', style='bodyI')) @@ -515,9 +557,9 @@ def build(): 'of self-containing elements, defined directly by comprehension on the predicate selfMem. ' 'No set-continuous operator is defined and J_self is not built as a union of sets, so the ' 'step that uses DC in Aczel\'s proof has no counterpart here. The results about J_self ' - 'follow immediately from AFAStructure (Lean: AczelConn.lean § I):')) + 'follow immediately from AFAStructure (Lean: ZeroParadox/Settheory/AczelConn.lean § I):')) E.append(result_box( - 'J_self Theorems (AczelConn.lean § I)', + 'J_self Theorems (ZeroParadox/Settheory/AczelConn.lean § I)', [ 'bot ∈ J_self: the bottom element is self-containing. (AFAStructure.bot_self_mem.)', 'J_self_eq_bot: every x ∈ J_self satisfies x = ⊥. ' @@ -539,9 +581,9 @@ def build(): E.append(Paragraph('III. The Abstract Principle: A Unique Witness Determines Its Set', S['h2'])) E.append(body( 'The identification is not specific to self-membership. It holds for any predicate with a ' - 'unique witness. AczelConn.lean makes this explicit:')) + 'unique witness. ZeroParadox/Settheory/AczelConn.lean makes this explicit:')) E.append(result_box( - 'Theorem singleton_from_unique_witness (AczelConn.lean § II)', + 'Theorem singleton_from_unique_witness (ZeroParadox/Settheory/AczelConn.lean § II)', [ 'For any type α and predicate P : α → Prop: ' 'if w satisfies P(w) and ∀ x, P(x) → x = w, ' @@ -570,7 +612,7 @@ def build(): ] E.append(body( - 'Developed in SelfApp.lean and Scale.lean after T-EXEC was established; ' + 'Developed in ZeroParadox/Computability/SelfApp.lean and ZeroParadox/Valuation/Scale.lean after T-EXEC was established; ' 'the abstraction chain derives AFAStructure\'s laws from stronger structures: a ' 'fixed-point structure and, beneath it, a valuation structure.', style='bodyI')) @@ -594,7 +636,7 @@ def build(): 'AbstractSelfApp encodes the abstract pattern common to both the set-theoretic and ' '2-adic domains: a self-application operation whose unique fixed point is ⊥.')) E.append(def_box( - 'AbstractSelfApp Typeclass (SelfApp.lean § I)', + 'AbstractSelfApp Typeclass (ZeroParadox/Computability/SelfApp.lean § I)', [ 'class AbstractSelfApp (L : Type*) [ZPSemilattice L] with:', '(1) selfApp : L → L — the self-application operation.', @@ -607,7 +649,7 @@ def build(): E.append(body( 'From the two laws fixed_bot and unique_fp (selfApp is data), the two AFAStructure LAWS become derived theorems, and selfMem is supplied as a definition (selfMemDerived) rather than proved — it is data:')) E.append(result_box( - 'Derived Results from AbstractSelfApp (SelfApp.lean § II–III)', + 'Derived Results from AbstractSelfApp (ZeroParadox/Computability/SelfApp.lean § II–III)', [ 'selfMemDerived x := selfApp(x) = x — self-containment as fixed-point property.', 'derived_bot_self_mem: selfMemDerived(⊥) — from fixed_bot. ✓', @@ -629,7 +671,7 @@ def build(): 'valuation. Only ⊥, which has infinite valuation (val(⊥) = ⊤), ' 'can be a fixed point.')) E.append(def_box( - 'ValuationStructure Typeclass (Scale.lean § I)', + 'ValuationStructure Typeclass (ZeroParadox/Valuation/Scale.lean § I)', [ 'class ValuationStructure (L : Type*) [ZPSemilattice L] with:', '(1) scale : L → L — the self-application (scaling) operation.', @@ -644,7 +686,7 @@ def build(): )) E.append(sp(6)) E.append(result_box( - 'Derived Results from ValuationStructure (Scale.lean § II–IV)', + 'Derived Results from ValuationStructure (ZeroParadox/Valuation/Scale.lean § II–IV)', [ 'val_finite_of_ne_bot: x ≠ ⊥ ⇒ val(x) ≠ ⊤ ' '— contrapositive of val_unique. ✓', @@ -708,7 +750,7 @@ def build(): ] E.append(body( - 'Developed in Model.lean and OntBridge.lean to ground the abstraction ' + 'Developed in ZeroParadox/Settheory/Model.lean and ZeroParadox/Settheory/OntBridge.lean to ground the abstraction ' 'chain in concrete types; OntologicalStates takes a shorter path because a ' 'two-element carrier admits no ValuationStructure.', style='bodyI')) @@ -723,7 +765,7 @@ def build(): 'So ⊤ is the ZP-bottom (valuation ∞, unique fixed point) and 0 is the ' 'ZP-maximum (fully constrained).')) E.append(def_box( - 'ℕ∞ Instances (Model.lean)', + 'ℕ∞ Instances (ZeroParadox/Settheory/Model.lean)', [ 'instNatInfZPS: ZPSemilattice ℕ∞ with join = min, bot = ⊤. ' 'A1–A3: min is associative, commutative, idempotent. ' @@ -737,7 +779,7 @@ def build(): )) E.append(sp(6)) E.append(result_box( - 'Derived AFA Content on ℕ∞ (Model.lean § III)', + 'Derived AFA Content on ℕ∞ (ZeroParadox/Settheory/Model.lean § III)', [ 'natInf_scale_unique_fp: x + 1 = x ⇒ x = ⊤. ' '(The unique fixed point of (· + 1) in ℕ∞ is ⊤.) ✓', @@ -762,7 +804,7 @@ def build(): 'exist ↦ null ≠ exist (unique_fp holds vacuously for exist). ' 'AFA content follows immediately from the AbstractSelfApp instance.')) E.append(def_box( - 'OntologicalStates Instances (OntBridge.lean)', + 'OntologicalStates Instances (ZeroParadox/Settheory/OntBridge.lean)', [ 'instOntZPS: ZPSemilattice OntologicalStates with null-identity join and bot = null. ' 'All four axioms proved by case analysis. ✓', @@ -773,7 +815,7 @@ def build(): )) E.append(sp(6)) E.append(result_box( - 'Derived AFA Content on OntologicalStates (OntBridge.lean § III)', + 'Derived AFA Content on OntologicalStates (ZeroParadox/Settheory/OntBridge.lean § III)', [ 'ont_bot_self_mem: null is self-containing. ✓', 'ont_quine_unique: any two self-containing elements of OntologicalStates are equal. ✓', @@ -784,8 +826,8 @@ def build(): E.append(callout( 'Two concrete instances, two paths through the chain. ℕ∞ takes the full ' 'ValuationStructure route. OntologicalStates bypasses ValuationStructure and connects ' - 'directly to AbstractSelfApp. Both deliver the same conclusion: the unique self-containing ' - 'element is the bottom. The architecture is sound because each type takes the path ' + 'directly to AbstractSelfApp. Both deliver the same conclusion: the unique element satisfying ' + 'selfMem (read as x = {x}) is the bottom. The architecture is sound because each type takes the path ' 'the mathematics allows.', bg=SLATE_LITE, border=SLATE )) @@ -799,8 +841,8 @@ def build(): ] E.append(body( - 'Formalised in APG.lean as the most recent addition; this section proves ' - 'decoration uniqueness for finite accessible pointed graphs over abstract ' + 'Formalised in ZeroParadox/Settheory/APG.lean as the most recent addition; this section proves ' + 'decoration uniqueness for every quiver, with a graph-side proof for finite accessible pointed graphs, over abstract ' 'DecorationUniverses — an analogue of AFA\'s uniqueness clause, not that clause ' 'and not AFA itself — ' 'using the typeclass chain established in Sections VIII–IX.', @@ -820,7 +862,7 @@ def build(): 'than sets. This avoids ZFSet (which satisfies Foundation, making self-loops impossible) ' 'and places the result in the typeclass framework established above.')) E.append(def_box( - 'Typeclass: DecorationUniverse (APG.lean § II)', + 'Typeclass: DecorationUniverse (ZeroParadox/Settheory/APG.lean § II)', [ 'class DecorationUniverse (U : Type*) [ZPSemilattice U]', ' [ValuationStructure U] where', @@ -843,7 +885,7 @@ def build(): 'inequalities, not an iterated equation. Let w be the next vertex on the cycle and p the ' 'path from w back to v. Because w is a child of v and d(v) collects over d of v’s ' 'children, collect_val_ge gives val(d(v)) ≥ val(d(w)) + 1. Following p, the lemma ' - 'path_val_chain (private to APG.lean) gives val(d(w)) ≥ val(d(v)) + length(p). ' + 'path_val_chain (private to ZeroParadox/Settheory/APG.lean) gives val(d(w)) ≥ val(d(v)) + length(p). ' 'path_val_chain\'s own proof recurses along p, accumulating at least one unit of valuation ' 'per edge — the bound above is itself reached by that recursion, not asserted outright. ' 'Together these force val(d(v)) to exceed itself, which no finite value in ℕ∞ ' @@ -857,7 +899,7 @@ def build(): 'scalek lemmas below are genuine results about periodic points of scale, and ' 'kCycle_node_eq_bot takes that equation as a hypothesis rather than deriving it.')) E.append(result_box( - 'Cyclic Vertex Theorems (APG.lean §§ III–VII\')', + 'Cyclic Vertex Theorems (ZeroParadox/Settheory/APG.lean §§ III–VII\')', [ 'val_iterate: val(scalek(x)) = val(x) + k for x ≠ ⊥. ✓', 'scale_iterate_unique_fp: scalek(x) = x ⇒ x = ⊥ for k ≥ 1. ✓', @@ -892,13 +934,31 @@ def build(): 'acyclic vertex v, the reach of w is a strict subset of the reach of v (since v cannot ' 'be reached from w without creating a cycle). Reach cardinality is therefore strictly ' 'decreasing, providing a well-founded measure for the induction.')) + E.append(body( + 'That measure is the graph side, and it is where finiteness is spent. The value side needs ' + 'none: decoration_unique_of_val (ZeroParadox/Settheory/APG.lean § IX) inducts on the ' + 'valuation of the decorating value instead. A value of finite valuation m is collected from ' + 'children whose values have valuation below m (collect_val_ge), and a value of valuation ' + '⊤ is ⊥ of U (val_unique). It holds on every quiver, finite or not. Credit runs one ' + 'way: this adapts the standard proof, by induction on the rank of the target, of a result ' + 'Aczel sets as an exercise, that the Foundation axiom implies AFA2 (every graph has at most ' + 'one decoration) (Aczel, Non-Well-Founded Sets, CSLI 1988, Exercise 2.1, p. 20; AFA1 ' + 'and AFA2 are defined on p. 19). The difference from that exercise is one point of infinite ' + 'depth, ⊥ of U, admitted through val_unique. The two sides ' + 'are related one way: a cyclic vertex’s value has valuation ⊤ ' + '(cyclic_decoration_eq_bot with val_bot); no converse is claimed.')) E.append(result_box( - 'Acyclic Induction and Global Uniqueness (APG.lean §§ VIII–IX)', + 'Acyclic Induction and Global Uniqueness (ZeroParadox/Settheory/APG.lean §§ VIII–IX)', [ 'acyclic_induction_step: if two valid decorations d₁, d₂ agree on all ' - 'children of an acyclic vertex v, they agree on v. ' + 'children of a vertex v, they agree on v. ' '(The two child image sets are equal by Set.ext, then rewrite — ordinary ' 'congruence, consuming no class axiom.) ✓', + 'decoration_unique_of_val, the main uniqueness result: for any quiver V, finite or not, with no APG argument, any two ' + 'valid decorations d₁, d₂ into any DecorationUniverse are equal. ' + 'Proof: strong induction on a finite valuation; valuation ⊤ is ⊥ of U by ' + 'val_unique. decoration_unique_finite restates decoration_unique with [Finite V] in ' + 'place of [Fintype V], as a corollary. Both [propext, Quot.sound]. ✓', 'decoration_unique [Fintype V]: for any finite APG with root r and any two valid ' 'decorations d₁, d₂ into any DecorationUniverse, d₁ = d₂. ' 'Proof: strong induction on |{w | Path u w}|; cyclic case by cyclic_decoration_eq_bot; ' @@ -907,13 +967,15 @@ def build(): )) E.append(sp(6)) E.append(callout( - 'decoration_unique is the ZP analogue of the uniqueness clause of AFA (an axiom, not a ' - 'theorem): for any ' - 'finite APG, at most one valid decoration exists into any DecorationUniverse. ' - 'The proof consumes collect_val_ge (never collect_singleton), val_unique through ' - 'val_finite_of_ne_bot, and [Fintype V] for the acyclic descent — it ' - 'gives a sufficient condition for decoration uniqueness, not a characterisation. It does not construct a specific AFA ' - 'model or derive AFA\'s axioms from ZP\'s.', + 'decoration_unique_of_val is the ZP analogue of the uniqueness clause of AFA (an axiom, not a ' + 'theorem): for any quiver, finite or not, at most one valid decoration exists into ' + 'any DecorationUniverse. Its proof consumes collect_val_ge and val_unique and no finiteness. ' + 'decoration_unique is the finite, graph-side proof, for finite APGs; it consumes ' + 'collect_val_ge (never collect_singleton), val_unique through val_finite_of_ne_bot, and ' + '[Fintype V] for the acyclic descent, and its statement is a special case of ' + 'decoration_unique_of_val. Each ' + 'gives a sufficient condition for decoration uniqueness, not a characterisation. Neither constructs a specific AFA ' + 'model or derives AFA\'s axioms from ZP\'s.', bg=AMBER_LITE, border=AMBER )) E.append(sp(6)) @@ -961,8 +1023,7 @@ def build(): ['ValuationStructure → AbstractSelfApp', 'ValuationStructure.val_scale + val_unique', 'None', - 'Lean: scale_unique_fp, toAbstractSelfApp — [propext, Classical.choice, Quot.sound], ' - 'already in each STATEMENT (ZP-J AFA Addendum § V) ✓'], + 'Lean: scale_unique_fp, toAbstractSelfApp — [propext, Classical.choice, Quot.sound] ✓'], ['ℕ∞ : ValuationStructure', 'ℕ∞ arithmetic (WithTop.top_add)', 'None', @@ -979,8 +1040,16 @@ def build(): 'cyclic_decoration_eq_bot + acyclic_induction_step + Set.ncard', '[Fintype V] — finite graph assumption', 'Lean: decoration_unique — propext, Classical.choice, Quot.sound ✓'], + ['decoration_unique_of_val (any quiver)', + 'collect_val_ge + val_unique + acyclic_induction_step', + 'None — no finiteness, no APG', + 'Lean: decoration_unique_of_val — [propext, Quot.sound]; no Classical.choice ✓'], + ['decoration_unique_finite [Finite V]', + 'decoration_unique_of_val', + '[Finite V] — in the statement only; the proof does not use it', + 'Lean: decoration_unique_finite — [propext, Quot.sound]; no Classical.choice ✓'], ['AFAStructure.bot_self_mem', - 'The role that the ZF+AFA identity ⊥ = {⊥} describes', + 'The Quine-atom role (CC-2), played in ZF+AFA by the set Q = {Q}', 'Typeclass field — a hypothesis; every ZPSemilattice meets it trivially', 'Not a theorem; a hypothesis T-EXEC carries.'], ] @@ -1015,9 +1084,9 @@ def build(): 'this document takes no position on whether his use of DC is essential.'], ['DA-1 Path 1 formalisation', 'PARTIAL — APG case proved', - 'DA-1 Path 1 (ZP-E) invokes ⊥ = {⊥} informally. ZP-J T-EXEC formalises ' - 'the role identification, not the set identity. decoration_unique (§ X) proves uniqueness for finite APGs ' - 'over abstract DecorationUniverses. The full ZF+AFA set-theoretic bridge ' + 'DA-1 Path 1 (ZP-E) invokes the Quine atom (CC-2) informally. ZP-J T-EXEC formalises ' + 'the role’s occupant in the lattice chart; no equation with the set Q = {Q} is stated. decoration_unique_of_val (§ X) proves uniqueness for every quiver ' + 'over abstract DecorationUniverses, and decoration_unique for finite APGs. The full ZF+AFA set-theoretic bridge ' '— showing the ZP types literally satisfy the ZF+AFA axioms — ' 'remains outside Lean scope.'], ['ZP-A CC-1 cross-check', @@ -1030,7 +1099,7 @@ def build(): 'ZeroParadox/Valuation/Scale.lean § V proves ℤ₂ admits a ZPSemilattice ' 'carrying a ValuationStructure, as an existence statement, without registering an ' 'instance; no registered instance on ℤ₂ was located in ZeroParadox/**/*.lean ' - 'on 2026-09-13.'], + 'on 2026-09-13, re-checked 2026-11-06.'], ] E.append(data_table( ['Item', 'Status', 'Description'], @@ -1047,7 +1116,8 @@ def build(): 'J_self = {⊥} with no Classical.choice | ' 'Abstraction chain: ValuationStructure → AbstractSelfApp → AFAStructure | ' 'Instances: ℕ∞, OntologicalStates | ' - 'decoration_unique: any two valid decorations of a finite APG into a DecorationUniverse agree | ' + 'decoration_unique_of_val: any two valid decorations of any quiver, finite or not, into a DecorationUniverse agree | ' + 'decoration_unique: the same for a finite APG, by a graph-side proof | ' 'All results sorry-free in Lean 4', S['endnote']), ] diff --git a/scripts/build_zpj_afa_addendum.py b/scripts/build_zpj_afa_addendum.py index 76397a78..3a73eaff 100644 --- a/scripts/build_zpj_afa_addendum.py +++ b/scripts/build_zpj_afa_addendum.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-J AFA Addendum: Decoration Uniqueness from Valuation Structure -Version 1.19 | October 2026 +Version 1.22 | November 2026 Reads after ZP-J Self-Reference. """ import os from zp_utils import * -VERSION = '1.19' +VERSION = '1.22' FIRST_RELEASED = 'May 2026' @@ -49,10 +49,15 @@ def build(): E.append(body( 'This document presents the formal consequences of ZP-J\'s valuation framework ' 'for the central uniqueness CLAUSE of Aczel\'s Anti-Foundation Axiom (AFA). ' - 'The main result is decoration_unique ' - '(ZeroParadox/Settheory/APG.lean § IX): for any finite ' - 'Accessible Pointed Graph, any two valid decorations must agree at every vertex. ' - 'The proof does not import set-theoretic AFA axioms. It derives the uniqueness ' + 'The main result is decoration_unique_of_val ' + '(ZeroParadox/Settheory/APG.lean § IX): any two decorations of any quiver, finite or ' + 'not, into a DecorationUniverse are equal, with no APG argument and no finiteness ' + 'hypothesis; it measures [propext, Quot.sound]. ' + 'decoration_unique (same section) is the finite, graph-side proof: for any finite ' + 'Accessible Pointed Graph, any two valid decorations must agree at every vertex. Its ' + 'statement is a special case of the main result (the example after ' + 'decoration_unique_finite in the same section). ' + 'Neither proof imports set-theoretic AFA axioms. Each derives the uniqueness ' 'property from a chain of abstract typeclasses whose root is ValuationStructure, ' 'established in ZP-J.')) E.append(body( @@ -66,7 +71,11 @@ def build(): 'though by bounding rather than by iterating: going once around a cycle forces ' 'a vertex’s depth to exceed itself, which only infinite depth — that ' 'is, ⊥ — can do. Acyclic vertices are handled by strong induction on ' - 'the size of the reachable set. Both cases together give decoration_unique.')) + 'the size of the reachable set. Both cases together give decoration_unique, the graph-side proof. ' + 'Read from the values instead of the vertices, the same depth does all the work and ' + 'finiteness none: a vertex whose value has finite depth has children whose values have ' + 'smaller depth, and ' + 'the only value of infinite depth is ⊥ of U. That is the main result (§IV.4).')) E.append(hr()) # ── Section I: ValuationStructure ────────────────────────────────────────── @@ -115,7 +124,7 @@ def build(): 'any x ≠ ⊥, that val(x) is finite — it is the contrapositive of ' '“infinite depth identifies ⊥” — and val_scale makes scale ' 'strictly increase it. No element of finite depth can therefore satisfy scale(x) = x. ' - 'val_bot is consumed nowhere on that chain (measured 2026-08-30); it fixes the depth ' + 'val_bot is consumed nowhere on that chain (ZeroParadox/Valuation/Scale.lean, § I); it fixes the depth ' 'of ⊥ itself, which the fixed-point argument never reads.')) E.append(result_box( @@ -177,9 +186,10 @@ def build(): E.append(body( 'AFAStructure is the lattice-level encoding of the three structural facts that ' - 'ZF+AFA provides set-theoretically: that ⊥ contains itself, that it is ' - 'the only self-containing element, and the self-membership predicate itself. ' - 'In ZF+AFA, the existence of a self-containing set follows from AFA\'s existence ' + 'ZF+AFA provides set-theoretically: that ⊥ satisfies selfMem, read in ZF+AFA as ' + 'x = {x} (bot_self_mem), that it is the only element that does (quine_unique), and the ' + 'predicate selfMem itself. ' + 'In ZF+AFA, the existence of a set x = {x} follows from AFA\'s existence ' 'clause applied to the one-node self-loop graph; uniqueness follows from AFA\'s ' 'uniqueness clause. In the ZP encoding, the existence field ' # ⚠ "supplied" is reserved on this page for DATA. bot_self_mem is a LAW - a Prop-valued @@ -266,7 +276,9 @@ def build(): '', # ⚠⚠ `Reachable` is NOT LOCATED in APG.lean as of 2026-10-09 (searched by identifier), # and the only resolution located for that name is `SimpleGraph.Reachable`, which is - # SYMMETRIC. That is + # SYMMETRIC (searched 2026-11-05 for a def/abbrev/inductive/structure/class named + # `Reachable` over the pinned Mathlib source and `ZeroParadox/**/*.lean`: that one + # hit, `Mathlib/Combinatorics/SimpleGraph/Connectivity/Connected.lean`). That is # not a naming nit: § IV.2's induction terminates ONLY because reachability here runs # ONE WAY. From an acyclic v to a child w, v is not reachable back from w, so # Reach(w) is a STRICT subset of Reach(v) and |Reach| decreases. Under a symmetric @@ -281,9 +293,10 @@ def build(): 'Reach(v) = { w : V | Nonempty (Quiver.Path v w) } (reachable from v)', '', 'In a finite APG (Fintype V), every Reach(v) is a finite set. ' - '|Reach(v)| is the cardinality used in the induction of ' + '|Reach(v)| is the cardinality used in the graph-side induction of ' 'ZeroParadox/Settheory/APG.lean § IX ' - '(this document’s §IV.2).', + '(this document’s §IV.2); the value-side proof (§IV.4) uses no ' + 'cardinality.', ] )) E.append(sp(4)) @@ -321,11 +334,15 @@ def build(): ] E.append(body( - 'The main theorem asserts that any finite APG admits at most one valid ' - 'decoration. The proof splits on whether a vertex lies on a directed cycle.')) + 'The main theorem, decoration_unique_of_val (§IV.4), asserts that any two valid ' + 'decorations of any quiver, finite or not, are equal; its proof splits on whether the ' + 'decorating value has finite depth. §§IV.1–IV.3 give the finite, graph-side ' + 'proof, decoration_unique: any finite APG admits at most one valid decoration, by ' + 'splitting on whether a vertex lies on a directed cycle. Its statement is a special case ' + 'of the main theorem.')) E.append(result_box( - 'Theorem: decoration_unique (ZeroParadox/Settheory/APG.lean §IX)', + 'Proposition: decoration_unique (ZeroParadox/Settheory/APG.lean §IX)', [ '∀ {V : Type*} [Quiver V] [Fintype V]', ' {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U]', @@ -341,7 +358,8 @@ def build(): E.append(Paragraph('IV.1 — Cyclic Vertices', S['h2'])) E.append(body( - 'A vertex v is cyclic if there exists a directed path from v back to itself. ' + 'A vertex v is cyclic if there exists a non-empty directed path from v back to itself ' + '(HasSelfCycle: an edge out of v followed by a path back). ' 'The valuation argument forces any valid decoration to assign ⊥ to every ' 'cyclic vertex, independent of which decoration is used. Both d₁ and ' 'd₂ must therefore assign ⊥ to every cyclic vertex, and they ' @@ -438,11 +456,11 @@ def build(): E.append(result_box( 'Lemma: acyclic_induction_step (ZeroParadox/Settheory/APG.lean §VIII)', [ - 'If d₁ and d₂ agree on every successor of an acyclic vertex v,', + 'If d₁ and d₂ agree on every successor of a vertex v (no acyclicity hypothesis),', 'then d₁ v = d₂ v.', 'Proof: collect is the same operation for both; d₁ and d₂ agree ' 'pointwise on children(v) by hypothesis; therefore the assembled labels agree.', - 'Lean purity: [propext, Classical.choice, Quot.sound]. ✓', + 'Lean purity: [propext, Quot.sound]. ✓', ] )) E.append(sp(4)) @@ -459,6 +477,50 @@ def build(): 'Function extensionality then closes the global equality d₁ = d₂ from that ' 'pointwise agreement; finiteness is consumed earlier, by the acyclic case’s ' 'descent on |Reach(v)|, and plays no part in this last step.')) + + E.append(Paragraph('IV.4 — The Value Side: Any Quiver', S['h2'])) + E.append(body( + 'The same uniqueness holds with no finiteness at all, by inducting on the decorating ' + 'value rather than on the graph. Fix a vertex u. If val(d₁ u) is a natural number ' + 'm, then for each child w, collect_val_ge gives m ≥ val(d₁ w) + 1, so ' + 'val(d₁ w) is a natural number below m; strong induction on m and ' + 'acyclic_induction_step give d₁ u = d₂ u. If val(d₁ u) and ' + 'val(d₂ u) are both ⊤, val_unique makes both equal ⊥ of U; if only val(d₂ u) is finite, ' + 'the finite case applies with the roles swapped. No cardinality is counted, so the graph ' + 'may be infinite.')) + E.append(result_box( + 'Theorem: decoration_unique_of_val (ZeroParadox/Settheory/APG.lean §IX)', + [ + '∀ {V : Type*} [Quiver V]', + ' {U : Type*} [ZPSemilattice U] [ValuationStructure U] [DecorationUniverse U]', + ' (d₁ d₂ : V → U),', + ' IsDecoration d₁ → IsDecoration d₂ → d₁ = d₂', + '', + 'On every quiver, finite or not, any two valid decorations into a DecorationUniverse ' + 'are equal. No APG argument, no finiteness binder.', + 'Prior art: the AFA2 half of a result Aczel sets as an exercise (Non-Well-Founded Sets, ' + 'CSLI 1988, Ex. 2.1 p. 20; AFA1/AFA2 p. 19), by its standard proof, induction on the rank ' + 'of the TARGET. It differs from the exercise by one point of rank ⊤, ⊥ of U, ' + 'admitted through val_unique.', + 'Lean purity: [propext, Quot.sound]. ✓', + ] + )) + E.append(sp(4)) + E.append(result_box( + 'Corollary: decoration_unique_finite (ZeroParadox/Settheory/APG.lean §IX)', + [ + 'decoration_unique with [Finite V] in place of [Fintype V], obtained from ' + 'decoration_unique_of_val; the [Finite V] binder appears in the statement only.', + 'Lean purity: [propext, Quot.sound]. ✓', + ] + )) + E.append(sp(4)) + E.append(body( + 'The two proofs are two charts of one uniqueness, and neither is the structure. The graph ' + 'side splits vertices cyclic/acyclic and spends finiteness on |Reach(v)|; the value side ' + 'splits depth finite/⊤ and spends none. They are related one way: a cyclic ' + 'vertex’s value has depth ⊤ (cyclic_decoration_eq_bot with val_bot); no ' + 'converse is claimed.')) E.append(sp(6)) # ── Section V: Scope and Purity ───────────────────────────────────────────── @@ -470,10 +532,10 @@ def build(): ] E.append(body( - 'decoration_unique establishes the uniqueness half of the property AFA ' - 'asserts (an axiom — Remark R-J.A) for abstract DecorationUniverses over finite ' - 'graphs. Two scope ' - 'boundaries are worth stating explicitly.')) + 'decoration_unique_of_val establishes the uniqueness half of the property AFA ' + 'asserts (an axiom — Remark R-J.A) for abstract DecorationUniverses over every ' + 'quiver, and decoration_unique by a graph-side proof over finite graphs. The scope boundary, and ' + 'where finiteness enters, are stated below.')) E.append(body( 'Existence. This document does not prove that every finite APG admits ' @@ -483,10 +545,10 @@ def build(): 'and remains an open question.')) E.append(body( - 'Finite graphs. decoration_unique requires Fintype V. The strong ' - 'induction on |Reach(v)| terminates because V is finite. Extending the result ' - 'to infinite APGs would require an ordinal induction or a well-foundedness ' - 'argument on the reachability relation, and is not addressed here.')) + 'Finiteness. decoration_unique requires Fintype V: its strong ' + 'induction on |Reach(v)| terminates because V is finite. Uniqueness itself does not ' + 'require it: decoration_unique_of_val (§IV.4) holds on every quiver, finite or ' + 'infinite, by induction on the decorating value’s depth.')) E.append(body( 'Commented-out stub. ZeroParadox/Settheory/APG.lean contains a ' @@ -518,7 +580,7 @@ def build(): 'ZeroParadox/Settheory/SetTheoryAFA.lean — AFAStructure typeclass ' '(selfMem, quine_unique, bot_self_mem), IsQuineAtom', 'ZeroParadox/Settheory/AczelConn.lean — J_self, ' - 'selfMem_determines_singleton, DC-free identification theorems', + 'selfMem_determines_singleton, choice-free identification theorems', 'ZeroParadox/Settheory/OntBridge.lean — OntologicalStates as ' 'AbstractSelfApp instance', 'ZeroParadox/Settheory/Model.lean — instNatInfZPS and instNatInfVal, ' @@ -536,7 +598,8 @@ def build(): 'same four axioms.', 'ZeroParadox/Settheory/APG.lean — APG, DecorationUniverse, val_iterate, ' 'scale_iterate_unique_fp, cyclic_decoration_eq_bot, ' - 'acyclic_induction_step, decoration_unique', + 'acyclic_induction_step, decoration_unique, decoration_unique_of_val, ' + 'decoration_unique_finite', 'All paths are repository-relative, in the public repository.', ] )) @@ -547,53 +610,39 @@ def build(): [ '[propext, Classical.choice, Quot.sound]', 'propext — propositional extensionality (standard in Lean 4)', - # ⚠⚠ THIS LINE NAMED THE WRONG SOURCE AND THEREFORE THE WRONG MODALITY. It read - # "(Mathlib Finset and Fintype machinery)". Measured 2026-09-02 with - # `lake env lean`: `ValuationStructure` — a BARE TYPECLASS mentioning neither — - # carries [propext, Classical.choice, Quot.sound], and so does - # `instAddMonoidWithOneENat`, the instance the numeral `1` in `val x + 1` reaches - # for. The route is that numeral, and Scale.lean's `_VSlit`/`_VScast` pair proves - # it is THE route rather than one of several: respelling the successor as - # `((1 : ℕ) : ℕ∞)` and changing nothing else makes the class report no axioms. - # ⚠ WHY IT MATTERED MORE THAN A CITATION SLIP: the line below says "No ZP-specific - # axioms beyond", so attributing the cost to a library turned something REMOVABLE - # into something UNAVOIDABLE. `AxiomProfile.lean` § 0 warns about exactly this — - # *"PROVENANCE and NECESSITY are independent axes, and the first version of this - # heading conflated them"* — and the corrected text keeps them apart: the tainted - # INSTANCE is Mathlib's, the SPELLING that reaches for it is this framework's, and - # a respelling clears it from the class. + # ⚠ Route (a) is measured at the pin in the [ZP-CUSTOM] line on `DecorationUniverse` + # (ZeroParadox/Settheory/APG.lean) and in that file's PurityCheck. PROVENANCE and + # NECESSITY are independent axes (`AxiomProfile.lean` § 0): the tainted instances + # are Mathlib's, and the binder that reaches for them is this theorem's. 'Classical.choice — AT LEAST FOUR ROUTES, and they are not the same ' - 'claim. (a) THE CLASSES: the numeral `1` in val_scale needs Mathlib’s ' - 'AddMonoidWithOne ℕ∞ instance, choice-tainted at the INSTANCE ' - 'level, so ValuationStructure carries the axiom as a bare typeclass before any ' - 'theorem; DecorationUniverse’s own `+ 1` in collect_val_ge reaches the same ' - 'instance. (b) A DIRECT CALL: decoration_unique’s proof takes an edge out ' + 'claim. (a) THE STATEMENT: decoration_unique binds [Fintype V], and Fintype carries ' + 'the axiom under the instances the pinned Mathlib supplies, so the statement reports ' + 'it before any proof and is STATEMENT-CARRIED in the sense of ' + 'ZeroParadox/Category/ChoiceCannotBe.md (the statement controls are the ' + 'ZeroParadox/Settheory/APG.lean record below). ValuationStructure and ' + 'DecorationUniverse themselves report no axioms. (b) A DIRECT CALL: decoration_unique’s proof takes an edge out ' 'of a Nonempty via hw.some, and Nonempty.some IS Classical.choice — not ' 'inherited through packaging, invoked. (c) CARDINALITY: the termination measure ' 'runs on Set.ncard, and Set.ncard_lt_ncard and Set.ncard_pos are each ' 'independently choice-tainted. (d) THE CASE SPLIT: the proof’s by_cases on ' - 'HasSelfCycle u is decided by Classical.propDecidable, one of the three classical-instance ' - 'gateways through which, jointly, 55.4% of Mathlib’s choice-dependence flows ' - '(L. J. Close, The Axiom Profile of Mathlib, Zenodo 2026, doi:10.5281/zenodo.20710921, ' - 'pp. 5–6; cited, not claimed).', + 'HasSelfCycle u is decided by Classical.propDecidable, the one instance in the gateway ' + 'triple (with Classical.indefiniteDescription and Classical.ofNonempty) that L. J. Close ' + 'identifies in Mathlib’s choice dependence (The Axiom Profile of Mathlib, Zenodo 2026, ' + 'doi:10.5281/zenodo.20710921, pp. 5–6, measured at Mathlib 8f9d9cf on Lean v4.28.0, ' + 'not the Mathlib 56a0058 on Lean v4.35.0 this repository pins; cited, not claimed).', 'Quot.sound — quotient soundness (standard in Lean 4)', - '• A RESTATEMENT CLEARS IT FOR THE CLASS; NO PROOF CAN CLEAR IT FOR THE ' - 'THEOREM AS STATED — and the difference is the whole claim. ' - 'ZeroParadox/Valuation/Scale.lean transcribes the class twice, as _VSlit and ' - '_VScast, differing only in route (a)’s numeral, which _VScast writes ' - '((1 : ℕ) : ℕ∞): _VSlit reports [propext, Classical.choice, ' - 'Quot.sound] and _VScast reports no axioms. The declared class still reports the ' - 'axiom; _VScast is a respelling of it, not a proof. ' - 'decoration_unique’s STATEMENT carries the axiom: a theorem that only ' - 'assumes that statement and proves True reports [propext, Classical.choice, ' - 'Quot.sound] (the statement control, measured 2026-10-09), so no proof of ' - 'decoration_unique as stated can remove it — the STATEMENT-CARRIED class of ' - 'ZeroParadox/Category/ChoiceCannotBe.md, recorded at DecorationUniverse in ' - 'ZeroParadox/Settheory/APG.lean. Routes (b), (c) and (d) lie in the proof, not the ' - 'statement. Measured 2026-10-09: the same statement restated over clean spellings of ' - 'both classes reports only [propext, Quot.sound] under the statement control, and ' - 'route (b)’s edge step, re-proved with obtain in place of .some, reports no ' - 'axioms; routes (c) and (d) were not re-proved in that measurement.', + '• NO PROOF CAN CLEAR IT FOR THE THEOREM AS STATED, AND THE STATEMENT IS ' + 'READ UNDER THE PINNED INSTANCES — both halves are the claim. The record is the ' + 'DecorationUniverse [ZP-CUSTOM] line of ZeroParadox/Settheory/APG.lean: the full ' + 'statement of decoration_unique, assumed and used for nothing, reports the three ' + 'axioms; the same statement with [Finite V] in place of [Fintype V] reports none; and ' + '∀ {U} [ZPSemilattice U] [ValuationStructure U], True reports none. So the ' + '[Fintype V] binder carries the axiom and the [ValuationStructure U] binder does not. ' + 'Which bin a statement falls in is relative to the instances it is elaborated under ' + '(ZeroParadox/Category/ChoiceCannotBe.lean § III, STATEMENT-CARRIED IS ' + 'INSTANCE-RELATIVE). Routes (b), (c) and (d) lie in the proof. The [Finite V] ' + 'restatement has a proof free of all four: decoration_unique_finite, from ' + 'decoration_unique_of_val, each [propext, Quot.sound] (§IV.4).', 'No ZP-specific AXIOM is declared anywhere in this chain; the footprint above is ' 'what the Lean reports, not a commitment the framework makes.', 'No Dependent Choice. No additional set-theoretic assumptions.', @@ -639,7 +688,8 @@ def build(): 'Endnote: This document is an addendum to ZP-J Self-Reference and reads after ' 'it. The derivation chain (ValuationStructure → AbstractSelfApp → ' 'AFAStructure) is established in ZP-J; this document applies it to the APG ' - 'decoration problem. It covers the uniqueness result for finite graphs. ' + 'decoration problem. It covers the uniqueness result for every quiver ' + '(decoration_unique_of_val) and its finite, graph-side proof for APGs (decoration_unique). ' 'All active theorems are sorry-free in Lean 4 ' '(one commented-out stub; see §V).', S['endnote'])) diff --git a/scripts/build_zpj_companion.py b/scripts/build_zpj_companion.py index f170f064..6e1d8f44 100644 --- a/scripts/build_zpj_companion.py +++ b/scripts/build_zpj_companion.py @@ -1,59 +1,6 @@ """ Build ZP-J Illustrated Companion -Version 1.34 | October 2026 -v1.33: ROUND-6 OUTSTANDING CLOSEOUT, items 3a, 3b, 3d, 6 (corpus-zpj-v2.8-round6-outstanding.md -EXECUTION SPEC 2026-09-28). 3a (CC-2 proved half): the Foundation-freeness sentence cited no -identifier; it now cites wf_no_selfloop (ZeroParadox/Settheory/Wall.lean - fully general, no -well-founded relation admits a self-loop), with quineHost_not_wellFounded / zfSet_no_quine_bottom -(QuineHost.lean) named as its QuineHost- and ZFSet-specific corollaries rather than the general -claim's citation. 3b (Z_[2] remember box): "admits a lattice carrying THIS valuation structure" -overclaimed a specific instance where Scale.lean section V proves only existence (Nonempty -ValuationStructure); now "a valuation structure". 3d (APG well-founded corollary): "Mostowski's -Collapsing Lemma (p. 4)" cited the general lemma for a claim that is actually Corollary 1.1 (p. 5) -of Aczel's manuscript; now cites Corollary 1.1 and keeps the Collapsing Lemma as what it follows -from. 6 (Z_[2] lattice note): "no lattice on Z_[2] is registered in the corpus" was undated, unlike -the formal document's parallel claim; now dated "as of 2026-09-28". -v1.32: CC-1 STATUS SYNC with ZP-J v2.8. The abstraction-chain table cell 'T-EXEC, J1, CC-1 as proved theorems' collapsed CC-1 to its proved half; it now reads 'CC-1 in conditional form'. cc1_derived proves the conditional (a Quine-atom start is a bottom start) and t_exec_iff the converse; the starting-point choice is restated, not forced, since a valid state sequence can start above bottom. GATE ROUND 2 (ordinary, carried): the 'not forced' reason needs its scope - on a ONE-point lattice every sequence starts at bottom, so the countermodel is stated for a lattice with a second point, and the OntBridge.lean example now also shows the start is not a Quine atom. Editorial O1: p1 said CC-2 is 'no longer a freestanding modelling assumption'; it remains ZP-A's Forced Metatheoretic Commitment, read at the lattice level as the role. Key Results: T-EXEC proves whatever fills the role is bottom (t_exec), not 'only occupant'. -v1.31: COMPANION SYNC WITH ZP-J v2.7 (ZPJ-ITER, ZPJ-AFA-THM). "Graphs That Decorate Themselves" said composing the decoration equation around a cycle gives d(v) = scale^k(d(v)); cyclic_decoration_eq_bot never forms that equation, and it holds only at single-child vertices. The cyclic paragraph now gives the depth BOUND in plain language. AFA was called a theorem at four sites ("the unique decoration theorem", "AFA proves", "AFA's central uniqueness theorem", "AFA's decoration theorem"); Aczel ch. 1 p. 6 states it as an axiom over every graph, and each site now says so. Also, measured 2026-09-13: the Z_[2] model's Classical.choice was attributed to Mathlib alone at two sites; Mathlib's 2-adic structures carry it already in the statements (a type probe over Mathlib's multiplication reports it), and the valuation q2Val adds its own route through instDecidableEqZ2 := Classical.decEq, so both sites name both routes. And the opening said ZP-J proves T-EXEC "using the valuation structure of Q2 and the AFA uniqueness result"; t_exec is (hq.2 bot AFAStructure.bot_self_mem).symm and uses no valuation, which enters later as the explanation of uniqueness. EDITORIAL ROUND 1, Tim's call on the claim ("match the Lean"): the section formerly headed "Two Assumptions That Became Theorems" ran an implication BACKWARDS - it said the ZP-A axioms "force the bottom element to be self-containing", but bot_self_mem is a class FIELD that t_exec consumes; CC-2 now reads as an input plus an argued commitment and CC-1 as cc1_derived actually binds it (a state sequence starting at a Quine atom). Also: the T-EXEC box cited the one-direction t_exec for an iff and equated q = {q} with q in q; the Z_[2] model was presented as the full AFA route when it runs through ValBridge and reaches only the fixed-point shadow; and "these three fields can be derived" now names the two laws. EDITORIAL ROUND 2 (FAIL-BEDROCK): round 1 corrected the CC-2 section only, so four other sites still said the reverse ("a derived consequence of T-EXEC at the structural level", "T-EXEC proves the structural self-containment fixed point", "ZP-J makes that argument formal" after "which forces bottom = {bottom}", and "T-EXEC makes this explicit" under the set-membership row) - a half-applied fix turning a consistent error into a self-contradiction. Tim: "Bot is a role not a fixed value... I thought we had this worked out long ago?" It was: SetTheoryAFA.lean's NO-GO gauge says the class encodes the ROLE. Every CC-2 site now says that T-EXEC identifies the occupant of the Quine-atom role and the literal set fact is the ZF+AFA commitment. Also: T-EXEC was credited to the quine_unique field it does not use (it uses bot_self_mem and the uniqueness half of its own hypothesis); "bottom in bottom, i.e. bottom = {bottom}" reversed to the true direction; CC-1's hypothesis restored; decoration uniqueness scoped to DecorationUniverses; "the uniqueness half of what AFA asserts" is now an analogue. EDITORIAL ROUND 3 (FAIL-BEDROCK): the disclaimer and the opening still said bottom = {bottom} is "provably the unique bottom element" and "a derived theorem" two sentences before the corrected paragraph denied it. Restated to Wheel.lean's CC-2 convention: the set identity is stated only of AFA set theory, where it is well-typed, and the lattice-level statement is the role and its occupant. The Remember box and Key Results no longer call bottom both the role and the occupant; "the self-containing set is {bottom}" now says the SET OF self-containing elements is {bottom}; the Quine-atom diagram caption says the picture is of the AFA set. ADVERSARY ROUND 4 (FAIL-BEDROCK, D1): the section headed "Aczel's DC Question - Closed for Self-Membership" said "ZP-J answers this question for the self-membership case: DC is not essential". The Lean identifies the set of self-containing elements in a lattice with no Classical.choice; it defines no set-continuous operator and never meets the step of Aczel's proof that uses DC, so it answers nothing about that proof. This is the recurrence of the v1.20/v1.22 AR fixes, which had removed the Aczel-specific claim. Retitled and restated; the intro and Key Results no longer say "no Dependent Choice". TIM'S CALL ON ROUND 4 (carrier): CC-1 restated as an equivalence - given AFAStructure, starting at a Quine atom and starting at bottom are the same condition (cc1_derived, and t_exec_iff for the converse), so CC-1 is restated through the role, not forced; the opening, the Two Assumptions section and Key Results say so, and that section no longer says the claims "became theorems". ROUND-4 ORDINARY RESIDUE: the T-EXEC box no longer places a Lean theorem "in the ZF+AFA setting" and says ZP-A semilattice, not "any type"; the Remember box no longer says "properly grounded under AFA" (a condition no bottom fails); the abstraction-chain paragraph now says every ZP-A semilattice supplies the class trivially; CC-2 is ZP-A's argued metatheoretic commitment, not "previously a modelling commitment". ADVERSARY ROUND 5 (FAIL-BEDROCK, D1): the abstraction-chain section ran the implication BACKWARDS - "AbstractSelfApp requires less", "ValuationStructure requires even less", "Each layer of the chain removes one more thing you have to assume" - one sentence after saying every ZP-A semilattice carries AFAStructure trivially. toAbstractSelfApp and toAFAStructure are instances, so ValuationStructure is the STRONGEST assumption: every lattice carries AbstractSelfApp and AFAStructure, and valuationStructure_forces_infinite makes any nontrivial ValuationStructure carrier infinite, which is why OntologicalStates has none. The section now reads the table top-down with the stronger rows on top, says the stronger rows buy an explanation rather than fewer assumptions, and is retitled from "Peeling Back the Layers"; ValBridge (weaker than ValuationStructure, and not a route to AFAStructure) now sits "beside the chain" rather than "one more layer underneath"; the opening, the "four directions" summary, the valuation-argument lead-in and Key Results no longer say the chain reduces the commitments. TWO-POLE AUDIT RESTORATIONS (Tim: restore all): (L2) CC-2 is ZP-A's Forced Metatheoretic Commitment with a proved half (Foundation-freeness) and an argued half; (L3) the opening, Two Assumptions and Key Results no longer say the set equation is "not derived" - in AFA set theory Q = {Q} is a theorem with exactly one solution (Aczel Ex. 1.3) and the commitment is that the framework's bottom is that set; (L5) the Z_[2] remember box keeps that Scale.lean section V proves Z_[2] admits the full chain as an existence statement; (L8) the APG section keeps that "every APG pictures a unique set" follows from AFA and that Mostowski gives the well-founded case without it. Also the Quine atom is "its own sole member" rather than "self-containing" (0* = {empty, 0*} is self-membered and not the Quine atom, Aczel Ex. 1.5); the opening's "in that setting" for a Lean equivalence; and "a simpler input, fixed_bot" (pre-round-5 polarity; the structure carrying fixed_bot is the stronger one). -v1.30: FIELD-COUNT SLIP CORRECTED (companion sync with ZP-J v2.6). "AFAStructure has three typeclass fields - three things you must prove" counted the DATA field as an obligation: SetTheoryAFA.lean:80 declares `selfMem : L -> Prop`, a predicate you SUPPLY, alongside two laws you prove. Same slip the formal document carried for DecorationUniverse, where counting `collect` as a law is what made two laws read as three. -v1.29: rendered Lean citations synced to post-reorg files/namespaces the earlier passes missed (bare ZPx.lean / ZeroParadox.ZPx.* / ZPx.; SSOT-driven). -v1.28: rendered Lean-file citations synced to post-reorg basenames (namespace de-scar); docstring changelog above kept as the historical record. -v1.26: FMC precision (sweep Step 4) — Key Results box and the T-EXEC body line now split the proved structural fixed point (axiom-free) from the argued set-membership reading (the ZF+AFA setting itself). -v1.25: §6 "future work" bridge sentence retired — the 2-adic valuation argument is now formalized (ZPJ_ScaleBridge wired into the maintained build); §7 gains the common-ancestor (ValBridge) framing — the abstract lattice track and ℤ₂ are instances of one minimal typeclass; §8 adds ℤ₂ as a third concrete model. The ℤ₂ instance is flagged as inheriting Classical.choice from Mathlib's p-adic library (unlike the axiom-free core T-EXEC). -v1.24: Directed-graph (APG) diagram added for the Quine atom (self-loop + well-founded chain ending at ∅); arithmetic analogy scoped (it cannot show ⊥={⊥} — routed to mirror/graph); "depth" rephrased from "how far from ⊥" to intrinsic descent/valuation (Dan feedback 2026-06-15). Fixed latent null glyph scaleᵏ (ᵏ → k). -v1.23: "his question" pronoun fixed; abstraction chain direction clarified; remember_box leads with analogy; p-adic removed from disclaimer (future work); "Not three separate" prose replaced; T-EXEC antecedent named (ER/AR fixes). -v1.22: "ZP lattice" replaced with structural description; "bounded semilattice" corrected to join-semilattice; AFAStructure typeclass used directly; Aczel specific claims replaced with generic AFA fixed-point framing (ER/AR fixes). -v1.21: ZP-A semilattice replaced with standard structural description; section heading scoped; AFA/ZP-J framing clarified; "uniqueness half" hedged as analogous (AR fixes). -v1.20: Aczel attribution removed; open question stated without attribution (AR fix). -v1.19: Plain-meaning table corrected; AFA/ZP-J scope clarified; sorry note added to key result box (AR/ER fixes). -v1.18: Three residual em-dashes in three_way_table() removed (ER fix). -v1.17: Em-dashes removed; Quine Atom added to tagline; 2-adic analogy caveat moved to front (AR/ER fixes). -v1.16: Title reverted to "The Self-Containing Null". -v1.15: Title changed to "The Quine Atom" (standard AFA term). -v1.14: "full AFA decoration" scoped to finite APGs; Aczel quote paraphrased; sorry-free claim scoped (ER fixes). -v1.13: Disclaimer leads with AFA math before brand name (AR fix). -v1.12: "Zero Paradox" expanded in disclaimer; "Really" dropped from subtitle (AR fix). -v1.11: Em-dashes removed from subtitle and first body paragraph; opening paragraph - rewritten to lead with AFA mathematical content (AR/ER fix). -v1.10: Header banner color corrected INDIGO → COMP_BLUE (matches all other companions). -v1.9: Cover and disclaimer updated to reflect that this companion serves both - ZP-J Self-Reference and ZP-J AFA Addendum. -v1.8: quine_atom_diagram — replace HTML entities (⊥) with literal ⊥ in - String() drawing primitives; entities render literally there, not as glyphs. -v1.7: vocab fix: ZP-J v2.0 → ZP-J. -v1.6: Five new sections added for ZP-J content — the valuation argument, - the abstraction chain, two concrete models, Aczel's DC question, and - APG decoration uniqueness. Key result box updated. -v1.5: Strip version number from companion footer. -v1.4: Strip version number from disclaimer cross-reference to ZP-J formal document. -v1.3: Disclaimer updated — "formal ontology" replaced with "formal document". Opening paragraph - revised — DA-1 glossed on first use instead of using internal label alone. -v1.2: quine_atom_diagram: dh increased (2.0 → 2.8 in), cy changed to fixed 110 so the - "⊥ = {⊥}" label (cy - r_outer - 18) no longer falls at y=-18 below the drawing box. -v1.1: Corrected CC-2 status to metatheoretic commitment within ZF+AFA; commitment shifts -to the AFA setting itself. CC-1 remains fully discharged axiom-free. Aligns with R-J.0. -v1.0: Initial release. Covers T-EXEC (Quine atom = ⊥), the three-way equivalence, -and the closure of CC-1 and CC-2 as derived theorems rather than freestanding commitments. +Version 1.42 | November 2026 """ import os @@ -82,11 +29,11 @@ def quine_atom_diagram(): r_inner = 28 d.add(Circle(cx, cy, r_inner, fillColor=INDIGO, strokeColor=INDIGO, strokeWidth=0)) - d.add(String(cx - 9, cy - 6, '⊥', + d.add(String(cx - 6, cy - 6, 'Q', fontSize=16, fontName='DV-B', fillColor=WHITE)) - # Label: ⊥ = {⊥} - d.add(String(cx - 28, cy - r_outer - 18, '⊥ = {⊥}', + # Label: Q = {Q} (the AFA set; the lattice's occupant of the role is a separate theorem) + d.add(String(cx - 28, cy - r_outer - 18, 'Q = {Q}', fontSize=13, fontName='DV-B', fillColor=INDIGO)) # Self-membership arrow @@ -97,8 +44,8 @@ def quine_atom_diagram(): d.add(Line(bx + 5, by - 6, bx, by, strokeColor=INDIGO, strokeWidth=1.5)) d.add(String(14, 10, - 'The Quine atom: ⊥ is a member of itself. ' - 'The outer ring is the set {⊥}; the inner disk is ⊥ as an element.', + 'The Quine atom (CC-2) in AFA: Q is its own sole member. ' + 'The outer ring is the set {Q}; the inner disk is Q as an element.', fontSize=7.5, fontName='DV-I', fillColor=GREY_TEXT)) return d @@ -128,7 +75,7 @@ def quine_graph_diagram(): # RIGHT — Quine atom ⊥ with a self-loop (dashed: exits right, re-enters the top) qx = 365 d.add(Circle(qx, cy, 18, fillColor=INDIGO, strokeColor=INDIGO, strokeWidth=0)) - d.add(String(qx - 9, cy - 6, '⊥', fontSize=16, fontName='DV-B', fillColor=WHITE)) + d.add(String(qx - 6, cy - 6, 'Q', fontSize=16, fontName='DV-B', fillColor=WHITE)) loop = Path(strokeColor=INDIGO, strokeWidth=1.4, fillColor=None, strokeDashArray=[2.5, 2.5]) loop.moveTo(qx + 18, cy) # exit the right edge @@ -137,7 +84,7 @@ def quine_graph_diagram(): # solid arrowhead at the top entry, pointing down into the ball d.add(Line(qx - 5, cy + 25, qx, cy + 18, strokeColor=INDIGO, strokeWidth=1.4)) d.add(Line(qx + 5, cy + 25, qx, cy + 18, strokeColor=INDIGO, strokeWidth=1.4)) - d.add(String(qx - 42, cy - 42, '⊥ = {⊥}: the chain loops on itself', + d.add(String(qx - 42, cy - 42, 'Q = {Q}: the chain loops on itself', fontSize=8, fontName='DV-I', fillColor=GREY_TEXT)) return d @@ -148,9 +95,11 @@ def three_way_table(): Paragraph('What ⊥ satisfies', CS['tbl_hdr']), Paragraph('Plain meaning', CS['tbl_hdr'])] rows = [ - ['Set theory (AFA)', - '⊥ = {⊥} (so ⊥ ∈ ⊥)', - '⊥ contains exactly one element: itself. AFA allows at most one set that is its own ' + ['Membership host (the QuineAtomHost an AFAStructure on L builds)', + 'is the occupant of the Quine-atom role in that host, ' + 'the role the set Q = {Q} plays in AFA set theory (quineAtomHost_quine_role_iff with ' + 'afaStructure_isQuineAtomHost)', + 'In AFA the set Q = {Q} contains exactly one element: itself. AFA allows at most one set that is its own ' 'sole member (x = {x}); bare self-membership is not unique there (see the T-EXEC box above). ' 'The Lean requirement: QuineAtomHost, ZeroParadox/Settheory/QuineHost.lean § VII'], ['Order theory (ZP-A)', @@ -173,7 +122,7 @@ def three_way_table(): ('LEFTPADDING', (0,0),(-1,-1), 6), ('RIGHTPADDING', (0,0),(-1,-1), 6), ('VALIGN', (0,0),(-1,-1), 'TOP'), ]) - t = Table(data, colWidths=[TW*0.22, TW*0.28, TW*0.50]) + t = Table(data, colWidths=[TW*0.22, TW*0.38, TW*0.40]) t.setStyle(ts); return t @@ -210,7 +159,7 @@ def abstraction_chain_table(): t.setStyle(ts); return t -VERSION = '1.34' +VERSION = '1.42' FIRST_RELEASED = 'April 2026' @@ -240,11 +189,11 @@ def footer_cb(canvas, doc): hdr.setStyle(hdr_ts) E += [hdr, sp(6), Paragraph('The Self-Containing Null', CS['title']), - Paragraph('What ⊥ = {⊥} Means, and Why It Matters', CS['subtitle']), + Paragraph('What the Quine Atom Means, and Why It Matters', CS['subtitle']), Paragraph('ZP Companion | The Quine Atom | ' + version_line(FIRST_RELEASED, VERSION), CS['meta']), Paragraph( - 'This companion explains in plain language what ⊥ = {⊥} (the Quine atom ' - 'of AFA set theory) means, and the proof that whatever plays that role in a lattice ' + 'This companion explains in plain language what the Quine atom (CC-2; in AFA set theory ' + 'the set Q = {Q}) means, and the proof that whatever plays that role in a lattice ' 'is its unique bottom element. ' 'This is one result in the Zero Paradox project (ZP-J), connecting ' 'AFA set theory, p-adic topology, and lattice algebra. ' @@ -258,12 +207,17 @@ def footer_cb(canvas, doc): # ── What Is ZP-J Doing? ────────────────────────────────────────────────── E.append(Paragraph('What Is ZP-J Doing?', CS['h1'])) E.append(cbody( - 'In AFA set theory the Quine atom is the set Q satisfying Q = {Q}, and the framework ' - 'identifies the bottom element ⊥ with it. That identification is a statement about ' - 'sets; a lattice cannot state it directly, because it would compare an element with a set ' - 'of elements. ZP-E argues, informally, that ' - 'nothing external to ⊥ can execute ⊥, so ⊥ must execute itself, and ' - 'reads that as ⊥ = {⊥} (see ZP-E for the full three-path argument).')) + 'In AFA set theory the Quine atom is the set Q satisfying Q = {Q}. The framework treats the ' + 'Quine atom (CC-2) as a ROLE: a point that steps to itself and to nothing else, here along ' + 'membership. Each setting has its own occupant, proved there: Q in AFA set theory; none in ' + 'Mathlib\'s sets, which obey Foundation (zfset_quine_role_unoccupied, ' + 'ZeroParadox/Settheory/Wall.lean); and ⊥ in a lattice carrying the role ' + '(quineAtomHost_quine_role_iff, ZeroParadox/Settheory/QuineDichotomy.lean). No equation between ' + '⊥ and Q is written, because it would compare an element of a lattice with a set. ' + 'ZP-E argues, informally, that ' + 'nothing external to ⊥ can execute ⊥, so if ⊥ executes at all, the executor is ' + '⊥ itself, and reads that as ⊥ occupying the Quine-atom role. That rules out an external executor, not an ' + 'inert ⊥ (see ZP-E for the full three-path argument).')) E.append(cbody( 'ZP-J formalises the structural part of that picture. The Quine atom becomes a ROLE, not a ' 'fixed value: the AFAStructure typeclass describes it, and its field bot_self_mem places ' @@ -272,11 +226,11 @@ def footer_cb(canvas, doc): 'element - is the bottom element ⊥; its later sections add a valuation argument, ' 'also machine-checked for the 2-adic integers, that derives the typeclass laws in ' 'carriers that have a depth measure. ' - 'CC-2 (⊥ = {⊥}) remains a commitment (ZP-A calls it a Forced Metatheoretic ' + 'CC-2, the Quine atom, remains a commitment (ZP-A calls it a Forced Metatheoretic ' 'Commitment); at the lattice level it is read as that role, and T-EXEC identifies the role\'s occupant. In AFA set theory the set ' - 'Q = {Q} exists and is unique, a consequence of the axiom (Aczel 1988, Example 1.3); that the ' - 'framework\'s ⊥ is that set is the commitment, argued rather than chosen freely, and not a ' - 'Lean theorem. CC-1 (S₀ = ⊥) is restated, not forced: in any lattice carrying the ' + 'Q = {Q} exists and is unique, a consequence of the axiom (Aczel 1988, Example 1.3); adopting AFA ' + 'for the set setting is the commitment, argued rather than chosen freely, and not a ' + 'Lean theorem, and no equation between ⊥ and Q is claimed. CC-1 (S₀ = ⊥) is restated, not forced: in any lattice carrying the ' 'typeclass, a state sequence starts at a Quine atom exactly when it starts at ⊥, and on a ' 'lattice with a second point a valid sequence can start above ⊥, at a point that is not a ' 'Quine atom, so the choice of starting point is expressed through the role rather than removed.')) @@ -285,7 +239,8 @@ def footer_cb(canvas, doc): 'self-containing elements as {⊥} without the axiom of choice; it derives the ' 'typeclass laws from stronger structures, ending in a valuation argument; it ' 'demonstrates the structure on two concrete types; and it proves a ' - 'decoration uniqueness theorem for finite APGs into abstract DecorationUniverses.')) + 'decoration uniqueness theorem for every directed graph, finite or not, into abstract ' + 'DecorationUniverses, with a separate graph-side proof for finite APGs.')) E.append(sp(4)) # ── What Is a Quine Atom? ──────────────────────────────────────────────── @@ -295,7 +250,7 @@ def footer_cb(canvas, doc): 'a measure of how deeply nested its membership is. A set like {{{∅}}} has rank 3 ' 'because you have to unwrap three layers to reach the empty set. Importantly, no ' 'set under Foundation can be a member of itself: that would create an infinite ' - 'descending chain ⊥ ∋ ⊥ ∋ ⊥ ∋ … with no bottom.')) + 'descending chain x ∋ x ∋ x ∋ … with no end.')) E.append(cbody( 'Anti-Foundation (AFA) drops that prohibition. It allows non-well-founded sets - ' 'sets that can be members of themselves. The simplest such object is the Quine atom: ' @@ -305,24 +260,25 @@ def footer_cb(canvas, doc): 'self-loop it guarantees exactly one such set exists.')) E.append(quine_atom_diagram()) E.append(ccaption( - 'The Quine atom ⊥ = {⊥}, pictured as a set in AFA set theory: ⊥ is the sole member of itself. ' - 'The outer ring is the set {⊥} and the inner disk is ⊥ as an element. ' - 'They are the same object.')) + 'The Quine atom (CC-2), pictured as a set in AFA set theory: Q is the sole member of itself. ' + 'The outer ring is the set {Q} and the inner disk is Q as an element. ' + 'They are the same set. In a lattice the role\'s only occupant is ⊥ (T-EXEC); no equation ' + 'between ⊥ and Q is written.')) E.append(sp(6)) E.append(quine_graph_diagram()) E.append(ccaption( 'A second way to see it - as a directed graph (an "accessible pointed graph", or APG, ' 'the structure Aczel\'s anti-foundation axiom decorates). Each arrow points from a set ' 'to one of its members. Ordinary sets are well-founded: following the arrows always ends, ' - 'here at the empty set ∅. The bottom ⊥ is the lone exception - its arrow loops straight ' - 'back to itself. That self-loop is exactly ⊥ = {⊥}, the Quine atom: a membership chain ' + 'here at the empty set ∅. The Quine atom Q is the lone exception - its arrow loops straight ' + 'back to itself. That self-loop is exactly Q = {Q}: a membership chain ' 'that never bottoms out.')) E.append(sp(4)) E.append(example_box('Real-world analogy - A mirror facing a mirror', [ 'Hold two mirrors facing each other. Each reflection contains the other mirror, ' 'which contains another reflection, which contains another mirror … infinitely. ' 'The image is self-referential: the full scene is visible inside itself at every ' - 'level. The Quine atom ⊥ = {⊥} has this structure - ⊥ is inside ' + 'level. The Quine atom Q = {Q} has this structure - Q is inside ' 'itself, not as a smaller copy, but as the same object.', ])) E.append(sp(8)) @@ -357,25 +313,28 @@ def footer_cb(canvas, doc): 'bottom element plays it. The two notions identify the same object.')) E.append(sp(8)) - # ── Three Languages, One Object ────────────────────────────────────────── - E.append(Paragraph('Three Languages, One Object', CS['h1'])) + # ── Three Languages, One Element of the Lattice ─────────────────────────── + E.append(Paragraph('Three Languages, One Element of the Lattice', CS['h1'])) E.append(cbody( - 'T-EXEC establishes a three-way identification. ⊥ is the same object described ' - 'in three different mathematical languages:')) + 'T-EXEC establishes a three-way identification within one lattice: in a lattice L carrying ' + 'AFAStructure, the Quine-atom predicate, the least element and the join identity pick out one ' + 'element of L, ⊥ of L (t_exec_triple_iff with da2_bottom_characterization), described in three different mathematical ' + 'languages:')) E.append(three_way_table()) E.append(sp(4)) E.append(cbody( 'These are not three separate properties that happen to coincide. They are three ' 'descriptions of the same structural role. T-EXEC machine-checks that the three roles ' - 'have one occupant (t_exec_triple_iff); the set-theory row is the AFA reading of the ' - 'first role, not a Lean statement.')) + 'have one occupant (t_exec_triple_iff with da2_bottom_characterization), and quineAtomHost_quine_role_iff at ' + 'afaStructure_isQuineAtomHost does so for the membership-host row; that row is the Lean chart whose AFA ' + 'reading is the set Q = {Q}; that reading is not a Lean statement.')) E.append(sp(4)) E.append(example_box('Real-world analogy - Zero in arithmetic (partial)', [ '0 in arithmetic wears more than one hat at once: it is the additive identity ' '(x + 0 = x) and the smallest non-negative integer (0 ≤ n for all n ∈ ℕ). ' 'Those two line up cleanly with ⊥ as join identity and ⊥ as minimum. ' 'But arithmetic has no honest way to show the third hat - ⊥ as the Quine atom ' - '(⊥ = {⊥}, "zero inside zero"): ordinary numbers simply do not contain themselves. ' + '(the role the AFA set Q = {Q} plays, "zero inside zero"): ordinary numbers simply do not contain themselves. ' 'For that self-containing property the right pictures are the mirror-facing-a-mirror ' 'analogy and the directed graph above, not arithmetic.', ])) @@ -395,7 +354,7 @@ def footer_cb(canvas, doc): 'that certain structural facts were assumed rather than derived. ZP-J restates both in ' 'terms of a role, and neither commitment disappears:')) E.append(cbody( - 'CC-2 (⊥ = {⊥}): In ZP-A, a Forced Metatheoretic Commitment with two ' + 'CC-2 (the Quine atom): In ZP-A, a Forced Metatheoretic Commitment with two ' 'halves: that any set theory hosting a self-membered bottom gives up Foundation is proved in ' 'Lean (wf_no_selfloop, ZeroParadox/Settheory/Wall.lean - no well-founded relation admits a ' 'self-loop; the QuineHost-specific case is its corollary quineHost_not_wellFounded, and ' @@ -405,7 +364,8 @@ def footer_cb(canvas, doc): 'AFAStructure typeclass encodes, with its field bot_self_mem placing ⊥ in it. T-EXEC ' 'proves that whatever fills that role is ⊥. In AFA set theory the equation Q = {Q} is ' 'itself a theorem, with exactly one solution (Aczel 1988, Example 1.3); what is not derived is ' - 'that the framework\'s ⊥ is that set, which is the commitment.')) + 'the adoption of AFA for the set setting, which is the commitment. No equation between ⊥ ' + 'and Q is written: each setting\'s occupant of the role is that setting\'s own theorem.')) E.append(cbody( 'CC-1 (S₀ = ⊥): ZP-J proves cc1_derived in Lean 4: if a ' 'state sequence starts at a Quine atom, it starts at ⊥, because T-EXEC identifies ' @@ -432,8 +392,9 @@ def footer_cb(canvas, doc): 'Imagine every element carries a "depth" - a value in the extended naturals ' '{0, 1, 2, …, ∞} given by how many times you can descend through its ' 'structure before bottoming out. Ordinary elements bottom out ' - 'in finitely many steps, so their depth is finite; ⊥ never bottoms out - it ' - 'contains itself - so its depth is ∞. Applying scale - the self-application ' + 'in finitely many steps, so their depth is finite; ⊥ of the lattice never bottoms ' + 'out - its depth is ∞, the field val_bot (val ⊥ = ⊤) of ' + 'ValuationStructure. Applying scale - the self-application ' 'operation - raises depth by exactly 1 at every non-⊥ element. ' 'So if scale(x) = x, then depth(x) = depth(x) + 1 - an equation with no finite ' 'solution. Only ⊥, whose depth is already ∞ (and ∞ + 1 = ∞ in ' @@ -583,10 +544,12 @@ def footer_cb(canvas, doc): E.append(cbody( 'ZP-J proves something different: a uniqueness-only result for abstract DecorationUniverses - ' 'types carrying the ValuationStructure and a collect operation, without importing AFA axioms. ' - 'The result: for any finite APG, any two valid decorations must agree at every vertex. ' + 'The result: on any directed graph, finite or infinite, any two valid decorations ' + 'must agree at every vertex (decoration_unique_of_val). For finite APGs a separate, ' + 'graph-side proof gives the same (decoration_unique). ' 'Existence is not proved; the ZP-J result is a constraint, not a construction.')) E.append(cbody( - 'The proof follows the same two-direction logic as T-EXEC:')) + 'The finite, graph-side proof follows the same two-direction logic as T-EXEC:')) E.append(cbody( 'Cyclic vertices: Collecting a set of children always raises depth by at least 1, ' 'so a vertex is at least one step deeper than each of its children. Walk once around a ' @@ -600,25 +563,39 @@ def footer_cb(canvas, doc): 'induction. If two decorations agree on all the children of a vertex, they must ' 'agree on the vertex itself - because the label is assembled from the children\'s ' 'labels and the assembly rule is the same. The induction terminates because the ' - 'set of reachable vertices strictly shrinks at each child.')) + 'set of reachable vertices strictly shrinks at each child. Counting those vertices is ' + 'what needs the graph to be finite.')) + E.append(cbody( + 'The other reading: instead of sorting vertices into cyclic and acyclic, sort ' + 'the labels by depth. A label of finite depth n is assembled from children whose labels ' + 'have depth below n, so induction on n settles it; the only label of infinite depth is ' + '⊥ of the decorating type. Think of a recursion that terminates on the size of its ' + 'output rather than its input: nothing about the graph is counted, so the graph may be ' + 'infinite (decoration_unique_of_val). This adapts the standard proof of a result Aczel sets ' + 'as an exercise, that the Foundation axiom gives every graph at most one decoration (Aczel, ' + 'Non-Well-Founded Sets, 1988, Exercise 2.1, p. 20), with one exception admitted: the single ' + 'label of infinite depth. The two readings are linked one way: a cyclic ' + 'vertex gets infinite depth, and nothing is claimed in reverse.')) E.append(sp(4)) E.append(remember_box( - 'decoration_unique is the ZP analogue of the uniqueness clause of AFA, which is an axiom. ' + 'decoration_unique_of_val is the ZP analogue of the uniqueness clause of AFA, which is an axiom. ' 'It does not construct a decoration or prove one exists - it proves that ' 'any two valid decorations must be identical. It is an analogue of the uniqueness half ' 'of what AFA asserts, not that clause itself: it is proved for abstract ' - 'DecorationUniverses over finite graphs, without importing set-theoretic AFA axioms.')) + 'DecorationUniverses over every graph, finite or not, without importing set-theoretic ' + 'AFA axioms. decoration_unique is its finite form: a graph-side proof for finite APGs.')) E.append(sp(8)) # ── Key Result Box ─────────────────────────────────────────────────────── E.append(key_result_box( 'Key Results - ZP-J', 'T-EXEC (axiom-free, Lean 4): IsQuineAtom(q) ↔ q = ⊥. ' - 'The Quine atom, the order minimum, and the join identity are the same element. ' + 'In a lattice L carrying AFAStructure, the Quine-atom predicate, the order minimum and the ' + 'join identity pick out one element of L (t_exec_triple_iff with da2_bottom_characterization). ' 'CC-1 (S₀ = ⊥): a state sequence starts at a Quine atom exactly when it starts ' 'at ⊥ (cc1_derived with t_exec_iff) - axiom-free in Lean 4; the starting point is ' 'restated through the role, not forced (on a lattice with a second point a valid sequence can start above ⊥). ' - 'CC-2 (⊥ = {⊥}): its structural content is a role, the Quine-atom role that AFAStructure encodes, and T-EXEC proves whatever fills that role is ⊥ (axiom-free); in AFA set theory Q = {Q} has exactly one solution, a theorem of that theory, and that the framework\'s ⊥ is that set is the commitment, not a Lean theorem. ' + 'CC-2 (the Quine atom): its structural content is a role, the Quine-atom role that AFAStructure encodes, and T-EXEC proves whatever fills that role is ⊥ (axiom-free); in AFA set theory Q = {Q} has exactly one solution, a theorem of that theory; adopting AFA for the set setting is the commitment, not a Lean theorem, and no equation between ⊥ and Q is written. ' 'Choice-free: the set of self-containing elements, {⊥}, is identified in one step ' 'with no axiom of choice; this does not address Aczel\'s question about Dependent Choice. ' 'Abstraction chain: ValuationStructure → AbstractSelfApp → AFAStructure - ' @@ -627,10 +604,13 @@ def footer_cb(canvas, doc): 'reduce what must be assumed. ' 'Concrete instances: ℕ∞ satisfies the full ValuationStructure chain; ' 'OntologicalStates connects at the AbstractSelfApp level directly. ' - 'decoration_unique: any two valid decorations of a finite APG into a DecorationUniverse agree. ' + 'decoration_unique_of_val: any two valid decorations of any graph, finite or not, into a ' + 'DecorationUniverse agree, with no finiteness hypothesis. ' + 'decoration_unique: the same for a finite APG, by a graph-side proof. ' 'All stated results sorry-free in Lean 4 ' - '(decoration_unique proved via strong induction on reach cardinality; ' - 'an auxiliary acyclic_decoration_unique in APG.lean is sorry\'d and commented out - ' + '(decoration_unique proved via strong induction on reach cardinality, ' + 'decoration_unique_of_val via strong induction on the depth of the decorating value; ' + 'an auxiliary acyclic_decoration_unique in ZeroParadox/Settheory/APG.lean is sorry\'d and commented out - ' 'it is not used by decoration_unique). ✓')) E.append(sp(6)) diff --git a/scripts/build_zpj_keystone_addendum.py b/scripts/build_zpj_keystone_addendum.py index 466271c8..09237d59 100644 --- a/scripts/build_zpj_keystone_addendum.py +++ b/scripts/build_zpj_keystone_addendum.py @@ -1,6 +1,6 @@ """ Zero Paradox — ZP-J Keystone Addendum: The Diagonal Fixed Point, the Lawvere Face-Split, and the Well-Foundedness Boundary -Version 1.26 | October 2026 +Version 1.31 | November 2026 Taylor (Well-founded coalgebras and recursion) is cited without year or venue: the copy on file carries neither. The gap stays open until a verified bibliographic record supplies them. Reads after ZP-J Self-Reference. @@ -10,7 +10,7 @@ from zp_utils import * from reportlab.platypus import KeepTogether -VERSION = '1.26' +VERSION = '1.31' FIRST_RELEASED = 'June 2026' # ── fix() guard: route all bare Paragraph() text through Unicode-to-entity conversion ── @@ -58,16 +58,20 @@ def build(): E.append(body( 'The keystone of the Zero Paradox is that ⊥ plays the same self-referential ' '(diagonal) fixed-point role in every framework, its occupant supplied per face: the Quine ' - 'atom ⊥ = {⊥} in set theory; filled in computation by a Kleene code (a ' - 'commitment, not a theorem); the point v2(0) = ∞ in ' + 'atom (CC-2) in set theory, the role a set x = {x} plays, whose occupancy is settled chart by chart ' + '(ZeroParadox/Settheory/QuineDichotomy.lean); filled in computation by a class of codes up to ' + 'equal eval, for a computable map respecting equal eval (codes_vs_classes); the point v2(0) = ∞ in ' 'valuation; and the initial object in category theory. Their shared membership in that ' 'family (MC-1) is proved per domain for the Quine atom, 2-adic and categorical faces; the ' 'Kleene face is carried as a requirement: its occupant is a code from the Rogers / Kleene ' 'fixed-point theorem (for every computable transform f of codes there is a code c with ' 'eval (f c) = eval c; Rogers\' form, computability_face_fixedPoint), a term of another type ' 'than ⊥ of the ZPSemilattice; the KleeneStructure class requires a code meeting a ' - 'periodicity condition (botCode_is_quine), and reading that code as the computational face of ' - '⊥ is the commitment (ZeroParadox/Computability/Kleene.lean); the ' + 'periodicity condition (botCode_is_quine), and the reading of that code as the computational face ' + 'of ⊥ splits (ZeroParadox/Computability/Kleene.lean): its identity half is retired, since ' + 'the code chart has its own occupant of the Quine-atom role, a class of codes up to equal eval ' + 'and no single code, for a computable map respecting equal eval (codes_vs_classes), and its running half, that ⊥ executes, is the ' + 'occurrence commitment; the ' 'choice of criteria is a design principle; and ' 'the claim that the faces are numerically one object is retired as ' 'ill-typed (object equality across categories does not typecheck and is not invariant under ' @@ -93,8 +97,8 @@ def build(): E.append(body( 'The unification of self-referential fixed points across fields is not new with the ' 'Zero Paradox. Lawvere (Diagonal Arguments and Cartesian Closed Categories, ' - '1969) showed that Cantor\'s diagonal, Russell\'s paradox, Gödel\'s incompleteness ' - 'lemma and Tarski\'s undefinability theorem are one move; Yanofsky (A Universal ' + '1969) showed that Cantor\'s diagonal, Russell\'s paradox, the fixed-point lemma at the heart of ' + 'Gödel\'s incompleteness and Tarski\'s undefinability theorem are one move; Yanofsky (A Universal ' 'Approach to Self-Referential Paradoxes, Incompleteness and Fixed Points, Bull. Symbolic ' 'Logic 9(3), 2003) restated this in plain set-and-function terms across logic and ' 'computation, adding Turing\'s halting argument and the recursion theorem. ' @@ -145,7 +149,7 @@ def build(): 'fixed point); Lawvere\'s are derived from a surjection. So the question is ' 'whether each face supplies that surjection. The verdict is face-dependent.')) E.append(KeepTogether(result_box( - 'In Set: no face is a Lawvere instance (Lawvere.lean)', + 'In Set: no face is a Lawvere instance (ZeroParadox/Category/Lawvere.lean)', [ 'For any nontrivial type, a Lawvere witness cannot exist: it would force every ' 'endofunction to have a fixed point, impossible once there are two distinct ' @@ -168,10 +172,12 @@ def build(): 'has a fixed point up to eval: two codes computing the same function. This wraps ' 'Mathlib\'s Nat.Partrec.Code.fixed_point (Rogers / Kleene\'s recursion theorem).', 'The qualifier is load-bearing. A literal fixed point is not on offer — c ↦ ' - 'pair(c, c) is total, computable, and returns its own input for no c. The escape from the ' + 'pair(c, c) (the map fun c => Code.pair c c, code_pair_diag_fixedPointFree) is total, computable, and returns its own input for no c. The escape from the ' 'Cantor obstruction is a restriction on which MAPS exist, not on which type eval lands in: ' 'no computable self-map on codes is eval-fixed-point-free, so the diagonal that would ' - 'refute the witness has no computable representative and the obstruction cannot fire. ' + 'refute the witness has no computable representative and the obstruction cannot fire (up to eval; ' + 'under literal equality that same map refutes the witness, the example after ' + 'no_witnessRel_of_admissible_fpf in ZeroParadox/Category/DiagonalWitness.lean). ' 'This is ZP-K\'s face (the Kleene quine).', 'Footprint: [propext, Classical.choice, Quot.sound], inherited from Mathlib.', 'Prior art, cited and not claimed: this is the effective-topos / Turing-category ' @@ -205,8 +211,8 @@ def build(): E.append(body( 'The keystone\'s structural home is well-founded coalgebra theory. A relation is ' 'encoded as a powerset coalgebra; well-founded means no infinite descending ' - 'chain — no cycle. The Quine atom ⊥ = {⊥} is exactly the minimal ' - 'non-well-founded coalgebra: the self-loop ⊥ ∈ ⊥, the back ' + 'chain — no cycle. The Quine atom (CC-2), a point x = {x}, is exactly the minimal ' + 'non-well-founded coalgebra: the self-loop x ∈ x, the back ' 'edge. Taylor (Well-founded coalgebras and recursion) proves well-founded ' '⇒ recursive as his Recursion Theorem (Thm 36, p. 15), and states the converse ' 'in a topos — there well-foundedness is necessary for recursion ' @@ -225,10 +231,10 @@ def build(): E.append(body( 'In that language the binary snap ⊥ → ε0 is a crossing of ' 'the well-foundedness boundary: from the non-well-founded floor (⊥, the ' - 'self-loop, where recursion cannot reach) to the well-founded ascent (the ε0 ' + 'self-loop, where recursion cannot reach: floor_not_wellFounded, below) to the well-founded ascent (the ε0 ' 'ordinal tower, recursively generated). The Zero Paradox formalizes this at two levels.')) E.append(KeepTogether(result_box( - 'Relation level (Boundary.lean)', + 'Relation level (ZeroParadox/Multihomed/Boundary.lean)', [ 'floor_not_wellFounded — the self-application floor is non-well-founded ' '(⊥ self-loops under selfApp). Fully axiom-free.', @@ -240,7 +246,7 @@ def build(): ))) E.append(sp(4)) E.append(KeepTogether(result_box( - 'Both levels at once (BoundaryBridge.lean)', + 'Both levels at once (ZeroParadox/Multihomed/BoundaryBridge.lean)', [ 'snap_boundary_two_registers — the crossing witnessed in two registers at ' 'once: the relation/carrier level above, and ZP-P\'s categorical μ/ν ' @@ -337,7 +343,7 @@ def build(): E.append(KeepTogether(Paragraph( 'Endnote: This document is an addendum to ZP-J Self-Reference and reads after it. ZP-J ' - 'established the porthole (v2(⊥) = ∞, ⊥ = {⊥}); this ' + 'established the valuation condition v2(⊥) = ∞ and ⊥ as the occupant of the Quine-atom role (CC-2); this ' 'addendum records two probes into the keystone\'s structure — the ' 'Lawvere face-split and the well-foundedness boundary — machine-checked except where ' 'marked cited, each fenced as to exactly ' diff --git a/scripts/build_zpj_wheel_addendum.py b/scripts/build_zpj_wheel_addendum.py index a2a1101e..ec5994a4 100644 --- a/scripts/build_zpj_wheel_addendum.py +++ b/scripts/build_zpj_wheel_addendum.py @@ -1,6 +1,6 @@ """ Zero Paradox — ZP-J Wheel Addendum: The Wheel of Fractions is a Wheel -Version 1.8 | September 2026 +Version 1.11 | November 2026 Reads after ZP-J Self-Reference. """ @@ -8,7 +8,7 @@ from zp_utils import * from reportlab.platypus import KeepTogether -VERSION = '1.8' +VERSION = '1.11' FIRST_RELEASED = 'June 2026' # ── fix() guard: route all bare Paragraph() text through Unicode-to-entity conversion ── @@ -62,22 +62,22 @@ def build(): 'The two elements this produces — ∞ = /0 (the reciprocal of zero) and ' '⊥ = 0·/0 (an absorbing "undefined" element) — are what distinguish ' 'a wheel from a field. ZP-J Self-Reference left open which way of totalising division ' - 'the Zero Paradox porthole gives rise to — Bergstra & Tucker\'s WADT 2020 paper ' + 'the Zero Paradox’s 0/∞ exchange gives rise to — Bergstra & Tucker\'s WADT 2020 paper ' 'places wheels and meadows in one signature alongside a third totalisation; this addendum ' - 'compares the two most directly relevant to the porthole: a wheel, which ' + 'compares the two most directly relevant to that exchange: a wheel, which ' 'adjoins ∞ and ⊥ as two distinct new elements, or a meadow (Bergstra ' '& Tucker), which adjoins nothing at all and instead declares 0−1 = 0, ' 'staying inside the original number system. This addendum settles that question.')) E.append(body( - 'The main result is WheelFrac.instWheel (WheelFrac.lean): for any commutative ' + 'The main result is ZeroParadox.instWheel (ZeroParadox/Algebra/WheelFrac.lean): for any commutative ' 'ring A and any multiplicative submonoid S, the wheel of fractions ' '⊙S A = (A × A)/≡S satisfies every axiom of ' - 'Carlström\'s Definition 1.1. The companion result WheelFrac.inf_ne_bot shows that, ' + 'Carlström\'s Definition 1.1. The companion result ZeroParadox.inf_ne_bot shows that, ' 'whenever 0 ∉ S, the two special elements stay distinct (∞ ≠ ' '⊥) — so the construction is a non-trivial wheel. The construction ' 'is Carlström\'s; the contribution here is a faithful, machine-verified encoding ' 'of it that is also free of the axiom of choice (footprint [propext, Quot.sound]), ' - 'situated as the algebraic form of the ZP porthole.')) + 'situated as the algebraic form of the 0/∞ exchange.')) E.append(hr()) # ── Section I: The Wheel typeclass ───────────────────────────────────────── @@ -95,7 +95,7 @@ def build(): 'eight. The unbundling is bookkeeping only — no axiom is added, removed, or ' 'weakened.')) E.append(def_box( - 'Typeclass: Wheel (Wheel.lean)', + 'Typeclass: Wheel (ZeroParadox/Algebra/Wheel.lean)', [ 'class Wheel (W : Type*) where', ' wadd, wmul : W → W → W -- + and ·', @@ -164,7 +164,7 @@ def build(): 'fails without a cancellation law. The submonoid-quotient relation ' '≡S repairs this by witnessing each identification with elements ' 'of S, and it is provably reflexive, symmetric, and transitive ' - '(WheelFrac.srel). Each of the five operations is then well-defined on the ' + '(ZeroParadox.srel). Each of the five operations is then well-defined on the ' 'quotient — the proofs that they respect ≡S are the bulk of ' 'the formalisation.')) E.append(sp(6)) @@ -179,12 +179,12 @@ def build(): E.append(body( 'With the operations shown well-defined, every one of the 14 typeclass fields ' 'is discharged. The additive and multiplicative monoid laws and the distributivity ' - 'and porthole axioms all reduce, after lifting representatives, to ring identities ' + 'and zero-term axioms (W9–W14) all reduce, after lifting representatives, to ring identities ' 'in A closed by ring normalisation; the two involution laws (W7, W8) hold ' 'definitionally because pair-swap is its own inverse and commutes with the ' 'componentwise product.')) E.append(result_box( - 'Theorem: WheelFrac.instWheel (WheelFrac.lean)', + 'Theorem: ZeroParadox.instWheel (ZeroParadox/Algebra/WheelFrac.lean)', [ '∀ {A : Type*} [CommRing A] (S : Submonoid A),', ' Wheel (⊙S A)', @@ -198,7 +198,7 @@ def build(): )) E.append(sp(6)) - # ── Section IV: The porthole — a non-trivial wheel, and not a meadow ─────── + # ── Section IV: The 0/∞ exchange — a non-trivial wheel, and not a meadow ─────── print('[build_zpj_wheel_addendum] Building Section IV...') E += [ hr(), @@ -215,7 +215,7 @@ def build(): '⊙S A is trivial (p. 5). The natural hypothesis 0 ∉ S holds ' 'whenever S is the complement of a prime ideal, the usual case.')) E.append(result_box( - 'Proposition: WheelFrac.inf_ne_bot (WheelFrac.lean)', + 'Proposition: ZeroParadox.inf_ne_bot (ZeroParadox/Algebra/WheelFrac.lean)', [ '∀ {A : Type*} [CommRing A] (S : Submonoid A),', ' (0 : A) ∉ S → ∞ ≠ ⊥ in ⊙S A', @@ -273,14 +273,17 @@ def build(): )) E.append(sp(4)) E.append(remark_box( - 'Remark — The Porthole Connection', + 'Remark — The Connection to ZP-J', [ - 'In ZP-J, the porthole is the point where val(⊥) = ∞ and ' - '⊥ = {⊥} coincide — the same structural fact written in the ' - '2-adic valuation (v₂(0) = ∞) and in ZF+AFA (the Quine atom). The ' + 'In ZP-J, the Quine-atom role is read in several charts, not as one equation across them: ' + 'a point that steps to itself and to nothing else (Motion.SelfOnlyAt). In the 2-adic ' + 'integers its occupant under x ↦ 2x is 0, where v₂(0) = ∞ (z2_two_views, ' + 'ZeroParadox/Valuation/Scale.lean); a valuation structure sets val(⊥) = ∞ ' + '(val_bot); in ZFC− + AFA the role is the Quine atom (CC-2), a set x = {x}, whose lattice-level ' + 'occupant is ⊥ (ZeroParadox/Settheory/QuineDichotomy.lean). The ' 'wheel of fractions is the algebraic face of that point: /0 is defined and ' - 'distinct from the absorbing ⊥, exactly the behaviour the porthole ' - 'predicts. The concrete carrier ZPWheelElem (Wheel.lean §III–VI) ' + 'distinct from the absorbing ⊥, and /∞ = 0 (winv_wheelInf) closes the ' + '0/∞ exchange. The concrete carrier ZPWheelElem (ZeroParadox/Algebra/Wheel.lean §III–VI) ' 'makes this explicit on the rationals extended with ∞ and ⊥, where ' 'val(x) = ∞ ⇔ /x = ∞ is proved directly ' '(zpw_top_val_iff_inv_is_inf). This addendum\'s headline result is the general ' @@ -301,23 +304,23 @@ def build(): 'Two scope boundaries are worth stating plainly. This is a formalisation, not ' 'new mathematics. The wheel of fractions and the theorem that it is a wheel are ' 'Carlström\'s. What is contributed here is a machine-checked encoding faithful to ' - 'Definition 1.1, with a verified axiom footprint, placed in the ZP porthole ' - 'context. Ring structure is an input, not a conclusion. The construction ' + 'Definition 1.1, with a verified axiom footprint, placed in the context of ZP-J’s ' + '0/∞ exchange. Ring structure is an input, not a conclusion. The construction ' 'starts from a commutative ring and a submonoid; it does not derive wheel structure ' 'from the ZP lattice axioms alone. The bridge typeclass that would state such a ' - 'derivation, WheelValuationStructure (Wheel.lean §VII), is defined but its ' - 'porthole condition val(0) = ⊤ is an assumed axiom, motivated by the ZP ' + 'derivation, WheelValuationStructure (ZeroParadox/Algebra/Wheel.lean §VII), is defined but its ' + 'condition val(0) = ⊤ is an assumed axiom, motivated by the ZP ' 'argument rather than type-checked as necessary.')) E.append(label_box( 'Lean Source Files', [ - 'WheelFrac.lean — rel, srel, the five quotient operations ' + 'ZeroParadox/Algebra/WheelFrac.lean — rel, srel, the five quotient operations ' '(waddF, wmulF, winvF), instWheel, inf_ne_bot. The headline results of this ' 'addendum.', - 'Wheel.lean — the Wheel typeclass (Carlström Def 1.1, 14 fields), ' + 'ZeroParadox/Algebra/Wheel.lean — the Wheel typeclass (Carlström Def 1.1, 14 fields), ' 'the derived elements wheelInf / wheelBot, the concrete carrier ZPWheelElem, ' - 'and the porthole correspondence zpw_top_val_iff_inv_is_inf.', - 'Both files in ZeroParadox/ in the public repository.', + 'and the correspondence val(x) = ⊤ ⇔ /x = ∞, zpw_top_val_iff_inv_is_inf.', + 'Both files are in the public repository.', ] )) E.append(sp(4)) @@ -346,7 +349,8 @@ def build(): 'called \'wheels\' (the term inspired by the topological picture ⊙ of the ' 'projective line together with an extra point 0/0) by Setzer [Set97], who showed ' 'how to modify the construction of fields of fractions from integral domains so ' - 'that wheels are obtained instead of fields."', + 'that wheels are obtained instead of fields." ([Set97] is Carlström\'s key for ' + 'A. Setzer, Wheels (draft), 1997.)', 'Carlström is the generalizer: "in this paper, we generalize Setzer\'s ' 'construction, so that it applies not only to integral domains, but to any ' 'commutative semiring." That is Wheels — On Division by Zero (Research ' @@ -363,10 +367,10 @@ def build(): 'that reproduces his Definition 1.1 field for field, and discharged without ' 'the axiom of choice. The encoding is what is new: a third party can read the ' '14 fields against Carlström\'s eight axioms and confirm the correspondence, ' - 'and can read the axiom footprint to confirm the choice-free claim. Whether ' - 'the porthole condition val(0) = ⊤ can be derived — rather than ' - 'assumed — from upstream ZP structure remains the open question flagged ' - 'in Wheel.lean §VII–VIII.', + 'and can read the axiom footprint to confirm the choice-free claim. The condition ' + 'val(0) = ⊤ stays an assumed class field, motivated and not forced ' + '(ZeroParadox/Algebra/Wheel.lean §VII–VIII); given multiplicativity it holds ' + 'exactly when the valuation is not the zero map (the examples closing §VII-b there).', ] )) E.append(sp(6)) @@ -377,8 +381,8 @@ def build(): # shrinks; a hard PageBreak would instead force a sixth page even once the text fits on five. E.append(KeepTogether(Paragraph( 'Endnote: This document is an addendum to ZP-J Self-Reference and reads after it. ' - 'ZP-J established the porthole (val(⊥) = ∞, ⊥ = {⊥}); this ' - 'document gives its algebraic form, the wheel of fractions, and the machine-verified ' + 'ZP-J established the valuation condition val(⊥) = ∞ and ⊥ as the lattice-level occupant of the Quine-atom role (CC-2); this ' + 'document gives the algebraic form of the 0/∞ exchange, the wheel of fractions, and the machine-verified ' 'proof that the construction is a wheel and a non-trivial one. All results sorry-free ' 'in Lean 4 as of September 2026. Footprints are per result, and [propext, Quot.sound] is ' 'the headline results\'; the Axiom Footprint box above gives the scope and the ' diff --git a/scripts/build_zpj_wheel_companion.py b/scripts/build_zpj_wheel_companion.py index 9d5e3dbc..32e5a714 100644 --- a/scripts/build_zpj_wheel_companion.py +++ b/scripts/build_zpj_wheel_companion.py @@ -1,13 +1,13 @@ """ Build ZP-J Wheel Illustrated Companion -Version 1.6 | September 2026 +Version 1.15 | November 2026 """ import os from zp_utils import * from reportlab.graphics.shapes import Drawing, Line, String, Circle, Ellipse -VERSION = '1.6' +VERSION = '1.15' FIRST_RELEASED = 'June 2026' @@ -107,9 +107,9 @@ def footer_cb(canvas, doc): 'algebraic structure (Carlström, 2001) in which dividing by zero is a ' 'defined operation rather than an error. Every formal claim here restates a ' 'theorem already proved in the technical document and its Lean source ' - '(Wheel.lean, WheelFrac.lean). Analogies are included to build ' - 'intuition, not as proof claims. Consult the addendum for the authoritative ' - 'mathematics.', CS['disc'])] + '(ZeroParadox/Algebra/Wheel.lean, ZeroParadox/Algebra/WheelFrac.lean). Analogies are ' + 'included to build intuition, not as proof claims. Consult the addendum for the ' + 'authoritative mathematics.', CS['disc'])] # ── The Problem With Dividing by Zero ──────────────────────────────────── E.append(Paragraph('The Problem With Dividing by Zero', CS['h1'])) @@ -143,8 +143,12 @@ def footer_cb(canvas, doc): 'absorbing "undefined" element: combine it with anything and you get ⊥ back. ' 'It is the wheel\'s honest answer to a genuinely meaningless expression - instead of ' 'crashing, the arithmetic returns a dedicated value that means "no information." ' - '(The wheel writes this element ⊥, the same symbol the Zero Paradox uses for ' - 'its bottom element - see the last section for why that is not a coincidence.)')) + '(The wheel writes this element ⊥. Carlström (printed p. 3) traces the pair to Edalat ' + 'and Potts, who suggested adjoining 1/0 and 0/0 to the reals, obtaining what domain theory calls the ' + '"lifting" of the real projective line: 1/0 is the projective line\'s point at infinity, and ' + '0/0 is the bottom the lifting adds. The Zero ' + 'Paradox uses the same symbol for the bottoms of its own carriers; the last section says ' + 'what the wheel\'s element shares with them and what it does not.)')) E.append(sp(4)) E.append(example_box('Real-world analogy - The calculator that never crashes', [ 'A pocket calculator shows "Error" when you divide by zero, and then you have to ' @@ -217,7 +221,7 @@ def footer_cb(canvas, doc): 'Carlström\'s Definition 1.1 (checked in Lean as 14 separate equational ' 'fields). It is a wheel, with no exceptions and no extra hypotheses.')) E.append(key_result_box( - 'WheelFrac.instWheel (machine-verified, Lean 4)', + 'ZeroParadox.instWheel (machine-verified, Lean 4)', 'For every commutative ring A and every multiplicative submonoid S, the wheel of ' 'fractions ⊙S A is a wheel - it satisfies all of Carlström\'s ' 'axioms. The proof is sorry-free and free of the axiom of choice: its only ' @@ -241,33 +245,34 @@ def footer_cb(canvas, doc): 'single element is Carlström\'s own observation (printed p. 5), not a result of ' 'this corpus.')) E.append(key_result_box( - 'WheelFrac.inf_ne_bot (machine-verified, Lean 4)', + 'ZeroParadox.inf_ne_bot (machine-verified, Lean 4)', 'If 0 ∉ S, then ∞ ≠ ⊥ in ⊙S A. The ' 'construction is therefore a non-trivial wheel. (If ∞ and ⊥ were equal, ' 'the witnessing elements of S would force 0 itself into S, contradicting the ' 'hypothesis.) Also sorry-free and choice-free: [propext, Quot.sound].')) E.append(sp(4)) - # ── The Porthole Connection ────────────────────────────────────────────── + # ── Why This Belongs ────────────────────────────────────────────── E.append(Paragraph('Why This Belongs in the Zero Paradox', CS['h1'])) E.append(cbody( - 'The Zero Paradox studies one structural fact about the bottom element ⊥, ' - 'written in several mathematical languages at once: in the 2-adic valuation it is ' - 'v₂(0) = ∞, and in non-well-founded set theory it is the Quine atom ' - '⊥ = {⊥}. The wheel of fractions is the algebraic face of the ' - 'same point. Where ZP-J says "the bottom is where measure runs to infinity," the ' - 'wheel says "the bottom is where division by zero lives" - and it shows that this ' - 'point is a defined, well-behaved element (∞ = /0), distinct - in the standard ' - 'case where 0 ∉ S - from the absorbing ⊥. Same location, different ' - 'vocabulary. The Zero Paradox\'s shorthand for that meeting point is the ' - 'porthole.')) + 'The Zero Paradox studies one role, written in several mathematical languages at once, ' + 'each with its own occupant and no equation across them: in the 2-adic valuation the ' + 'occupant is 0, where v₂(0) = ∞; in non-well-founded set theory it is the Quine ' + 'atom (CC-2), a set x = {x} (Aczel 1988, Example 1.3); in a lattice under a self-application map it is ⊥ of the lattice. The wheel of ' + 'fractions is the algebraic face of that role. Where ZP-J says "the bottom is where measure runs to infinity," the ' + 'wheel adjoins two elements at division by zero: ∞ = /0, which inversion exchanges ' + 'with 0 (/∞ = 0), and the absorbing ⊥ = 0·/0, distinct from ∞ in the ' + 'standard case where 0 ∉ S. Of the two, ⊥ = 0·/0 is the one that steps only ' + 'to itself under inversion; ∞ steps to 0 (see the last section). That exchange of 0 and ' + '∞ under inversion is winv_wheelInf (/∞ = 0), with ∞ = /0 by definition.')) E.append(cbody( 'One honest limitation. The wheel is built on top of a ring you supply - the ' 'ring structure is an input, not something derived from the Zero Paradox\'s own ' - 'axioms. Whether the defining property of the porthole can be derived from ' - 'upstream ZP structure, rather than assumed, is an open question flagged in the ' - 'Lean source (the bridge typeclass WheelValuationStructure states it, but its key ' - 'condition is an assumed axiom). The wheel shows the algebraic face exists and is ' + 'axioms. The valuation condition val(0) = ⊤ (the wvs_val_zero field of ' + 'WheelValuationStructure) is assumed, motivated and not forced, as the Lean source ' + 'says (ZeroParadox/Algebra/Wheel.lean §VIII). Given that the valuation turns ' + 'products into sums, the condition holds exactly when the valuation is not zero ' + 'everywhere (the examples closing §VII-b there). The wheel shows the algebraic face exists and is ' 'consistent; it does not claim to force it into being.')) E.append(sp(4)) @@ -278,9 +283,17 @@ def footer_cb(canvas, doc): 'not new mathematics. What the Zero Paradox adds is a faithful, machine-checked ' 'encoding - readable field by field against Carlström\'s Definition 1.1, with ' 'a verified axiom footprint showing it needs no axiom of choice - placed in the ' - 'context of the bottom element ⊥. The takeaway: division by zero is not an ' - 'error to be avoided but a defined element to be understood, and at exactly the ' - 'point the rest of the framework already identifies as the bottom.')) + 'context of the Zero Paradox. The takeaway: division by zero is not an error to be ' + 'avoided but a defined element to be understood, ∞ = /0, which inversion exchanges ' + 'with 0 (winv_wheelInf). The ' + 'absorbing element ⊥ = 0·/0 steps only to itself under inversion ' + '(wheelBot_selfOnlyAt_winv) and absorbs every point under addition (wheelBot_absorbs), ' + 'so it is one occupant of the Quine-atom role in the wheel. Under addition it is the only ' + 'one, since every point steps to it (wheelBot_addSelfOnly_unique); under inversion it is not the only one: 1 ' + 'also steps only to itself under inversion (winv_one, the inverse of 1 is 1), and in any ' + 'wheel with more than one element 1 and 0·/0 differ (Carlström, Proposition ' + '4.4). Occupants in the framework\'s other carriers fill the same role and are not one ' + 'object with it, since an equation across carriers is ill-typed.')) E.append(sp(6)) print(f'[build_zpj_wheel_companion] Assembling document ({len(E)} elements)...') diff --git a/scripts/build_zpk.py b/scripts/build_zpk.py index ab18c07e..463b1934 100644 --- a/scripts/build_zpk.py +++ b/scripts/build_zpk.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-K: Computational Grounding of Self-Reference PDF Builder -Version 1.27 | October 2026 +Version 1.38 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.27' +VERSION = '1.38' FIRST_RELEASED = 'April 2026' @@ -34,13 +34,21 @@ def build(): 'self-reference structure. On the framework\'s reading, ⊥ in the computational ' 'instantiation is not a state of a Turing machine: it is the ground state of a universal ' 'Turing machine — the state from which no external executor is required. Kleene\'s ' - 'second recursion theorem supplies a fixed point of the self-application operator; that ' - 'this fixed point is to be read as the computational expression of ⊥ = {⊥} is the ' - 'framework\'s commitment, carried by the KleeneStructure class, not a property the ' - 'theorem establishes.')) + 'second recursion theorem supplies a fixed point of the self-application operator. The ' + 'reading of that fixed point as ⊥\'s computational counterpart splits in two, and no field ' + 'of the KleeneStructure class asserts either half. Its identity half is retired: a code and ' + '⊥ of a lattice are compared through the Quine-atom role (Motion.SelfOnlyAt, a point that ' + 'steps to itself and to nothing else), which under the eval step no single code occupies ' + '(evalStepMotion_not_selfOnlyAt) and, for a computable map respecting equal output, a class ' + 'of codes up to equal output does (codes_vs_classes). Its running half, that ⊥ actually ' + 'executes, is the occurrence commitment.')) E.append(body( 'The central result is a three-way equivalence within this framework, in the precise sense ' - 'defined by Remark R-K.0: the structural roles of ⊥ — Quine atom (set-theoretic), bottom ' + 'defined by Remark R-K.0: the structural roles of ⊥ of a lattice carrying AFAStructure — ' + 'the Quine-atom role (CC-2, read in the lattice\'s AFA structure, where ⊥ fills it by the ' + 'class fields bot_self_mem and quine_unique; the set-theoretic fact is Aczel 1988, p. 19, ' + 'where AFA allows at most one solution of x = {x}; see ZP-J; in Mathlib\'s ZFSet no set ' + 'occupies it, zfset_quine_role_unoccupied), bottom ' 'element (order-theoretic), and join identity (algebraic) — are PROVED to coincide, while ' 'the fourth role, Kleene fixed point (computational), is required as a typeclass field ' 'rather than derived. ' @@ -158,7 +166,8 @@ def build(): 'infinitely many self-printing codes exist, and no behaviour belongs to two of them. ' 'Contrast padding, where infinitely many codes share one behaviour.', 'Lean: ZeroParadox.selfprints_behaviour_injective. Purity: propext, Classical.choice, ' - 'Quot.sound (measured 2026-10-04); the predicate SelfPrints itself carries the same three.', + 'Quot.sound (#print axioms in the PurityCheck section of ' + 'ZeroParadox/Computability/Kleene.lean); the predicate SelfPrints itself carries the same three.', ] )) E.append(sp(6)) @@ -178,9 +187,15 @@ def build(): E.append(body( 'ZP-K\'s KleeneStructure extends AFAStructure with a computational witness: a code ' 'botCode satisfying the selfApply periodicity condition, whose existence is guaranteed ' - 'by Kleene\'s theorem. The typeclass commitment takes AFA self-containment (⊥ = {⊥}) ' - 'and the Kleene fixed point to be the same structural role stated in two formal ' - 'languages — this is the motivating claim, not a consequence derived by the theorems.')) + 'by Kleene\'s theorem. The class was built for the reading that AFA self-containment (the ' + 'Quine atom, CC-2) and the Kleene fixed point are one structural role in two formal ' + 'languages. That role is stated once, as the Quine-atom role Motion.SelfOnlyAt (a point that ' + 'steps to itself and to nothing else), and each chart carries its own occupancy theorem: ' + 'with membership as the step, ⊥ is the only occupant in an AFAStructure lattice ' + '(quineAtomHost_quine_role_iff, host afaStructure_isQuineAtomHost); on codes under the eval ' + 'step no single code occupies it (evalStepMotion_not_selfOnlyAt), and for a computable map ' + 'respecting equal output a class of codes up to equal output does (codes_vs_classes). No ' + 'equation across a code and ⊥ is stated, and no field of the class asserts one.')) E.append(def_box( 'KleeneStructure Typeclass (Kleene.lean § II)', @@ -198,18 +213,20 @@ def build(): 'Any KleeneStructure instance must supply both the AFA witness (bot_self_mem) ' 'and the computational witness (botCode with botCode_is_quine). Both are class ' 'FIELDS — assumptions discharged at instantiation, not results proved here. They are ' - 'required together because the framework READS them as one structural fact; that ' - 'reading is the motivation for the class, and it is not derived within it.', + 'required together because the class was built for the reading that they are one ' + 'structural fact; that reading is not derived within it, and its identity half is ' + 'retired in favour of per-chart occupancy of the Quine-atom role (I above).', ] )) E.append(sp(6)) E.append(Paragraph('II. Why Not a Bridge Axiom?', S['h2'])) E.append(body( - 'The identification between AFA self-containment and Kleene computational fixed points ' - 'is not asserted as a new axiom. KleeneStructure is a typeclass: any concrete type ' - 'claiming this identification must discharge it as a proof obligation. The commitment ' - 'is checked at instantiation, not accepted globally.')) + 'No identification between AFA self-containment and Kleene computational fixed points ' + 'is asserted, as a new axiom or as a class field. KleeneStructure is a typeclass: any ' + 'concrete type must discharge its fields (among them a predicate selfMem with ⊥ its unique witness, and a ' + 'code botCode meeting the periodicity condition) as proof obligations. They are checked at instantiation, not ' + 'accepted globally.')) E.append(callout( 'The distinction from ZP-J carries over: a freestanding axiom says "trust me." ' 'A typeclass field says "prove it for your specific type, or it does not compile." ' @@ -227,9 +244,12 @@ def build(): ] E.append(body( - 'ZP-J T-EXEC established a three-way equivalence: Quine atom (set-theoretic) ↔ ' - 'bottom element (order-theoretic) ↔ join identity (algebraic). T-COMP proves exactly ' - 'those three equivalent. ZP-K bundles a fourth face — Kleene fixed point ' + 'ZP-J T-EXEC established a three-way equivalence in a lattice carrying AFAStructure: Quine ' + 'atom (in the lattice\'s AFA structure; in Mathlib\'s ZFSet the role is unoccupied, ' + 'zfset_quine_role_unoccupied) ↔ ' + 'bottom element (order-theoretic) ↔ join identity (algebraic). T-COMP, whose statement is ' + '(1) ↔ ((2) ∧ (3)), proves those three equivalent together with da2_bottom_characterization, ' + 'which gives (2) ↔ (3). ZP-K bundles a fourth face — Kleene fixed point ' '(computational) — as a KleeneStructure class field, so all four are present ' 'simultaneously in any KleeneStructure lattice, but the fourth is required at ' 'instantiation rather than proved equivalent to the others.')) @@ -237,7 +257,8 @@ def build(): 'Remark R-K.0 — What T-COMP Proves, and What "Four-Way" Meant', [ 'The equivalence among (1)–(4) has two distinct sources:', - '(1)–(3) are equivalent by T-EXEC (ZP-J): any element that is a Quine atom is also ' + '(1)–(3) are equivalent by T-EXEC (ZP-J), with da2_bottom_characterization for ' + '(2) ↔ (3): any element that is a Quine atom is also ' '⊥ and a join identity, and vice versa. This is a genuine logical derivation — the ' 'three properties are proved to coincide from the AFAStructure axioms.', '(4) is present in any KleeneStructure instance because KleeneStructure requires it ' @@ -257,7 +278,9 @@ def build(): 'instance." (1)–(3) are independently proved equivalent. (4) is bundled in by the ' 'typeclass requirement. The philosophical claim — that Kleene computational ' 'self-reference and AFA set-theoretic self-reference are the same thing — is the ' - 'motivation for the typeclass design, not a consequence derived within it.', + 'motivation for the typeclass design, not a consequence derived within it. Its identity ' + 'half is retired: what the two share is the Quine-atom role, whose occupancy is settled chart by chart ' + '(Section II.I), and that ⊥ actually executes is the occurrence commitment.', ] )) E.append(sp(6)) @@ -266,14 +289,15 @@ def build(): 'Theorem T-COMP — Computational Grounding (Kleene.lean § III)', [ 'In any KleeneStructure lattice L, for any q : L, the following are equivalent:', - '(1) IsQuineAtom q — set-theoretic self-reference (AFA)', + '(1) IsQuineAtom q — the Quine-atom role in the lattice\'s AFA structure (CC-2)', '(2) q = ⊥ — order-theoretic minimum (ZP-A)', '(3) ∀ x : L, join q x = x — algebraic generator (ZP-A A4)', '', 'Separately, the KleeneStructure requirement: ∃ botCode : Code, IsComputationalQuine ' 'botCode (computational self-reference). It is not a clause of t_comp; it is present in ' 'any KleeneStructure instance because botCode_is_quine is a required field. The ' - 'equivalence of (1)–(3) is derived by T-EXEC.', + 'equivalence of (1)–(3) is derived by T-EXEC, with da2_bottom_characterization for ' + '(2) ↔ (3).', 'Lean: ZeroParadox.t_comp. ' 'Purity: standard foundational axioms — from Mathlib computability. ✓', ] @@ -292,7 +316,7 @@ def build(): 'witness of execution and not a second independent proof.')) E.append(body( 'Path 1 says: nothing external to ⊥ can execute ⊥, so if ⊥ executes at all, the executor ' - 'is ⊥ itself, read as ⊥ = {⊥}; that rules out an external executor, not an inert ⊥. ' + 'is ⊥ itself, ⊥ read as the Quine atom (CC-2); that rules out an external executor, not an inert ⊥. ' 'Path 3 says: no shorter external program generates ⊥; that rules out a shorter external ' 'generator, not an inert string, so Path 3 does not derive executing from incompressibility. ' 'The framework READS these as one claim in two vocabularies. What is ' @@ -341,8 +365,9 @@ def build(): 'Lean proves only the Quine-atom statement above; that ⊥ executes is the occurrence ' 'commitment, not this theorem. Lean witnesses ⊥ as the AFA Quine ' 'atom of MachinePhase (da1_closed_concrete) and carries the Kleene quine as a ' - 'KleeneStructure requirement (botCode_is_quine); that these are one structural fact is ' - 'the framework\'s reading.', + 'KleeneStructure requirement (botCode_is_quine); no Lean statement makes them one ' + 'object, and what they share is the Quine-atom role, whose occupancy is settled chart by chart ' + '(Section II.I).', 'Lean: ZeroParadox.description_instantiation_gap_closed. ' 'Purity: standard foundational axioms only. ✓', ] @@ -399,7 +424,9 @@ def build(): 'statement carries it; where only the proof does, whether another proof avoids it is ' 'a separate question, and the table does not answer it. The following were measured on ' '2026-09-19 against the pinned Mathlib; re-run them rather than citing this table ' - 'if the answer matters.')) + 'if the answer matters. On this toolchain `#print axioms` can under-report for declarations ' + 'imported from another module (lean4 issue #15226); for the "none" rows, the issue’s own ' + 'signature was checked and did not fire.')) E.append(data_table( headers=['Declaration', 'Axiom footprint'], @@ -433,25 +460,30 @@ def build(): E.append(body( 'The Kleene.lean § VIII and Disjunctive.lean declarations cited in Section I.III and ' 'Section VI are not in that table. Their #print axioms lines are in those two files\' ' - 'PurityCheck sections, and where Classical.choice enters selfref_universal_exists is recorded in ' - 'ZeroParadox/Computability/Kleene.md § VIII, measured 2026-10-04.')) + 'PurityCheck sections; those of kleene_cf and selfref_universal_exists_enc are in the ' + 'PurityCheck sections of ZeroParadox/Computability/KleeneChoiceFree.lean and ' + 'ZeroParadox/Computability/UniversalChoiceFree.lean. Where Classical.choice enters selfref_universal_exists is recorded in ' + 'ZeroParadox/Computability/Kleene.md § VIII.')) E.append(body( 'ZP-J T-EXEC and all its corollaries remain axiom-free. Classical.choice is not ' 'confined to the computability rows: in Disjunctive.lean, champ_disjunctive carries it, ' 'reached through disjunctive_iff_once, while the at-least-once form ' - 'champ_disjunctiveOnce measures propext and Quot.sound only (measured 2026-10-04; ' - 'ZeroParadox/Information/Disjunctive.md, Footprints).')) + 'champ_disjunctiveOnce measures propext and Quot.sound only (#print axioms in the ' + 'PurityCheck section of ZeroParadox/Information/Disjunctive.lean).')) E.append(remark_box( 'Remark: Classical Choice in Computability', [ 'Kleene\'s theorem as Mathlib states it, ∀ f, Partrec₂ f → ∃ c, eval c = f c, carries ' 'Classical.choice in its statement: that statement, measured as a proposition, reports ' - 'propext, Classical.choice and Quot.sound (2026-10-04), and so does the statement of ' + 'propext, Classical.choice and Quot.sound, and so does the statement of ' 'Rogers\' theorem, ∀ f, Computable f → ∃ c, eval (f c) = eval c. So every proof of ' 'either, as stated, carries the triple. Where it enters each statement is recorded in ' - 'ZeroParadox/Computability/Kleene.md § VIII. Whether a restated, choice-free statement ' - 'has a choice-free proof is UNCLASSIFIED (Section VI.IV).', + 'ZeroParadox/Computability/Kleene.md § VIII. A restatement of Kleene\'s form whose ' + 'statement and proof are both choice-free, for a transformation given as a code rather ' + 'than as a Partrec₂ function, is kleene_cf (ZeroParadox/Computability/KleeneChoiceFree.lean, ' + 'propext and Quot.sound only; the Open Items Register below); Rogers\' form has no such ' + 'restatement in this corpus.', 'The MachinePhase instance (§ V) picks botCode with Classical.choose from ' 'computational_quine_exists, which is what makes machinePhaseKleene noncomputable. A ' 'computable instance with the constant code Code.const 0 also exists (the example after ' @@ -488,8 +520,10 @@ def build(): ' quine_unique _ _ hx hy := hx.trans hy.symm (if x = ⊥ and y = ⊥ then x = y)', ' bot_self_mem := rfl (⊥ = ⊥, proved by reflexivity)', '', - 'This is the CIC encoding of ⊥ = {⊥}: the initial machine state is self-containing ' - 'and is the unique element with this property. No ZF+AFA axiom is added — ' + 'This is the CIC-compatible stand-in for the Quine atom (CC-2): the initial machine ' + 'state is self-containing and is the unique element with this property, so with ' + 'membership as the step it is the only occupant of the Quine-atom role ' + '(quineAtomHost_quine_role_iff, host afaStructure_isQuineAtomHost). No ZF+AFA axiom is added — ' 'the structural fact is encoded as a definition that Lean verifies.', ] )) @@ -506,9 +540,9 @@ def build(): 'botCode is a class field supplied at instantiation; this instance supplies it as ' 'Classical.choose applied to computational_quine_exists — some witness of that ' 'existence statement, not a distinguished code. Reading it as ' - '"the program that IS its own program" is the framework\'s commitment carried by the ' - 'class, not a property this instance establishes: IsComputationalQuine is a ' - 'periodicity condition, strictly weaker than self-reference.', + '"the program that IS its own program" is not a property this instance establishes, ' + 'and no field of the class asserts it (its identity half is retired, Section II.I): ' + 'IsComputationalQuine is a periodicity condition, strictly weaker than self-reference.', ] )) E.append(sp(6)) @@ -543,24 +577,28 @@ def build(): E.append(body( 'ZP-E\'s DA-1 section previously carried the designation "Outside Lean Scope" with ' 'three justifications: Path 1 requires ZF+AFA, which ZP-E held incompatible with Lean\'s CIC/MLTT; ' - 'Path 3 requires Kolmogorov complexity (uncomputable, absent from Mathlib); Path 2 ' + 'Path 3 requires Kolmogorov complexity (it is uncomputable, and that alone does not keep it ' + 'out of Lean, where a noncomputable definition is allowed; no formalization of it was located in ' + 'the pinned Mathlib as of 2026-10-04, searched as recorded in ' + 'ZeroParadox/Information/Disjunctive.md, and Lean developments outside Mathlib that define it ' + 'are named at the ZPSurprisal entry of LEAN_CUSTOM_REGISTRY.md); Path 2 ' 'requires a step from unbounded surprisal to executing, which ZP-E names a bridge ' 'principle of its own, a missing principle and not a missing proof.')) E.append(body( 'For Path 1 (AFA structural), in Lean the two charts split: Mathlib\'s ZFSet, a model of ' - 'ZFC, contains no set that is a member of itself (no_quine_atom), while outside ZFSet ' + 'ZFC, contains no set that is a member of itself (no_quine_atom; Mathlib\'s ZFSet.mem_irrefl), while outside ZFSet ' 'Lean hosts a one-atom model whose distinguished element is its own unique self-member ' '(the QuineHost instance on OneAtom, ZeroParadox/Settheory/QuineHost.lean § V). ' 'The Lean counterpart of Path 1 is da1_closed_concrete, which proves ' 'IsQuineAtom (⊥ : MachinePhase) and nothing computational: in the AFAStructure ' - 'typeclass, selfMem encodes ⊥ = {⊥} in CIC-compatible form, and the proof obligation ' + 'typeclass, selfMem stands in for the Quine atom (CC-2) in CIC-compatible form, and the proof obligation ' 'is discharged by the MachinePhase instance. Path 3 (computational) is NOT resolved ' 'here. Its Lean counterpart, botCode_is_quine, is a KleeneStructure class field — an assumption ' 'supplied at instantiation, not a second independent proof — and the condition it ' 'requires, IsComputationalQuine, is a periodicity condition that a constant code ' 'satisfies trivially. The Kolmogorov reading ("no shorter program is prior to ⊥") has ' - 'no formal content in ZP-K: Kolmogorov complexity is uncomputable and absent from the ' - 'development. Path 3 therefore derives nothing here: in ZP-E it bears on DA-1\'s ' + 'no formal content in ZP-K: Kolmogorov complexity is not formalized in this corpus (a scope ' + 'decision, recorded at the ZPSurprisal entry of LEAN_CUSTOM_REGISTRY.md). Path 3 therefore derives nothing here: in ZP-E it bears on DA-1\'s ' 'precondition and does not derive executing from incompressibility, and that ' 'precondition is what the occurrence commitment asserts.')) E.append(body( @@ -656,9 +694,12 @@ def build(): 'universal code on a channel e + 1.', 'Reading: replicas share everything but the address. Incompressibility is a property of ' 'each instance, and the next instance adds only its address. That is a claim about ' - 'relative complexity, and it stays a reading while Kolmogorov complexity is not in Lean.', + 'relative complexity, and it stays a reading while Kolmogorov complexity is not formalized ' + 'in this corpus (a scope decision, recorded at the ZPSurprisal entry of ' + 'LEAN_CUSTOM_REGISTRY.md, which also names Lean developments outside Mathlib that define it).', 'Lean: ZeroParadox.selfPrints_universal_address. ' - 'Purity: propext, Classical.choice, Quot.sound (measured 2026-10-04).', + 'Purity: propext, Classical.choice, Quot.sound (#print axioms in the PurityCheck section ' + 'of ZeroParadox/Computability/Kleene.lean).', ] )) E.append(sp(6)) @@ -697,11 +738,10 @@ def build(): 'measured: selfref_universal_exists carries Classical.choice, and so does its statement, ' 'through Mathlib\'s numbering of codes (Denumerable Code, reached through ofNatCode); ' 'restated with encodeCode for the Gödel number and the channel of code d written ' - 'Nat.pair (encodeCode d + 1) n, the statement is axiom-free, and no proof of the restated form ' - 'without choice was found. ZeroParadox/Computability/Kleene.md § VIII records the ' - 'measurement (2026-10-04) and what the route lacked as located then. Every proof of the ' - 'statement as written carries choice; whether the restated statement has a choice-free ' - 'proof is UNCLASSIFIED.')) + 'Nat.pair (encodeCode d + 1) n, the statement is axiom-free, and it has a proof at ' + 'propext and Quot.sound only, selfref_universal_exists_enc ' + '(ZeroParadox/Computability/UniversalChoiceFree.lean). ZeroParadox/Computability/Kleene.md ' + '§ VIII records the measurements. Every proof of the statement as written carries choice.')) E.append(Paragraph('V. The Zero Tape: Reference and Self', S['h2'])) E.append(body( @@ -764,7 +804,7 @@ def build(): ['machinePhaseAFA (AFAStructure)', 'selfMem := x = ⊥; quine_unique; bot_self_mem := rfl', 'No axioms', - 'CIC encoding of ⊥ = {⊥} for MachinePhase ✓'], + 'CIC stand-in for the Quine atom (CC-2) on MachinePhase ✓'], ['machinePhaseKleene (KleeneStructure)', 'machinePhaseAFA + Classical.choose computational_quine_exists', 'Standard Mathlib foundational axioms', @@ -777,42 +817,42 @@ def build(): 'structural closure by typeclass design — see R-K.0)'], ['fixed_points_infinite, padding', 'fixed_point₂_unbounded (Kleene.lean § VIII)', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Computability/Kleene.lean)', 'Lean ✓ — infinitely many fixed points for every partially computable F; the Padding Lemma'], ['selfref_universal_exists, selfref_universal_infinite', 'fixed_point₂ (Mathlib) + selfPrintOrDelegate_partrec; fixed_points_infinite', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04), carried by the statement; ' - 'restated form UNCLASSIFIED, Kleene.md § VIII', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Computability/Kleene.lean), carried by the statement; ' + 'restated form proved without choice, selfref_universal_exists_enc (ZeroParadox/Computability/Kleene.md § VIII)', 'Lean ✓ — existence of self-printing universal codes; nothing says a code is run'], ['selfprints_behaviour_injective', 'SelfPrints at channel 0 + Encodable.encode_injective', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Computability/Kleene.lean)', 'Lean ✓ — Reading: a uniqueness at the level of behaviour'], ['selfPrints_universal_address', 'SelfPrints + Universal + Encodable.encode_injective', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Computability/Kleene.lean)', 'Lean ✓ — Reading: replicas share everything but the address'], ['code_occurs_of_disjunctive', 'Disjunctive (Disjunctive.lean § I) at each code word', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Information/Disjunctive.lean)', 'Lean ✓ — presence, Sense A; no code is read or run'], ['champ_disjunctive, champ_disjunctiveOnce, champ_primrec', 'tri / untri slot layout + bitAt_ofBits; disjunctive_iff_once; Mathlib Primrec', 'champ_disjunctive: propext, Classical.choice, Quot.sound; champ_disjunctiveOnce: ' - 'propext, Quot.sound; champ_primrec: propext, Classical.choice, Quot.sound (measured ' - '2026-10-04)', + 'propext, Quot.sound; champ_primrec: propext, Classical.choice, Quot.sound ' + '(#print axioms, ZeroParadox/Information/Disjunctive.lean)', 'Lean ✓ — disjunctive without randomness'], ['fairTape_disjunctive_ae', 'second Borel–Cantelli (measure_limsup_eq_one) on disjoint aligned blocks', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Information/Disjunctive.lean)', 'Lean ✓ — almost every fair-coin tape is disjunctive'], ['disjunctive_not_periodic', 'not_disjunctive_of_periodic (Disjunctive.lean § V)', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Information/Disjunctive.lean)', 'Lean ✓ — no full self-copy at any offset a > 0'], ['carry_steps_onward_forever_yet_shows_nothing', 'stutter_obs_const + carry_stutters (Occurrence.lean § VI-c)', - 'propext, Classical.choice, Quot.sound (measured 2026-10-04)', + 'propext, Classical.choice, Quot.sound (#print axioms, ZeroParadox/Computability/Occurrence.lean)', 'Lean ✓ — steps onward forever with a constant observable'], ['Reading: zero tape (Section VI.V)', 'BottomCannotBe.lean, "The infinitude in two charts: content and self"', @@ -857,7 +897,7 @@ def build(): 'CLOSED — two predicates, two answers', 'Codes meeting IsComputationalQuine are not unique: the constant codes alone give ' 'infinitely many (infinite_quine_family). That the Quine atom is ⊥ of the lattice, and the ' - 'only one, flows from ZP-J T-EXEC (set-theoretic side). For self-printing codes, a ' + 'only one, flows from ZP-J T-EXEC (the AFA side). For self-printing codes, a ' 'uniqueness at the level of behaviour is proved (selfprints_behaviour_injective).'], ['Rogers\' fixed-point theorem', 'CLOSED — roger_fixed_point_exists', @@ -868,16 +908,19 @@ def build(): 'The 2-adic model from ZP-B (Q₂ structure) has not been given a KleeneStructure ' 'instance. This is a natural extension but not required for T-SNAP or DA-1.'], ['Choice-free recursion theorem', - 'OPEN — measured negative, 2026-10-04', + 'CLOSED for Kleene\'s form (kleene_cf) and the channel restatement ' + '(selfref_universal_exists_enc); Rogers\' form not restated', 'The statement of selfref_universal_exists carries Classical.choice through Mathlib\'s ' - 'numbering of codes (Denumerable Code); restated with encodeCode for the Gödel number and ' - 'the channel of code d written Nat.pair (encodeCode d + 1) n, it is axiom-free, and no ' - 'proof of the restated form without choice was found. What the route lacked, as located ' - 'then, is recorded in ZeroParadox/Computability/Kleene.md § VIII. Every proof of the ' - 'statement as written carries choice; whether the restated form has a choice-free proof ' - 'is UNCLASSIFIED.'], + 'numbering of codes (Denumerable Code), so every proof of it as written carries choice. ' + 'Restated with encodeCode for the Gödel number and the channel of code d written ' + 'Nat.pair (encodeCode d + 1) n, it is axiom-free, and selfref_universal_exists_enc ' + '(ZeroParadox/Computability/UniversalChoiceFree.lean) proves it at propext and Quot.sound ' + 'only. The recursion theorem itself, for a transformation given as a code, is kleene_cf ' + '(ZeroParadox/Computability/KleeneChoiceFree.lean), at the same footprint. Rogers\' form, ' + '∀ f, Computable f → ∃ c, eval (f c) = eval c, has no choice-free restatement in this ' + 'corpus. The record is ZeroParadox/Computability/Kleene.md § VIII.'], ['Martin-Löf randomness ⇒ disjunctive', - 'OPEN — not in Lean', + 'OPEN — not formalized in this corpus', 'Standard theory: a Martin-Löf random sequence is disjunctive, and by the Levin–Schnorr ' 'theorem Martin-Löf randomness is incompressibility of every prefix, K(first n bits of x) ≥ ' 'n − c for some constant c and every n, with K the prefix-free complexity (Franklin and ' @@ -886,7 +929,10 @@ def build(): 'p. 15, crediting Martin-Löf; Martin-Löf 1971, Theorem 1, proves the form conditional on ' 'the length n). Martin-Löf randomness and ' 'Kolmogorov complexity are not located in the Mathlib pin as of 2026-10-04 (search record ' - 'in Disjunctive.md). Until this bridge is formalised, the framework\'s commitment that the ' + 'in ZeroParadox/Information/Disjunctive.md). Outside Mathlib, one development named at the ' + 'ZPSurprisal entry of LEAN_CUSTOM_REGISTRY.md defines Martin-Löf randomness and proves the ' + 'Levin–Schnorr theorem; a proof there that a Martin-Löf random sequence is disjunctive was ' + 'not located as of 2026-11-01 (the search is recorded at that entry). Until this bridge is formalised, the framework\'s commitment that the ' 'occupant of its ⊥ role, ⊥ of a ZPSemilattice, read as a tape, is maximally complex reaches ' 'Disjunctive (Section VI.I) only as a reading.'], ] diff --git a/scripts/build_zpk_companion.py b/scripts/build_zpk_companion.py index 3400f13a..73d85492 100644 --- a/scripts/build_zpk_companion.py +++ b/scripts/build_zpk_companion.py @@ -1,6 +1,6 @@ """ Build ZP-K Illustrated Companion -Version 1.25 | October 2026 +Version 1.34 | November 2026 """ import os @@ -51,7 +51,7 @@ def node(bx, by, color, lite, label, sub1, sub2, ax1, ay1, ax2, ay2): # Top: Set theory / AFA node(cx - bw/2, cy + cr + 10, INDIGO, INDIGO_LITE, - 'Set Theory (AFA)', '⊥ = {⊥}', 'Quine atom', + 'Set Theory (AFA)', 'x = {x}', 'Quine atom', cx, cy + cr + 10, cx, cy + cr + 2) # Bottom: Computation / Kleene @@ -78,8 +78,9 @@ def four_way_table(): Paragraph('Intuition', CS['kr_hdr'])] rows = [ ['Set theory (AFA)', - '⊥ = {⊥} — Quine atom', - '⊥ is its own sole member; no external interpreter exists'], + 'x = {x} — the Quine-atom role (CC-2); in an AFAStructure lattice ⊥ is its only ' + 'occupant (quineAtomHost_quine_role_iff)', + 'the set Q = {Q} is its own sole member; ⊥ occupies the role in the lattice'], ['Order theory (ZP-A)', '⊥ ≤ x for all x — minimum', '⊥ is below everything; the universal starting point'], @@ -88,8 +89,9 @@ def four_way_table(): '⊥ contributes nothing to any join; the additive zero'], ['Computation (Kleene)', 'eval botCode = selfApply botCode — fixed point', - 'a fixed point of self-application; reading it as "⊥ is its own program" is the ' - 'framework\'s commitment, not a consequence'], + 'a fixed point of self-application; "⊥ is its own program" is not an identity: ' + 'codes occupy the Quine-atom role in their own chart, as a class up to equal output, for a ' + 'computable map respecting equal output (codes_vs_classes)'], ] data = [hdr] + [[Paragraph(fix(r[0]), CS['kr_body']), Paragraph(fix(r[1]), CS['kr_body']), @@ -107,7 +109,7 @@ def four_way_table(): t = Table(data, colWidths=[TW*0.22, TW*0.30, TW*0.48]) t.setStyle(ts); return t -VERSION = '1.25' +VERSION = '1.34' FIRST_RELEASED = 'April 2026' @@ -150,16 +152,21 @@ def footer_cb(canvas, doc): # What Is ZP-K Doing? E.append(Paragraph('What Is ZP-K Doing?', CS['h1'])) E.append(cbody( - 'ZP-J proved that the Quine atom (set-theoretic self-reference) and the bottom element ' - '(order-theoretic minimum) are the same object. ZP-K adds a fourth language: ' + 'ZP-J proved that inside a ZPSemilattice carrying AFAStructure, the Quine atom (CC-2, ' + 'set-theoretic self-reference) is the bottom element ⊥ (order-theoretic minimum) and no other ' + 'element is (T-EXEC, t_exec_triple_iff): one occupant of the Quine-atom role, in the lattice ' + 'chart. ZP-K adds a fourth language: ' 'computability theory. It adds a fourth description of ⊥, this time in terms of ' 'Turing machines and Kleene\'s second recursion theorem. THREE of the four descriptions ' 'are proved equivalent: T-COMP shows that, for an element of a ZPSemilattice carrying ' 'KleeneStructure, being a Quine atom is equivalent to being the semilattice\'s least element ⊥ ' 'together with the join identity, and da2_bottom_characterization shows those two ' - 'equivalent. ZP-K carries c₀\'s computational face as a ' - 'KleeneStructure requirement (botCode_is_quine); reading c₀ as the Kleene quine is the ' - 'KleeneStructure commitment, not a theorem.')) + 'equivalent. ZP-K\'s KleeneStructure requires some code to be a computational quine ' + '(botCode_is_quine, a periodicity condition that constant codes also meet); no field ties that code to c₀. Reading c₀ as the Kleene quine splits in ' + 'two: its identity half is retired, since codes occupy the Quine-atom role in their own ' + 'chart, as a class of codes up to equal output, for a computable map respecting equal ' + 'output (codes_vs_classes); and that c₀ runs is the ' + 'occurrence commitment. Neither half is a theorem.')) E.append(cbody( 'On the framework\'s reading, ⊥ is not a description of a Turing machine waiting for an ' 'outside party to run it: ⊥ is read as an instance of a Turing machine (its ground state, ' @@ -196,9 +203,12 @@ def footer_cb(canvas, doc): 'Kleene\'s theorem guarantees that every partially computable map f sending each program to ' 'a partial function has a fixed point, a program c whose behaviour eval c is the function f ' 'sends it to, eval c = f c (kleene_fixed_point_exists); a self-printing program of this kind ' - 'is a fixed point of one particular such map (selfref_universal_exists, below). On the framework\'s reading, the computational Quine is the expression ' - 'of ⊥ = {⊥} in the language of programs: c is its own program, just as ⊥ is its own member. ' - 'ZP-K carries that reading as a KleeneStructure requirement (botCode_is_quine), not a theorem.', + 'is a fixed point of one particular such map (selfref_universal_exists, below). ZP-K was built ' + 'on the reading that the computational Quine expresses the Quine atom (CC-2) in the language ' + 'of programs: c is its own program, just as ⊥ is its own member. Stated in the die, that is ' + 'one role with an occupant in each chart, not an identity: ⊥ in an AFAStructure lattice ' + '(quineAtomHost_quine_role_iff), and a class of codes up to equal output on the code side, ' + 'for a computable map respecting equal output (codes_vs_classes). No field of KleeneStructure asserts an identity.', ])) E.append(sp(4)) E.append(cbody( @@ -222,17 +232,23 @@ def footer_cb(canvas, doc): E.append(sp(8)) # The four-way equivalence - E.append(Paragraph('T-COMP: The Three-Way Equivalence, and What Computation Adds', CS['h1'])) + E.append(Paragraph('The Three-Way Equivalence (T-COMP with da2_bottom_characterization), and What Computation Adds', CS['h1'])) E.append(cbody( 'ZP-K\'s central theorem, T-COMP (Computational Grounding), with da2_bottom_characterization, proves that THREE of the ' - 'four descriptions below are equivalent - self-containment, order, and algebra all ' - 'identify the same object. The fourth, the computational one, is not a clause of the ' + 'four descriptions below are equivalent - the Quine-atom predicate (AFA), order, and algebra all ' + 'identify the same element of the lattice. The fourth, the computational one, is not a clause of the ' 'theorem: it is supplied as an assumption when the structure is built. The framework ' 'holds to that distinction:')) E.append(four_way_diagram()) E.append(ccaption( - 'The null ground element ⊥ at the center, described in four formal languages. The arrows ' - 'among the first three are proved equivalences. The computational description is joined to ' + '⊥ of the lattice at the center, described in three formal languages; the fourth node, the ' + 'computational one, is a condition on a code (KleeneStructure.botCode_is_quine), supplied by assumption and not one ' + 'object with ⊥: for a generic lattice L an equation between a code and ⊥ of L is ' + 'ill-typed (for L the type of codes itself it typechecks, ZeroParadox/Computability/' + 'ComputationCannotBe.lean § IV), and no theorem states one. In the code chart the ' + 'Quine-atom role is filled by a class of codes up to equal output, not by one code: under ' + 'the evaluation step no single code occupies it (evalStepMotion_not_selfOnlyAt), and, for a ' + 'computable map respecting equal output, a class does (codes_vs_classes). The arrows among the first three are proved equivalences. The computational description is joined to ' 'them by assumption, not by proof.')) E.append(sp(4)) E.append(four_way_table()) @@ -244,13 +260,16 @@ def footer_cb(canvas, doc): 'the motivation for building a KleeneStructure, the formal bridge connecting the ' 'set-theoretic (AFAStructure) and computational (Kleene fixed-point) descriptions. It is ' 'not something ZP-K derives: the bridge is built because the reading is held, not the ' - 'other way round.')) + 'other way round. The identity half of that reading is retired: what the descriptions ' + 'share is the Quine-atom role (Motion.SelfOnlyAt, a point that steps to itself and to ' + 'nothing else), and each chart proves its own occupancy of it.')) E.append(sp(4)) E.append(remember_box( 'Remember: T-COMP is not saying that set theory and computability theory are the same. ' 'It is saying that the specific structural role played by ⊥ — self-containment, ' 'minimality, join-identity — is expressible in several languages, and that THREE of ' - 'those expressions are provably equivalent; the computational one is joined by ' + 'those expressions are provably equivalent (T-COMP with da2_bottom_characterization); ' + 'the computational one is joined by ' 'assumption. The equivalence is local to this ' 'structural role, not a global identification of the frameworks.')) E.append(sp(8)) @@ -262,15 +281,23 @@ def footer_cb(canvas, doc): E.append(cbody( 'Path 1 (Structural — AFA): Nothing external to ⊥ can execute ⊥, so if ⊥ ' 'executes at all, it executes itself. That rules out an outside executor; it does not rule ' - 'out an inert ⊥. ZP-J proved axiom-free that ⊥ is the unique self-containing element (the structural fixed point); that this is the literal ⊥ = {⊥} holds in the ZF+AFA setting. ' + 'out an inert ⊥. ZP-J proved axiom-free that ⊥ of a lattice carrying AFAStructure is its unique self-containing element (the structural fixed point). ' + 'Read in ZFC− + AFA (Foundation replaced by AFA, Choice kept), the Quine-atom role is filled by a set x with x = {x} (Aczel 1988, ' + 'Example 1.3); in Mathlib\'s ZFSet it ' + 'is unoccupied (zfset_quine_role_unoccupied). No equation across the lattice and a set ' + 'chart is stated. ' 'What Lean witnesses via ZP-K: Path 1\'s Lean counterpart is da1_closed_concrete, which proves ' 'IsQuineAtom (⊥ : MachinePhase) through the KleeneStructure instance machinePhaseKleene, ' 'whose AFAStructure part is machinePhaseAFA. There selfMem is defined as x = ⊥, so the ' 'content is the uniqueness rather than the membership, and the same statement has a proof ' 'from machinePhaseAFA alone (the example after da1_closed_concrete in Kleene.lean).')) E.append(cbody( - 'Path 2 (Informational — L-INF): The surprisal of ⊥ is unbounded — no finite ' - 'interpreter can hold it as a stored description. ' + 'Path 2 (Informational — L-INF): Surprisal at ⊥ has two charts (⊥ of MachinePhase corresponds to 0 of Q₂ by the framework\'s reading, not an identity). In the ' + 'depth chart every depth n of the binary ball hierarchy has finite surprisal n and no finite ' + 'bound holds of all of them (l_inf); in the point chart the complexity at the floor 0 of Q₂ ' + 'is ⊤ (infinitude_forces_infinite_complexity, at the Q₂ instance q2InfinitudeFloor). Both, and why no equation joins them: ' + 'ZeroParadox/Information/Surprisal.lean, l_inf. Reading: no finite interpreter can hold ⊥ ' + 'as a stored description. ' 'Remains outside Lean scope: the step from "unbounded surprisal" to "executing" ' 'is a bridge principle of its own, which the framework does not adopt, and it is not the ' 'occurrence commitment.')) @@ -305,9 +332,11 @@ def footer_cb(canvas, doc): 'waiting for someone outside to press "run": if it runs at all, it runs itself (Path 1). ' 'That it does run is the occurrence commitment, which DA-1 uses and does not supply; ' 'given it, the machine has left c₀ for c₁, by the definition of the first running ' - 'configuration (D7). ZP-K carries c₀\'s computational face as a ' - 'KleeneStructure requirement (botCode_is_quine); reading c₀ as the Kleene quine is the ' - 'KleeneStructure commitment, not a theorem. What T-COMP, with da2_bottom_characterization, proves is narrower: ' + 'configuration (D7). ZP-K\'s KleeneStructure requires some code to be a computational quine ' + '(botCode_is_quine, a periodicity condition that constant codes also meet); no field ties that code to c₀; reading c₀ as the Kleene quine is not an ' + 'identity (codes occupy the Quine-atom role in their own chart, as a class up to equal output, ' + 'for a computable map respecting equal output, codes_vs_classes), and that ' + 'c₀ runs is the occurrence commitment. What T-COMP, with da2_bottom_characterization, proves is narrower: ' 'three of the four descriptions of ⊥ are equivalent to one another. It says nothing ' 'about external agents, and nothing about execution.')) E.append(sp(4)) @@ -327,11 +356,14 @@ def footer_cb(canvas, doc): E.append(Paragraph('A Note on Proof Purity', CS['h1'])) E.append(cbody( 'The statements of Kleene\'s theorem and of Rogers\' fixed-point theorem, as Mathlib ' - 'states them, already carry Classical.choice (measured 2026-10-04), so every proof of ' + 'states them, already carry Classical.choice (where it enters is recorded in ' + 'ZeroParadox/Computability/Kleene.md § VIII), so every proof of ' 'them as stated carries it too: the STATEMENT-CARRIED class of ' 'ZeroParadox/Category/ChoiceCannotBe.md. That footprint is inherited from Mathlib rather ' - 'than a Zero Paradox commitment. Whether a restated, choice-free statement has a ' - 'choice-free proof is unclassified in that document\'s sense. ZP-K Section IV tabulates the measured axiom footprints. ' + 'than a Zero Paradox commitment. Kleene\'s theorem restated with the transformation given ' + 'as a code has a statement and a proof free of choice (kleene_cf, ' + 'ZeroParadox/Computability/KleeneChoiceFree.lean); Rogers\' form has no such restatement ' + 'in this corpus. ZP-K Section IV tabulates the measured axiom footprints. ' 'What is free of Classical.choice is the choice-free CORE, and that is narrower than any layer ' 'name: ZeroParadox/AxiomProfile.lean §I is where the core is listed and each ' 'footprint measured — T-SNAP, the lattice, the Quine atom. Results elsewhere ' @@ -373,17 +405,18 @@ def footer_cb(canvas, doc): 'but unprovable in PA — a fixed point, not an oscillation.')) E.append(cbody( 'ZP-K’s construction achieves the same structural form in the setting of ⊥. ' - '⊥ = {⊥} (the AFA Quine atom; da1_closed_concrete gives this for MachinePhase, where selfMem is defined as x = ⊥, so the content is the uniqueness rather than the membership) is ' + 'The Quine atom (CC-2), here ⊥ of MachinePhase (da1_closed_concrete; selfMem is defined ' + 'as x = ⊥, so the content is the uniqueness rather than the membership), is ' 'self-containing, not self-negating: x = f(x) where f is set-membership, not ' 'x = NOT x. The Kleene fixed point gives the same structure computationally: ' 'a code whose behavior is determined entirely by itself. Both witnesses resolve ' 'at a fixed point. Neither oscillates.')) E.append(cbody( - 'ZP-E’s t_snap_irreversible goes further: it formally proves that the ' - 'liar-type trajectory is structurally impossible in this framework, not merely ' - 'absent. Once c₀ transitions to c₁, the semilattice axioms guarantee ' - 'no path returns. The sequence c₀ → c₁ → c₀ → … ' - 'cannot occur — the algebra forbids it.')) + 'ZP-E’s t_snap_irreversible goes further for one kind of step, the join: if x lies ' + 'strictly below y, no join of y with anything gives back x. So once c₀ has moved to ' + 'c₁, no join returns, and the sequence c₀ → c₁ → c₀ ' + '→ … cannot occur given that every transition is a join. The theorem says ' + 'nothing about steps of other kinds.')) E.append(sp(4)) E.append(remember_box( 'This is a structural observation, not a claim that ZP proves Gödel’s ' @@ -412,10 +445,12 @@ def footer_cb(canvas, doc): 'simple counting tape in the style of Champernowne is disjunctive and computable. The ' 'framework holds, as a commitment, that the occupant of its ⊥ role, ⊥ of a ZPSemilattice, ' 'read as a tape, is maximally complex; that commitment is about that occupant, not about ' - 'the all-false tape below. Standard theory, not proved in Lean: a sequence whose every ' + 'the all-false tape below. Standard theory, not proved in this corpus: a sequence whose every ' 'prefix is incompressible up to a constant in the prefix-free sense of Kolmogorov ' 'complexity is exactly a Martin-Löf random one (the Levin–Schnorr theorem; Franklin and ' - 'Porter, arXiv:2004.02851, Theorem 2.5), and such a sequence is disjunctive. The ' + 'Porter, arXiv:2004.02851, Theorem 2.5; proved in Lean outside Mathlib in a development ' + 'that the ZPSurprisal entry of LEAN_CUSTOM_REGISTRY.md names), and such a sequence is ' + 'disjunctive. The ' 'prefix-free sense matters: with plain complexity every infinite sequence has infinitely ' 'many prefixes of length n compressible to at most n − log n bits (Franklin and Porter, ' 'arXiv:2004.02851, § 2.2, p. 15, crediting Martin-Löf; Martin-Löf 1971, Theorem 1, proves ' @@ -442,9 +477,11 @@ def footer_cb(canvas, doc): 'a theorem about programs: building a program is a computation, and choosing a program by ' 'what it does is where choice would do its work. In Lean the footprint does not draw that ' 'line: the existence theorem\'s statement carries Classical.choice (STATEMENT-CARRIED in ' - 'the sense of ZeroParadox/Category/ChoiceCannotBe.md), and whether a restated, ' - 'choice-free statement has a choice-free proof is unclassified in that sense ' - '(ZeroParadox/Computability/Kleene.md § VIII).')) + 'the sense of ZeroParadox/Category/ChoiceCannotBe.md), while a restated statement, with ' + 'the Gödel number and the channels spelled without Mathlib\'s numbering of programs, is ' + 'free of choice and has a proof free of choice (selfref_universal_exists_enc, ' + 'ZeroParadox/Computability/UniversalChoiceFree.lean; the record is ' + 'ZeroParadox/Computability/Kleene.md § VIII).')) E.append(cbody( 'The zero tape. The all-false tape is ⊥ of the bit-by-bit tape order, carries no ' 'program\'s code except the empty one, and is what any tape becomes when compared with ' @@ -476,7 +513,7 @@ def footer_cb(canvas, doc): E.append(key_result_box( 'Key Result — ZP-K', 'T-COMP: IsQuineAtom(q) ↔ q = ⊥ ∧ (∀ x, q ∨ x = x). ' - 'THREE characterisations are proved equivalent - self-containment (AFA), order, and algebra ' + 'THREE characterisations are proved equivalent - the Quine-atom predicate (AFA), order, and algebra ' '(the last two by da2_bottom_characterization). ' 'The computational face is NOT a fourth clause of this theorem: it enters as an assumption, ' 'the KleeneStructure field botCode_is_quine. ' diff --git a/scripts/build_zpl.py b/scripts/build_zpl.py index e402bde6..873e0d9b 100644 --- a/scripts/build_zpl.py +++ b/scripts/build_zpl.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-L: Incomputability Convergence PDF Builder -Version 1.30 | October 2026 +Version 1.38 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.30' +VERSION = '1.38' FIRST_RELEASED = 'May 2026' @@ -49,8 +49,10 @@ def build(): 'Fourth, cnfToZp2 maps ordinals below ε₀ into ℤ₂ by recursion ' 'on their Cantor normal form. From tower stage 1 on, the 2-adic valuation of the ' 'image climbs with ordinal height toward ∞ while the 2-adic norm falls toward 0; ' - 'the images converge to 0 = ⊥, the point the seed stage 0 itself maps to ' - '(snap_arc_z2_loop, ZeroParadox/Ordinal/CnfBridge.lean).')) + 'the images converge to 0, the point the seed stage 0 itself maps to ' + '(snap_arc_z2_loop, ZeroParadox/Ordinal/CnfBridge.lean). That 0 is least in ' + 'ℤ₂\'s norm preorder and greatest in its valuation preorder ' + '(z2_two_views, ZeroParadox/Valuation/Scale.lean), the two readings just given.')) E.append(body( 'The central result (§VII) is the canonical snap map: ' 'ϕ α = if α < ε₀ then c₀ else c₁ ' @@ -75,13 +77,19 @@ def build(): 'which measures no axioms, and botCode, which carries them.')) E.append(data_table( - headers=['Layer', 'Formal Language', 'Expression of non-constructibility'], + headers=['Layer', 'Formal Language', 'Result cited, or status'], rows_data=[ ['ZPB', 'Topology', 'C3: no continuous path ⊥ → x ≠ ⊥'], - ['ZPC', 'Information Theory', 'L-INF: infinite surprisal at ⊥'], + ['ZPC', 'Information Theory', 'L-INF: surprisal unbounded in depth n, every value finite ' + '(l_inf); at Q₂\'s floor 0 the complexity cxQ2 is ⊤ ' + '(infinitude_forces_infinite_complexity, instance q2InfinitudeFloor). That c₀ ' + 'corresponds to that floor is a reading'], ['ZPJ/K', 'Set Theory + Computation', 'bot_self_mem (AFA); botCode (Kleene)'], - ['ZPI', 'Algorithmic IT', 'K uncomputable; the K-ratio bridge is refuted, ' - 'counterexample Sn = 2n (ZP-I § II.B)'], + ['ZPI', 'Algorithmic IT', 'K uncomputable. ZP-I § II.B refutes the valuation-complexity ' + 'bridge (unbounded 2-adic valuation of Sn implies K(Sn | n) / ' + '|Sn| → 1) with Sn = 2n, the powers of 2 that §IV\'s ' + 'tower images take; the valuation half is in ' + 'Lean, the complexity half is argued outside it'], ], col_widths=[50, 100, 280], )) @@ -91,8 +99,9 @@ def build(): 'Remark: K is not computed in Lean', [ 'Kolmogorov complexity K is not computed in Lean in this framework. ' - 'The AFA/Kleene route reaches the same fixed-point structure via a path whose ' - 'Kleene step is a KleeneStructure requirement, without requiring K to be explicitly computed.', + 'The AFA/Kleene route needs no K: da1_paths_unified is a conjunction of two facts, ' + 'that ⊥ of the lattice is its Quine atom (bot_is_quine_atom) and that the code ' + 'botCode is a computational quine (the KleeneStructure field botCode_is_quine).', 'Axiom footprint evidence — the following ZP-K theorems all carry ' '[propext, Classical.choice, Quot.sound]:', ' t_comp (T-COMP three-way equivalence; the computational face is an assumption, not a clause)', @@ -267,14 +276,20 @@ def build(): 'and by Tarski\'s completeness theorem for the theory of real-closed fields, ' 'every first-order sentence in the language of ordered fields that holds in ' 'ℝ also holds in No, and vice versa.', - 'ZP-F (The Counterexamples) proves that the Binary Snap — the transition from ⊥ to the ordinal threshold ε₀, the first fixed point of ω· above ⊥ of Ordinal ' - '(leastness: epsilonZero_le_fixedPoint, this section) — cannot occur in any linearly ordered ' - 'field. This result applies directly to No considered as a linearly ordered field. ' - 'Note the scope: what is derived is the transition’s SHAPE and its impossibility in an ordered field.', + 'ZP-F (The Counterexamples) proves that in any linearly ordered field 0 has no first step ' + 'above it, AX-B1’s form (f_snap_impossible, which, despite its name, states that no ' + 'linearly ordered field has a least positive element). Its ε₀ is a bound variable ' + 'over the positive elements of the field, each a candidate first step above the ' + 'field’s 0, and does not name the ordinal ε₀ of this section; in No that ' + 'ordinal is one of them, and ε₀/2 lies below it. This result applies directly to No considered as a ' + 'linearly ordered field. Note the scope: T-SNAP’s SHAPE does not need a first step ' + '(t_snap_given holds at a step taken in a densely ordered join-semilattice, ℚ≥0 under max, ' + 'whose ⊥ is 0; ZeroParadox/Order/Snap.lean); what an ordered ' + 'field lacks is AX-B1’s first step.', 'The surreals therefore contain ε₀ as an ordinal while simultaneously ' - 'satisfying the density condition that blocks the Binary Snap in their ordered ' + 'satisfying the density condition that rules out a first step above 0 in their ordered ' 'field structure. Both structures coexist in No: ε₀ is present as an ' - 'ordinal, and the field density that blocks the snap is present in the field ' + 'ordinal, and the field density that rules out a first step is present in the field ' 'structure. The two results apply to different structural aspects of No.', ] )) @@ -289,14 +304,12 @@ def build(): 'full first-order theory, so any first-order property of ℝ — ' 'including field density — transfers.', 'Field density transfers: between any two hyperreals there is another. The ' - 'density condition that blocks the Binary Snap in ℝ (proved in ZP-F) ' + 'density condition that rules out a first step above 0 in ℝ (proved in ZP-F) ' 'therefore holds in *ℝ as well.', 'The non-standard naturals *ℕ contain infinite elements, but every ' - 'infinite H ∈ *ℕ has a predecessor H−1 in *ℕ. ' - 'ε₀ is a limit ordinal: it has no predecessor and is the supremum ' - 'of the tower below it. *ℕ cannot host the Binary Snap not only because ' - 'of field density, but because its infinite elements are successor-like rather ' - 'than limit-like. The snap requires genuine limit ordinal structure.', + 'infinite H ∈ *ℕ has a predecessor H−1 in *ℕ, so none of ' + 'them is limit-like. ε₀, by contrast, is a limit ordinal: it has no predecessor and is the supremum ' + 'of the tower below it.', 'The monad of 0 in *ℝ — the external set {ε : |ε| < 1/n ' 'for all standard n} — is external to the ultrapower. Between any two ' 'distinct elements of the monad there is another (their arithmetic mean in ' @@ -373,7 +386,8 @@ def build(): 'Theorem: tower_converges_to_zero', [ 'Filter.Tendsto (fun n ↦ cnfToZp2 (towerNONote n)) Filter.atTop (nhds 0)', - 'The images of the tower stages converge to 0 = ⊥ in ℤ₂.', + 'The images of the tower stages converge to 0 (nhds 0) in ℤ₂; the theorem ' + 'names no order.', 'Proof: each stage’s image cnfToZp2(towerNONote (n+1)) = 2^(n+1) in ℤ₂, ' 'so its 2-adic norm is ‖2‖^(n+1) = (1/2)^(n+1) → 0. ' 'Uses Metric.tendsto_atTop and exists_pow_lt_of_lt_one.', @@ -682,15 +696,17 @@ def build(): '[propext, Classical.choice, Quot.sound]. Section I\'s table and ZP-K Section IV ' 'record where the ZP layers differ — Section I\'s own ZPJ/K row names ' 'bot_self_mem, which measures no axioms.', - 'These are standard Mathlib infrastructure axioms (ordinal theory, p-adic ' - 'analysis, computability). They are not ZP-L commitments.', + 'These are axioms of Lean\'s core library, reached here through Mathlib\'s ordinal ' + 'theory, p-adic analysis and computability. They are not ZP-L commitments.', 'The footprints across the ZP layers are not uniform; ZP-K Section IV tabulates the ' 'measurements. In the computability layer, Rogers\' fixed-point theorem as Mathlib ' 'states it carries Classical.choice in its statement, through Mathlib\'s numbering of ' 'program codes (the Denumerable Code instance; ZeroParadox/Computability/Kleene.md ' '§ VIII). ZP-K\'s machinePhaseKleene also picks botCode with Classical.choose, which is ' 'what makes that instance noncomputable.', - 'Zero sorry in Gentzen.lean.', + 'The footprints listed here are copies; to re-measure one, run #print axioms on the named ' + 'declaration. ZeroParadox/Ordinal/Gentzen.lean, this document\'s own Lean file, prints ' + 'those of the results it holds.', ] )) E.append(sp(6)) diff --git a/scripts/build_zpl_companion.py b/scripts/build_zpl_companion.py index 5922a401..ccab330f 100644 --- a/scripts/build_zpl_companion.py +++ b/scripts/build_zpl_companion.py @@ -1,13 +1,18 @@ """ Build ZP-L Illustrated Companion -Version 1.18 | October 2026 +Version 1.23 | November 2026 Citation fence (Gentzen): the Convergence section's credits follow CLAIMS.md's Gentzen rows and are -taken from the primary papers, never from a secondary source's labels. Provability of transfinite -induction below epsilon-0 is what Gentzen 1943 (p. 140 and its footnote 3) reports, crediting -Hilbert-Bernays; it is never called Hilbert-Bernays' theorem, and no year is given for Grundlagen der -Mathematik II (no copy among this project's filed papers, searched by file name, 2026-10-13). Not -cited: p. 140's announcement of the presentations in Gentzen 1943 section 2 (pp. 145-155 not checked -against the text), and the 1938 Neue Fassung. +taken from Gentzen 1943 (Math. Ann. 119), the one primary paper filed here, never from a secondary +source's labels. The 1936 consistency credit rests on Gentzen 1943, p. 140, footnote 2: the 1936 +paper itself was not among this project's filed papers as of 2026-11-03 (searched by file name). +The rendered Cantor-normal-form credit (Gentzen 1943, section 1) has no CLAIMS.md row; it is read +from p. 141 of the filed scan, where every ordinal below epsilon-0 is written (uniquely) with 0, +omega, sum and omega-exponentiation. Provability of transfinite induction below epsilon-0 is what +Gentzen 1943 (p. 140 and its footnote 3) reports, crediting Hilbert-Bernays; it is never called +Hilbert-Bernays' theorem, and no year is given for Grundlagen der Mathematik II (a copy was not +located among this project's filed papers as of 2026-10-13, searched by file name). Not cited: p. 140's +announcement of the presentations in Gentzen 1943 section 2 (pp. 146-151 on the filed scan), and the +1938 Neue Fassung. """ import os @@ -179,23 +184,23 @@ def dual_convergence_diagram(): d.add(Circle(dots_x + j * 8, row_bot, 2, fillColor=INDIGO, strokeColor=INDIGO, strokeWidth=0)) - # Arrow to 0 = ⊥ box + # Arrow to the 0 box arr2_x1 = dots_x + 3 * 8 + 4 arr2_x2 = end_bx - 3 d.add(Line(arr2_x1, row_bot, arr2_x2, row_bot, strokeColor=INDIGO, strokeWidth=1.5)) d.add(Line(arr2_x2, row_bot, arr2_x2 - 7, row_bot + 4, strokeColor=INDIGO, strokeWidth=1.5)) d.add(Line(arr2_x2, row_bot, arr2_x2 - 7, row_bot - 4, strokeColor=INDIGO, strokeWidth=1.5)) - # 0 = ⊥ box (indigo) + # 0 box (indigo): the norm view's least point, so no ⊥ of another structure is drawn here d.add(Rect(end_bx, bot_by, end_bw, bh, fillColor=INDIGO_LITE, strokeColor=INDIGO, strokeWidth=1.8, rx=3, ry=3)) - d.add(String(end_bx + 5, bot_by + bh - 13, '0 = ⊥', + d.add(String(end_bx + 5, bot_by + bh - 13, '0', fontSize=9.5, fontName='DV-B', fillColor=INDIGO)) d.add(String(end_bx + 5, bot_by + 5, '(limit)', fontSize=7.5, fontName='DV-I', fillColor=INDIGO)) # Row label (above bottom row, in the inter-row gap) - d.add(String(x0, bot_by + bh + 8, '2-adic norm of image (converges to 0 = ⊥):', + d.add(String(x0, bot_by + bh + 8, '2-adic norm of image (converges to 0):', fontSize=8, fontName='DV-I', fillColor=GREY_TEXT)) # ── Vertical dashed connectors between rows ─────────────────────────────── @@ -219,7 +224,7 @@ def dual_convergence_diagram(): return d -VERSION = '1.18' +VERSION = '1.23' FIRST_RELEASED = 'May 2026' @@ -272,10 +277,11 @@ def footer_cb(canvas, doc): # ── What Is ZP-L Doing? ─────────────────────────────────────────────────── E.append(Paragraph('What Is ZP-L Doing?', CS['h1'])) E.append(cbody( - 'ZP-K carries the computational face of the initial machine state c₀ as a ' + 'ZP-K carries a computational counterpart of the initial machine state c₀ as a ' 'KleeneStructure requirement (botCode_is_quine): a program whose behavior is determined ' 'entirely by its own index, whose existence the second recursion theorem guarantees. ' - 'Reading c₀ as the Kleene quine is that commitment, not a theorem. ZP-L picks up the thread from a different ' + 'No equation makes c₀ that program: the identity reading is retired, and what stays a ' + 'commitment is that c₀ actually runs, the occurrence commitment. ZP-L picks up the thread from a different ' 'direction: the ordinal direction. If a map ϕ assigns machine phases to ordinals ' '— sending c₀ to everything below a certain point and c₁ above it ' '— what is that threshold ordinal? ZP-L establishes the answer: ε₀, ' @@ -285,7 +291,9 @@ def footer_cb(canvas, doc): 'threshold — no monotone, tower-aligned map can snap before ε₀, and ' 'the canonical map snaps exactly there. ZP-L also establishes the connection to ' 'ZP-B: as the tower stages approach ε₀ in ordinal order, their ' - '2-adic images converge to 0 = ⊥ in ℤ₂. The same sequence ' + '2-adic images converge to 0 in ℤ₂, the point that is least in ' + 'ℤ₂\'s norm preorder and greatest in its valuation preorder (z2_two_views, ' + 'ZeroParadox/Valuation/Scale.lean). The same sequence ' 'witnesses both convergences simultaneously.')) E.append(sp(4)) E.append(example_box('Real-world analogy — the unreachable horizon', [ @@ -365,9 +373,10 @@ def footer_cb(canvas, doc): # ── The Two-Adic Connection ─────────────────────────────────────────────── E.append(Paragraph('The Two-Adic Connection', CS['h1'])) E.append(cbody( - 'ZP-B established that 0 = ⊥ in the 2-adic integers ℤ₂ is the ' - 'valuative sink: the 2-adic valuation of 0 is infinite, which means 0 sits at the ' - 'bottom of the 2-adic metric. ZP-L connects this to the ordinal tower via a map, ' + 'ZP-B established that 0 in the 2-adic integers ℤ₂ is the ' + 'valuative sink: the 2-adic valuation of 0 is infinite. So 0 is the greatest point in ' + 'the valuation preorder and the least in the norm preorder, where its norm is 0 ' + '(z2_two_views). ZP-L connects this to the ordinal tower via a map, ' 'cnfToZp2, from ordinals below ε₀ into ℤ₂, defined by recursion ' 'on their Cantor normal forms.')) E.append(cbody( @@ -376,14 +385,14 @@ def footer_cb(canvas, doc): 'the valuation, the images climb: 2n has 2-adic valuation n, rising toward ' 'the infinite valuation of 0. Read through the norm, they fall: the 2-adic norm of ' '2n is (1/2)n, which goes to 0 as n increases. So as the ordinal ' - 'tower climbs toward ε₀ from below, its 2-adic image converges to 0 = ⊥ ' + 'tower climbs toward ε₀ from below, its 2-adic image converges to 0 ' 'in the 2-adic metric, the point it started from. Two convergences, one tower.')) E.append(sp(4)) E.append(dual_convergence_diagram()) E.append(ccaption( 'Same tower stages, two perspectives. Teal (top row): ordinal stages 1, ω, ω^ω, … ' 'approach ε₀ from below. Indigo (bottom row): the 2-adic norms of their ' - 'images 1/2, 1/4, 1/8, … converge to 0 = ⊥. ' + 'images 1/2, 1/4, 1/8, … converge to 0. ' 'ZP-L §VII: snap_zp2_correspondence.')) E.append(sp(4)) E.append(cbody( @@ -398,15 +407,23 @@ def footer_cb(canvas, doc): # ── The Kleene Connection ───────────────────────────────────────────────── E.append(Paragraph('The Kleene Connection', CS['h1'])) E.append(cbody( - 'ZP-K carries ⊥\'s computational face as a requirement of its Kleene structure: ' - 'the class field botCode_is_quine, which asks the nominated code to satisfy ' + 'ZP-K\'s Kleene structure carries a computational-quine requirement, read as ⊥\'s counterpart: ' + 'the class field botCode_is_quine, which asks the supplied code to satisfy ' 'IsComputationalQuine — a periodicity condition, eval c n = eval c (encode c + n) ' 'for every n, so the code\'s own Gödel number is a period of it. Kleene\'s second ' 'recursion theorem guarantees such a code exists. The condition does not by itself pin ' 'self-reference: the constant codes satisfy it, and they are what witnesses ' - 'infinite_quine_family (ZP-K §VI). That the program and the bottom are one object ' - 'is the framework\'s reading rather than a Lean equation — a program code and the ' - 'lattice carrier are different types. ZP-L identifies ' + 'infinite_quine_family (ZP-K §VI). A program and ⊥ of the lattice are compared ' + 'through a role rather than an identity: the Quine-atom role, a point that steps to itself ' + 'and to nothing else (Motion.SelfOnlyAt), which a point of each chart occupies or provably none does. ' + '⊥ of the lattice is its only occupant under a self-application map supplied by ' + 'AbstractSelfApp (selfApp_quine_role_iff). On codes, stepping ' + 'from a code to the codes whose output is what a map assigns it, no single code occupies ' + 'it (evalStepMotion_not_selfOnlyAt), and for a computable map respecting equal output ' + 'some class of codes up to equal output does (codes_vs_classes, ' + 'ZeroParadox/Computability/Kleene.lean). No equation across a program code and the ' + 'lattice carrier is stated; they are different types, so the supplied code is not identified with ⊥, ' + 'and that ⊥ actually runs stays the occurrence commitment. ZP-L identifies ' 'ε₀ as an ordinal fixed point: the first ordinal satisfying ω^α = α, ' 'guaranteed to exist by the fixed-point theorem for normal functions. Both fixed-point ' 'proofs carry Classical.choice in their Lean formalizations; ZP-K Section IV ' @@ -459,8 +476,10 @@ def footer_cb(canvas, doc): E.append(cbody( 'ZP-L and Gentzen share the ordinal itself. ZP-L defines ε₀ as Mathlib’s ' 'Ordinal.epsilon 0, where ω-tower self-iteration closes on itself, and writes the ' - 'ordinals below it in Cantor normal form, the notation ordinal analysis also uses (Gentzen 1943, §1). Gentzen ' - 'starts from proof theory: ε₀ is where PA’s provability tower runs out. ' + 'ordinals below it in Cantor normal form, the notation ordinal analysis also uses (Gentzen 1943, §1). The ' + 'proof-theoretic side starts from PA: ε₀ is where PA’s provable cases of ' + 'transfinite induction run out, the cases below it credited by Gentzen to Hilbert-Bernays ' + '(1943, p. 140, footnote 3) and the case at it Gentzen’s own (1943). ' 'What is ZP-L’s own is the snap: a monotone map sending the tower’s stages to ' 'c₀ fires nowhere below ε₀, and its firing at ε₀ is a hypothesis, ' 'hε₀ (ZeroParadox/Ordinal/Incompleteness.lean § II).')) @@ -510,7 +529,7 @@ def footer_cb(canvas, doc): '(c₁ on every fixed point of ω^·), snapping at ε₀, ' 'and ε₀ minimal — with no free hypotheses. ' 'snap_zp2_correspondence co-proves that the same tower witnesses both the ' - 'ordinal approach to ε₀ and the 2-adic convergence to 0 = ⊥. ' + 'ordinal approach to ε₀ and the 2-adic convergence to 0 in ℤ₂. ' 'All theorems proved without sorry. ZPM places both sides in ℤ₂: cnfToZp2 ' 'sends the tower\'s ordinal notations there, snapEmbed sends the machine phases there, ' 'and the tower\'s images converge to snapEmbed\'s value at c₁ (zpm_triangle).')) diff --git a/scripts/build_zpm.py b/scripts/build_zpm.py index 1097e891..6437deb0 100644 --- a/scripts/build_zpm.py +++ b/scripts/build_zpm.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-M: Kleene-Ordinal Bridge PDF Builder -Version 1.13 | October 2026 +Version 1.20 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.13' +VERSION = '1.20' FIRST_RELEASED = 'May 2026' @@ -28,7 +28,7 @@ def build(): 'Synthesis bridge. ' 'All theorems §I–§IV proved sorry-free in Lean 4. ' 'Closes the hfp free hypothesis (ZP-L) and the snapEmbed type bridge. ' - 'Axiom footprint: [propext, Classical.choice, Quot.sound] throughout.', + 'Axiom footprint: at most [propext, Classical.choice, Quot.sound], per declaration below.', S['note']), sp(10), hr(), @@ -43,16 +43,17 @@ def build(): 'alignment hypothesis plus monotonicity: hfp is not an independent condition. ' 'Second, the canonical type bridge snapEmbed : MachinePhase → ℤ₂ ' 'formalizes the structural triangle connecting the pre-snap state c₀ ' - '(read as the Kleene quine, a KleeneStructure requirement in ZP-K, not a theorem), the ordinal snap at ε₀ (ZP-L), and the ' + '(⊥ of MachinePhase; reading it as the Kleene quine is not an equation, since a Code and a MachinePhase state ' + 'are different types, and that it runs is the occurrence commitment), the ordinal snap at ε₀ (ZP-L), and the ' '2-adic limit 0 (ZP-B).')) E.append(body( - 'The closing result (§IV) records that both the Kleene recursion theorem and ' - 'the ordinal fixed-point ε₀ = ω^ε₀ are instances of ' - 'the same diagonalization pattern: a self-referential operation produces a forced ' - 'fixed point. The two domains — computability theory (codes and Gödel numbers) ' - 'and ordinal theory (ω-tower iteration) — use no shared mathematical machinery, ' - 'but the structural schema is identical. Remark R-M.1 tracks what this means for ' - 'DA-1 Path 2 and the boundary of the diagonalization frame.')) + 'The closing result (§IV) proves two existence statements together: a code c with eval c n = eval c (encode c + n) ' + 'for every n (a periodicity condition, proved via the recursion theorem, which constant codes also meet) and the least ' + 'ordinal fixed point ε₀ = ω^ε₀. ' + 'It is a conjunction of two existence proofs over different types. The two domains — computability ' + 'theory (codes and Gödel numbers) and ordinal theory (ω-tower iteration) — use no shared ' + 'mathematical machinery; reading them as one pattern is the framework’s interpretation, not ' + 'what the theorem proves (Remark R-M.1). R-M.1 also tracks what this means for DA-1 Path 2.')) E.append(hr()) # ── Section I: The snapEmbed Morphism ────────────────────────────────────── @@ -69,11 +70,18 @@ def build(): 'Under multiplication on ℤ₂, 0 is absorbing — mirroring exactly the ' 'join structure on MachinePhase, where c₁ is the absorbing element.')) E.append(body( - 'Within the ZP framework, 0 ∈ ℤ₂ plays the role of ⊥ — ' - 'it is the 2-adic valuation limit and the fixed point of multiplication by 2. ' - 'snapEmbed makes this modelling commitment concrete: c₁ maps to 0 because ' - 'c₁ IS the object at infinite 2-adic depth. This is a modelling commitment, ' - 'not a ring-theoretic theorem.')) + 'No equation between a MachinePhase state and a 2-adic integer is stated; they are different types. ' + 'What c₁ and 0 share is a role, the die’s Motion.SelfOnlyAt (ZeroParadox/Die.lean): a point that ' + 'steps to itself and to nothing else; in each carrier its occupant is proved for the step chosen there. ' + 'Two pairings, each through the map snapEmbed, stand in place of an identity (Incompleteness.lean §I-b). Under the join step a → join a z for some z, only ' + 'c₁ occupies the role (machineJoinMotion_selfOnlyAt_iff); under the multiplication step x → x·w for some w ' + 'on ℤ₂, only 0 does (z2MulMotion_selfOnlyAt_iff); snapEmbed is a map of these two motions ' + '(snapEmbedHom). Its back clause fails at c₀ (1 steps to 2, and no state maps to 2), so the general ' + 'transport of the role along such maps does not apply; at c₁ the role does carry over, because 0 has only ' + 'itself as successor (snapEmbed_selfOnlyAt_c1, from Motion.selfOnlyAt_relHom). Under doubling on ℤ₂, ' + 'only 0 occupies the role (z2_double_selfOnlyAt_iff), and 0 is divisible by every power of 2 (snapEmbed_c1_dvd); but snapEmbed ' + 'carries no motion with a step at c₀ into doubling steps (snapEmbed_doubling_noStepAt): the snap ' + 'c₀ → c₁ goes to 1 → 0, which is not a doubling step.')) E.append(def_box( 'Definition: snapEmbed (Incompleteness.lean §I)', @@ -84,8 +92,8 @@ def build(): '', 'The morphism property: join on MachinePhase (c₁ is absorbing under join) ' 'corresponds to multiplication on ℤ₂ (0 is absorbing under ×). ' - 'Both structures share the absorbing-element pattern — the bridge is structural, ' - 'not incidental.', + 'In the die this is a map of motions, from a → join a z for some z on MachinePhase to ' + 'x → x·w for some w on ℤ₂ (snapEmbedHom, §I-b).', ] )) E.append(sp(6)) @@ -131,11 +139,30 @@ def build(): '∀ n : ℕ, (2 : ℤ₂)^n ∣ snapEmbed c₁', 'c₁ maps to 0, which is divisible by all powers of 2.', '0 ∈ ℤ₂ is divisible by 2^n for every n — infinite 2-adic depth.', - 'This is the formal signature of ⊥ = {⊥}: infinite 2-adic valuation.', 'Proof: simp [snapEmbed_c1].', 'Lean purity: [propext, Classical.choice, Quot.sound]. ✓', ] )) + E.append(sp(4)) + + E.append(result_box( + 'Results: snapEmbed in the die (Incompleteness.lean §I-b)', + [ + 'machineJoinMotion_selfOnlyAt_iff: under a → join a z for some z, y steps to itself and to nothing else iff y = c₁. ' + 'Lean purity: [propext].', + 'z2MulMotion_selfOnlyAt_iff: under x → x·w for some w on ℤ₂, y steps to itself and to nothing else iff y = 0. ' + 'Lean purity: [propext, Classical.choice, Quot.sound].', + 'snapEmbedHom: snapEmbed is a strict map between these two motions (steps to steps, from snapEmbed_mul_morphism). ' + 'An example beside it shows the back clause fails at c₀ (1 steps to 2, and no state maps to 2). ' + 'Lean purity: [propext, Classical.choice, Quot.sound].', + 'snapEmbed_selfOnlyAt_c1: the image of c₁ steps to itself only in the multiplication motion, carried along ' + 'snapEmbedHom’s steps by Motion.selfOnlyAt_relHom. Lean purity: [propext, Classical.choice, Quot.sound].', + 'z2_double_selfOnlyAt_iff: under doubling on ℤ₂, y steps to itself and to nothing else iff y = 0. ' + 'Lean purity: [propext, Classical.choice, Quot.sound].', + 'snapEmbed_doubling_noStepAt: if snapEmbed sends every step of a motion M on MachinePhase to a doubling step, ' + 'c₀ has no step in M. Lean purity: [propext, Classical.choice, Quot.sound]. ✓', + ] + )) E.append(sp(6)) E.append(remark_box( @@ -146,8 +173,8 @@ def build(): 'occupant 0 and the ε₀ occupant differ (epsilon0_ne_bot); against the ' '2-adic 0 an identity with ε₀ is not a well-formed statement ' '(it fails to elaborate, Ordinal vs ℤ₂), and the link runs ' - 'through maps: snapEmbed sends c₁ to 0, the Scale.lean chart\'s ' - '(⊥ = 0) bottom-role occupant. The canonical threshold ' + 'through maps: snapEmbed sends c₁ to 0, the bottom-role occupant of the Scale.lean chart, ' + 'whose join with ⊥ = 0 is chosen (ZeroParadox/Valuation/Scale.lean §V). The canonical threshold ' 'map Ordinal → MachinePhase is order-non-decreasing in ZP-A\'s join order ' '(snap_map_mono), and no map Ordinal → MachinePhase is compatible with the ' 'CNF → ℤ₂ map along the tower: for every g : MachinePhase → ' @@ -221,8 +248,8 @@ def build(): E.append(callout( 'What §II achieves: hfp is no longer a free hypothesis in the minimality theorem. ' 'Given ϕ ε₀ = c₁ (the alignment condition: the map snaps at ' - 'ε₀) plus monotonicity, the full minimality result follows from the ordinal ' - 'structure alone. hfp is a derived consequence, not an additional commitment.', + 'ε₀) plus monotonicity and every tower stage sent to c₀ (h0), the full ' + 'minimality result follows (snap_unconditional). hfp is a derived consequence, not an additional commitment.', bg=GREEN_LITE, border=GREEN )) E.append(sp(6)) @@ -291,24 +318,28 @@ def build(): )) E.append(sp(6)) - # ── Section IV: Shared Diagonalization Pattern ───────────────────────────── + # ── Section IV: The Kleene and Ordinal Fixed Points ───────────────────────────── print('[build_zpm] Building Section IV...') E += [ hr(), - Paragraph('Section IV: Shared Diagonalization Pattern', S['h1']), + Paragraph('Section IV: The Kleene and Ordinal Fixed Points', S['h1']), hr(), ] E.append(body( - 'Both the Kleene recursion theorem (ZP-K) and the ordinal fixed-point ε₀ ' - '(ZP-L) arise from the same structural schema: a self-referential operation has a ' - 'forced fixed point. In computability theory, the diagonal applies to codes and ' - 'their Gödel numbers. In ordinal theory, the diagonal applies to the tower iteration ' - 'α ↦ ω^α. The two domains share no mathematical machinery, ' - 'but the diagonalization pattern is identical.')) + 'The Kleene recursion theorem (ZP-K) gives a code fixed up to evaluation, and ε₀ (ZP-L) is ' + 'the least fixed point of ω^·; the two come from different constructions. In computability theory the construction ' + 'is a diagonal argument over codes and their Gödel numbers. In ordinal theory ε₀ is ' + 'reached by iterating the normal function α ↦ ω^α from 0 and taking the ' + 'supremum (ε₀ = nfp (ω^·) 0, epsilonZero_eq_nfp in ZeroParadox/Ordinal/Gentzen.lean), the ' + 'fixed-point lemma for normal functions rather than a diagonal argument. The two domains share no ' + 'mathematical machinery. The theorem below records the ordinal fixed point and, on the computability side, ' + 'the computability fixed point the recursion theorem yields: a code c with eval c = selfApply c ' + '(IsComputationalQuine), a predicate constant codes also satisfy, so it does not pin self-reference ' + '(Remark R-M.1).')) E.append(data_table( - headers=['Domain', 'Self-referential operation', 'Forced fixed point'], + headers=['Domain', 'Operation', 'Fixed point'], rows_data=[ ['Computability (ZP-K)', 'eval c = selfApply c (c runs on its own Gödel number)', @@ -327,11 +358,12 @@ def build(): '(∃ c : Code, ∀ n, eval c n = eval c (encode c + n)) ∧', '(∃ α : Ordinal, ω^α = α ∧ ' '∀ β, ω^β = β → α ≤ β)', - 'Both diagonalization patterns produce fixed points, co-proved in one formal context.', - 'Left: Kleene quine (period = Gödel number of c), via computational_quine_exists.', + 'Two existence statements, co-proved in one formal context.', + 'Left: a code periodic with period its own Gödel number, via computational_quine_exists; ' + 'constant codes also satisfy it, so the left conjunct alone does not pin self-reference.', 'Right: ε₀ = ω^ε₀, minimal; via epsilonZero_fixedPoint ' 'and epsilonZero_le_fixedPoint.', - 'The co-existence is the formal content: two forced fixed points, two domains, ' + 'The co-existence is the formal content: two existence statements, two domains, ' 'one theorem.', 'Lean purity: [propext, Classical.choice, Quot.sound]. ✓', ] @@ -341,29 +373,38 @@ def build(): E.append(remark_box( 'Remark R-M.1: DA-1 Path 2 and the Limits of the Diagonalization Frame', [ - 'both_fixed_points_exist establishes that Kleene diagonalization (a code on ' - 'its own Gödel number) and ordinal diagonalization (ε₀ = ω^ε₀, ' - 'least fixed point) are the same structural pattern in two domains. Both are ' - 'textbook instances of the diagonalization schema.', - 'L-INF (ZP-C §II: ⊥ has divergent surprisal — unbounded information content, ' - 'incompressible by any finite description) is structurally analogous. Whether it ' - 'fits the same diagonalization schema formally is the open question.', - 'The formally unconnected instance is L-INF. This gap is DA-1 Path 2 — the ' - 'informational bridge. The reason Path 2 resisted formalization is now visible ' - 'from this layer: L-INF is a measure-theoretic statement (Shannon entropy, ' - 'probability distributions) while the Kleene quine is a computability-theoretic ' - 'statement (partial recursive functions, Gödel encoding). The two frameworks ' - 'share no mathematical machinery.', - 'The diagonalization frame established here provides the common conceptual ground, ' - 'but the formal bridge requires the Kolmogorov complexity connection: ' - 'incompressibility is the concept that lives in both worlds simultaneously. ' - 'That bridge is outside the current Lean scope, pending AIT infrastructure ' - 'not yet in Mathlib.', - 'DA-1 Path 2 was recharacterized in ZP-E/ZP-K as a foundational commitment ' - 'rather than a missing proof. The diagonalization frame here makes the boundary ' - 'precise: the gap is not a skipped proof step but a genuine framework separation — ' - 'measure-theoretic surprisal on one side, computability-theoretic encoding on the ' - 'other, with no shared machinery in current Mathlib.', + 'both_fixed_points_exist records, on one side, a code periodic with period its own Gödel number ' + '(obtained by Kleene diagonalization, though constant codes also meet the condition) and, on the other, ' + 'the ordinal ε₀ = ω^ε₀, the least fixed point and the supremum of the iterates ' + 'of ω^· from 0. The statement is a ' + 'conjunction of two existentials, so it establishes that both exist, not that they are one ' + 'structural pattern; reading them as the same pattern is the framework’s interpretation, ' + 'and no equation between a Code and an Ordinal is well-formed. The Kleene fixed point comes from ' + 'a diagonal argument (Lawvere 1969; Yanofsky 2003, Theorem 5, places the recursion theorem under that schema); ε₀ comes from the fixed-point lemma for normal functions, by ' + 'iteration to a supremum.', + 'The informational argument has two charts. Depth chart, ZP-C L-INF: surprisal is unbounded above in the ' + 'ball-hierarchy depth, each value finite (l_inf). Point chart: at 0 of Q2, the one point in every ' + 'ball of the chain centred at 0, the 2-adic additive valuation is ⊤ (padic_addVal_bot), the point to ' + 'which c₀, ⊥ of MachinePhase, corresponds in ZP-C. As of 2026-11-01 no single declared map from ' + 'MachinePhase into ℤ2 or ℚ2 sends c₀ to 0: searching the .lean files under ' + 'ZeroParadox/ for both type names finds snapEmbed (ZeroParadox/Ordinal/Incompleteness.lean) and two negative ' + 'examples (ZeroParadox/Ordinal/Gentzen.lean, ZeroParadox/Valuation/SemilatticeInstance.lean). A composite does: ' + 'the order isomorphism from MachinePhase onto the two-point Pole (c₀ to zero), exhibited in an anonymous ' + 'example in ZeroParadox/DieCannotBe.lean and read there as order shape only, followed by poleToSphere ' + '(ZeroParadox/Valuation/PoleCornersBridge.lean), which sends zero to 0 of ℚ2 in its one-point ' + 'compactification; that composite is not declared. ' + '§ I’s snapEmbed is a different map, sending c₀ to 1 and c₁ to 0; the two are not ' + 'composed. L-INF is structurally analogous to the Kleene fixed point. Whether it ' + 'fits Kleene’s diagonalization schema formally is the open question this remark tracks.', + 'L-INF stays formally unconnected. It is a measure-theoretic statement ' + '(surprisal under a probability measure on ZP-B’s binary space), while the Kleene quine ' + 'is a computability-theoretic statement (partial recursive functions, Gödel encoding), ' + 'and neither this remark nor both_fixed_points_exist links them. ZP-C uses the surprisal ' + 'measure and Kolmogorov complexity as two separate arguments (ZP-C Remark R-BRIDGE).', + 'DA-1 Path 2 is a different matter. In ZP-E (DA-1 insert § IV) it is the step from ' + 'unbounded surprisal to executing: a bridge principle of its own, a missing principle and ' + 'not a missing proof, which the framework does not adopt and which is not the occurrence ' + 'commitment (ZeroParadox/Ordinal/Incompleteness.md, Remark R-M.1).', ] )) E.append(sp(6)) @@ -388,6 +429,12 @@ def build(): ['snap_state_zp2_is_zero', '§III', 'Proved ✓'], ['zpm_triangle', '§III', 'Proved ✓'], ['both_fixed_points_exist', '§IV', 'Proved ✓'], + ['machineJoinMotion_selfOnlyAt_iff', '§I-b', 'Proved ✓'], + ['z2MulMotion_selfOnlyAt_iff', '§I-b', 'Proved ✓'], + ['snapEmbedHom', '§I-b', 'Defined ✓'], + ['snapEmbed_selfOnlyAt_c1', '§I-b', 'Proved ✓'], + ['z2_double_selfOnlyAt_iff', '§I-b', 'Proved ✓'], + ['snapEmbed_doubling_noStepAt', '§I-b', 'Proved ✓'], ], col_widths=[TW * 0.55, TW * 0.15, TW * 0.30], )) @@ -396,15 +443,17 @@ def build(): E.append(axiom_box( 'Axiom Purity', [ - 'All theorems carry axiom footprint: [propext, Classical.choice, Quot.sound].', - 'These are standard Mathlib infrastructure axioms, inherited from ordinal theory ' - '(ZP-L), 2-adic analysis (ZP-B), and computability theory (ZP-K).', + 'Axiom footprint: at most [propext, Classical.choice, Quot.sound], per declaration (machineJoinMotion and machineJoinMotion_selfOnlyAt_iff carry [propext] only).', + 'propext, Classical.choice and Quot.sound are Lean’s own axioms; here they are reached through ' + 'Mathlib’s ordinal theory (ZP-L), 2-adic analysis (ZP-B), and computability theory (ZP-K).', 'Classical.choice is carried by the statements of the ordinal fixed-point (nfp) results as ' - 'written (statement control, measured 2026-10-08; ZeroParadox/Category/ChoiceCannotBe.md), ' + 'written (the statement controls printed in ZeroParadox/Ordinal/Epsilon0MinMax.lean; ' + 'ZeroParadox/Category/ChoiceCannotBe.md), ' 'and present in ' 'the computability fixed-point (Kleene\'s theorem). ZP-K Section IV tabulates the ' 'per-declaration measurements.', - 'Zero sorry in Incompleteness.lean. Verified: lake build, May 2026.', + 'The footprints listed here are copies; to re-measure one, run #print axioms on the named ' + 'declaration.', ] )) E.append(sp(6)) @@ -415,7 +464,7 @@ def build(): 'End of ZP-M | Kleene–Ordinal Bridge | ' 'snapEmbed type bridge | hfp gap closed | zpm_triangle co-proved | ' 'both_fixed_points_exist | R-M.1: DA-1 Path 2 boundary | ' - 'All Incompleteness.lean theorems verified. Axioms: [propext, Classical.choice, Quot.sound].', + 'All Incompleteness.lean theorems verified. Axioms: at most [propext, Classical.choice, Quot.sound], per declaration.', S['endnote']), ] diff --git a/scripts/build_zpm_companion.py b/scripts/build_zpm_companion.py index d86240ec..6520c11b 100644 --- a/scripts/build_zpm_companion.py +++ b/scripts/build_zpm_companion.py @@ -1,6 +1,6 @@ """ Build ZP-M Illustrated Companion -Version 1.8 | October 2026 +Version 1.14 | November 2026 """ import os @@ -8,7 +8,7 @@ from reportlab.graphics.shapes import Drawing, Line, String, Rect, Circle, Polygon from reportlab.graphics import renderPDF -VERSION = '1.8' +VERSION = '1.14' FIRST_RELEASED = 'May 2026' @@ -91,7 +91,7 @@ def diag_pattern_diagram(): 'Domain: codes + Gödel numbers', fontSize=8, fontName='DV', fillColor=GREY_TEXT)) d.add(String(10 + 8, box_y + box_h - 92, - 'Forced by: second recursion theorem', + 'From: second recursion theorem', fontSize=8, fontName='DV', fillColor=GREY_TEXT)) # Right box: ordinal @@ -110,14 +110,9 @@ def diag_pattern_diagram(): 'Domain: ordinals + ω-tower iteration', fontSize=8, fontName='DV', fillColor=GREY_TEXT)) d.add(String(mid + 18, box_y + box_h - 92, - 'Forced by: least fixed-point theorem', + 'From: iterating ω^· from 0 to a supremum', fontSize=8, fontName='DV', fillColor=GREY_TEXT)) - # Caption at bottom - d.add(String(14, 10, - 'Same schema, different domains — no shared machinery between the two.', - fontSize=7.5, fontName='DV-I', fillColor=GREY_TEXT)) - return validate_drawing(d, dh, 'diag_pattern_diagram') @@ -171,13 +166,15 @@ def footer_cb(canvas, doc): E.append(cbody( 'ZP-M is a consolidation layer. Its job is to connect two results that were ' - 'proved separately in ZP-K and ZP-L and show that they are looking at the same ' - 'structure from different angles.')) + 'proved separately in ZP-K and ZP-L, through maps between their types rather than an ' + 'identity across them.')) E.append(cbody( - 'ZP-K carries the computational face of the initial state c₀ (⊥) as a KleeneStructure ' - 'requirement (botCode_is_quine): read as a Kleene fixed point, a program that is its own ' - 'program, with no external executor required. Reading c₀ as the Kleene quine is that ' - 'commitment, not a theorem. ZP-L proved that nothing fires below the ordinal ε₀: ' + 'ZP-K names a code beside the initial state c₀ (⊥ of MachinePhase) as a KleeneStructure ' + 'requirement (botCode_is_quine), a periodicity condition that constant codes also meet. Reading ' + 'c₀ as the Kleene quine, a program that is its own program, splits in two. It is not an equation, ' + 'since a code and a machine state are different types, so that half is retired; that ⊥ of ' + 'MachinePhase runs is the occurrence commitment, and if it runs, nothing outside it runs it (DA-1, ' + 'Path 1). ZP-L proved that nothing fires below the ordinal ε₀: ' 'the tower ω, ω^ω, ω^ω^ω, … approaches ε₀ from below, and ' 'any monotone map that sends tower stages to c₀ also sends every ordinal below ε₀ ' 'to c₀ (snap_threshold_is_epsilon_zero). Firing at ε₀ itself is not forced (the map ' @@ -213,13 +210,19 @@ def footer_cb(canvas, doc): E.append(cbody( 'The map is injective (c₀ and c₁ land in distinct places) and ' 'preserves the algebraic structure: joining c₁ with anything gives c₁, ' - 'and multiplying 0 by anything gives 0. The same absorbing-element pattern ' - 'holds in both types, under different operations.')) + 'and multiplying 0 by anything gives 0. In the die (ZeroParadox/Die.lean), with join as the step on ' + 'the machine states and multiplication as the step on ℤ₂, each is the only point that steps to itself ' + 'and to nothing else, and snapEmbed is a map between those two motions (snapEmbedHom, ' + 'ZeroParadox/Ordinal/Incompleteness.lean §I-b). Along it the role carries over at c₁, because 0 has ' + 'only itself as a successor (snapEmbed_selfOnlyAt_c1), though the map’s back clause fails at c₀, so the general transport does not apply. That relates the two ' + 'occupants by a map; it does not make them one object. Under a self-application map supplied by AbstractSelfApp, ' + 'the occupant on the machine states is c₀, by that class’s fields: which point fills the role depends on the step.')) E.append(cbody( 'The key geometric fact: 0 in ℤ₂ is divisible by every power of 2. ' - 'That is what "infinite 2-adic valuation" means. This is the same mathematical ' - 'signature as ⊥ = {⊥} — a structure that contains itself at every level of ' - 'depth, with no bottom that is not also the top.')) + 'That is what "infinite 2-adic valuation" means, and under doubling 0 is the only point ' + 'that steps to itself and to nothing else (z2_double_selfOnlyAt_iff). The snap step itself does not ' + 'carry over to doubling: c₀ → c₁ goes to 1 → 0, and 0 is not 2 · 1 ' + '(snapEmbed_doubling_noStepAt).')) E.append(sp(6)) @@ -243,8 +246,8 @@ def footer_cb(canvas, doc): 'in ℤ₂ converge to 0 as the ordinal stages approach ε₀.')) E.append(cbody( 'All three edges are theorems, and zpm_triangle assembles them into a single ' - 'formal statement. This is the first place in the framework where the ordinal, ' - 'computational, and 2-adic threads appear in the same proof.')) + 'formal statement. The ordinal, machine-state and 2-adic threads appear in the same proof; ' + 'it has no computational conjunct, and the Kleene reading of c₀ is not part of it.')) E.append(sp(6)) @@ -261,41 +264,43 @@ def footer_cb(canvas, doc): 'ZP-M §II closes this gap. The argument is short: if a map is monotone and ' 'sends ε₀ to c₁, then for any other fixed point α ≥ ε₀, ' 'monotonicity forces the map to agree with c₁ at α (because c₁ absorbs ' - 'every join). The minimality theorem now holds under weaker hypotheses: just ' - 'monotonicity and "snap at ε₀" together imply the full result, without hfp ' - 'as a separate commitment.')) + 'every join). The minimality theorem now holds under weaker hypotheses: ' + 'monotonicity, every tower stage sent to c₀, and "snap at ε₀" together imply the full ' + 'result (snap_unconditional), without hfp as a separate commitment.')) E.append(callout( - 'hfp is not an additional assumption — it is a consequence of the ordinal ' - 'structure plus the alignment condition φ(ε₀) = c₁. The gap in ZP-L is closed.', + 'hfp is not an additional assumption — it is a consequence of monotonicity ' + 'plus the alignment condition φ(ε₀) = c₁ (hfp_from_epsilon_zero). The gap in ZP-L is closed.', bg=GREEN_LITE, border=GREEN )) E.append(sp(6)) # ── §5: The Diagonalization Pattern ─────────────────────────────────────── print('[build_zpm_companion] Building §5...') - E += [hr(), Paragraph('5. One Pattern, Two Domains', CS['h1']), sp(4)] + E += [hr(), Paragraph('5. Two Fixed Points, Two Domains', CS['h1']), sp(4)] E.append(cbody( - 'The deepest result in ZP-M is not a new theorem but a recognition: Kleene\'s ' - 'second recursion theorem (computability) and the construction of ε₀ ' - '(ordinal theory) are the same argument running in different mathematical worlds.')) + 'ZP-M closes by putting two fixed points side by side: the one Kleene\'s ' + 'second recursion theorem gives (computability) and ε₀ (ordinal theory). ' + 'Reading them as one argument running in two mathematical worlds is the framework\'s ' + 'interpretation; the theorem proves less, as below.')) E.append(diag_pattern_diagram()) - E.append(ccaption('The diagonalization schema in two domains: same structure, no shared machinery.')) + E.append(ccaption('Two fixed points in two domains, by two constructions, with no shared machinery.')) E.append(sp(8)) E.append(cbody( - 'In each case: you define an operation that refers to itself, and the framework ' - 'forces a fixed point to exist. In computability theory, the operation refers to ' - 'a program\'s own Gödel number (its address in the code space). In ordinal theory, ' - 'the operation is ω-exponentiation, and the fixed point is the first ordinal that ' - 'the tower cannot exceed. The mechanisms are entirely different. The schema is identical.')) + 'In computability theory, a diagonal argument over a program\'s own Gödel number (its ' + 'address in the code space) gives a code fixed up to evaluation. In ordinal theory, ' + 'iterating ω-exponentiation from 0 and taking the supremum gives ε₀, the first ordinal ' + 'the tower cannot exceed: the fixed-point lemma for normal functions, not a diagonal ' + 'argument. The mechanisms are entirely different.')) E.append(cbody( - 'The theorem both_fixed_points_exist states this directly: both fixed points ' - 'exist, and their proofs live in the same Lean context. This is not a coincidence ' - 'that requires explanation — it is the recognition that diagonalization is a ' - 'structural fact that transcends any particular domain.')) + 'The theorem both_fixed_points_exist records the ordinal fixed point and, on the computability ' + 'side, a code periodic with period its own Gödel number (constant codes also meet that condition, so ' + 'it does not by itself pin self-reference), and the proofs live in the same Lean context. It is a conjunction of two existence proofs over ' + 'different types, a Code and an Ordinal, so it does not show they are one pattern; no ' + 'equation between the two is even well-formed.')) E.append(sp(6)) @@ -304,31 +309,40 @@ def footer_cb(canvas, doc): E += [hr(), Paragraph('6. Remark R-M.1: Where the Frame Ends', CS['h1']), sp(4)] E.append(cbody( - 'ZP-M establishes the diagonalization frame for two of the three threads in ' - 'the DA-1 argument. Path 1 (AFA structural) and Path 3 (Kleene computational) ' - 'are both diagonalization instances — they were carried together in ZP-K as a conjunction ' - 'of witnesses (da1_paths_unified); that they are one structural fact is the framework\'s ' - 'reading. Now both share ' - 'the frame with the ordinal result.')) + 'ZP-M sets two of the three threads in the DA-1 argument beside the ordinal result. ' + 'Path 1 (AFA structural) and Path 3 (incompressibility, whose Lean counterpart is a Kleene field) had their Lean counterparts ' + 'carried together in ZP-K as a conjunction (da1_paths_unified), and Path 3\'s counterpart ' + 'is not a witness of execution; that they are one structural fact, and that they share a ' + 'frame with the ordinal result, is the framework\'s reading.')) E.append(cbody( - 'Path 2 (informational) remains outside this frame. L-INF (ZP-C) says that ' - '⊥ has unbounded information content — no finite description can ' - 'capture it. This is structurally analogous to the diagonalization pattern, ' - 'but the analogy has not been made formal.')) + 'Path 2 (informational) remains outside this frame. It has two charts. Depth chart, ZP-C L-INF: ' + 'surprisal grows without bound with depth in the ball hierarchy, each value finite ' + '(l_inf). Point chart: at 0 of ℚ₂, the one point in every ball of the chain centred at 0, the 2-adic ' + 'additive valuation is ⊤ (padic_addVal_bot), the point to which ZP-C has c₀, ⊥ of the machine-state type, ' + 'correspond. (As of 2026-11-01 no single declared map from the machine-state type into the 2-adic integers ' + 'or numbers sends c₀ to 0: a search of the corpus\'s Lean files for both type names finds snapEmbed and two ' + 'negative examples. A composite of two maps the corpus has does send c₀ to 0 of ℚ₂: an order isomorphism ' + 'onto a two-point type, read there as order shape only, then poleToSphere; that composite is not declared. ' + 'snapEmbed, above, is a different map, sending ' + 'c₀ to 1, and the two are not composed.) ' + 'This is structurally analogous to the Kleene fixed point, but the analogy has not been ' + 'made formal.')) E.append(cbody( 'The reason, visible from ZP-M, is a framework separation: L-INF is a ' 'measure-theoretic result (about probability distributions and Shannon entropy), ' 'while Kleene\'s theorem is a computability-theoretic result (about codes and ' - 'recursive functions). The two use no shared mathematical machinery. The concept ' - 'that bridges them — Kolmogorov complexity, which is simultaneously an ' - 'information-theoretic and computability-theoretic notion — is not yet formalized ' - 'in Mathlib.')) + 'recursive functions). The two use no shared mathematical machinery, and ZP-C keeps ' + 'surprisal and Kolmogorov complexity as two separate arguments (ZP-C Remark R-BRIDGE). Kolmogorov ' + 'complexity is itself both an information-theoretic and a computability-theoretic notion; it was not ' + 'located in the pinned Mathlib as of 2026-10-04, searched as recorded in ' + 'ZeroParadox/Information/Disjunctive.md.')) E.append(callout( 'DA-1 Path 2 is not a missing proof step — it is a genuine framework boundary. ' - 'ZP-M makes the boundary precise: on one side, diagonalization over codes and ' - 'ordinals (in Lean scope). On the other side, the AIT bridge between ' - 'incompressibility and self-execution (outside current Lean scope).', + 'ZP-M makes the boundary precise: on one side, the fixed points over codes and ' + 'ordinals (in Lean scope). On the other side, L-INF, which neither R-M.1 nor ' + 'both_fixed_points_exist links to the Kleene quine, and the step from unbounded surprisal to executing: a bridge ' + 'principle of its own, which the framework does not adopt (ZP-E, DA-1 Path 2).', bg=AMBER_LITE, border=AMBER )) E.append(sp(8)) @@ -345,10 +359,11 @@ def footer_cb(canvas, doc): 'type bridge. ✓', 'both_fixed_points_exist: Kleene and ordinal fixed points co-witnessed ' 'in one formal context. ✓', - 'R-M.1: DA-1 Path 2 boundary made precise — AIT bridge is outside current ' - 'Lean scope; gap is framework separation, not missing proof.', - 'All 9 theorems proved sorry-free. ' - 'Axiom footprint: [propext, Classical.choice, Quot.sound].', + 'R-M.1: DA-1 Path 2 boundary made precise — it does not link L-INF to the ' + 'Kleene quine, and the step from unbounded surprisal to executing is an unadopted bridge ' + 'principle, not a missing proof.', + 'Every theorem proved sorry-free. ' + 'Axiom footprint: at most [propext, Classical.choice, Quot.sound], per declaration in ZP-M.', ] )) E.append(sp(8)) diff --git a/scripts/build_zpn.py b/scripts/build_zpn.py index 41435222..3a580a58 100644 --- a/scripts/build_zpn.py +++ b/scripts/build_zpn.py @@ -1,6 +1,6 @@ """ Zero Paradox — ZP-N: The Constructive Snap PDF Builder -Version 2.5 | October 2026 +Version 2.9 | November 2026 Lean: ConstructiveOrdinals.lean, SnapNucleusConstructive.lean, OrdinalChoiceEssential.lean, PricedInterface.lean. Follows all rules in scripts/PDF_Rendering_Standards.md. @@ -9,7 +9,7 @@ import os from zp_utils import * -VERSION = '2.5' +VERSION = '2.9' FIRST_RELEASED = 'July 2026' @@ -48,27 +48,33 @@ def build(): 'with no Axiom of Choice. But the machinery ZP-L reaches for to state that structure ' 'semantically is not: comparing arbitrary well-orders implies excluded middle. So the choice ' 'is not a mere artifact of how a proof was written. ZP-L’s ε0 results, ' - 'as stated, already carry Classical.choice in their statements (the statement control, ' - 'measured 2026-10-08), so no proof of those statements can drop it. For the ascent below ' + 'as stated, already carry Classical.choice in their statements (the statement controls, ' + 'printed in ZeroParadox/Ordinal/Epsilon0MinMax.lean), so no proof of those statements can ' + 'drop it. For the ascent below ' 'ε0 it is the price of a tool stronger than the job requires: the ascent is ' 'restated choice-free here, on notations. For ε0 itself, a choice-free Lean ' 'restatement of the fixed-point equation and its uniqueness on E0Note exists, with existence ' 'set by definition (E0Note, below); a choice-free derivation in Lean of the fixed point on a ' - 'well-founded carrier, leastness included, was not located as of 2026-10-08 ' + 'well-founded carrier whose statements are choice-free, leastness included, was not located ' + 'as of 2026-10-08, searched again 2026-10-13 ' '(ZeroParadox/Ordinal/SnapNucleus.md, section Axiom footprint, records the search).')) E.append(body( 'So this layer does two things. It rebuilds the ascent syntactically, where it is choice-free. ' 'And it builds a carrier of notations denoting the ordinals up to ε0 — ' 'ordinal notations with one point ' 'adjoined on top — where the crossing into Mathlib’s semantic ordinals is a single ' - 'named map whose cost can be read off directly. Staying on the notation side is free of choice; ' - 'crossing is not; and the crossing is one function rather than a diffuse dependency.')) + 'named map whose cost can be read off directly. On the notation side the comparison, the ' + 'ascent and the carrier’s declarations are free of choice, though well-formedness through ' + 'Mathlib’s NF is not (tower_NF, Section III); crossing is not; and the crossing is one ' + 'function rather than a diffuse dependency.')) E.append(body( 'The move is to work at the level of ordinal notations (ONote, Cantor-normal-form ' 'terms), whose comparison ONote.cmp is choice-free (propext-only) and never passes through ' 'repr into the semantic Ordinal type. ε0 is not itself a notation: the ' 'notations name exactly the ordinals below ε0, and ε0 is their ' - 'limit — the fixed point the notation system cannot reach. So the snap threshold is ' + 'limit: every notation denotes below it (repr_lt_epsilon0, ' + 'ZeroParadox/Ordinal/PricedInterface.lean), and the tower climbs past every notation ' + '(tower_no_upper_bound, ZeroParadox/Ordinal/SnapNucleusConstructive.lean). So the snap threshold is ' 'characterised from below: the tower ascends, and the fixed point (ε0) ' 'is precisely what lies beyond every notation. This layer adds no axiom; it isolates where ' 'choice actually enters the ordinal snap.')) @@ -195,28 +201,34 @@ def build(): 'notations (Section II) uses propext alone.')) E.append(remark_box( - 'Remark: even well-formedness inherits choice (the bridge, made visible)', + 'Remark: even well-formedness inherits choice (through NF’s definition)', [ 'tower_NF — the statement that each tower stage is in normal form — DOES carry ' 'Classical.choice ([propext, Classical.choice, Quot.sound]), because Mathlib’s NF ' 'predicate is defined through repr into Ordinal. The snap facts (Section II) do not depend ' 'on NF, so they stay choice-free; but even “this notation is well-formed” ' 'inherits choice, through NF’s definition. That is one site where choice enters, not ' - 'the only one: ZP-L’s least-fixed-point results are not routed through tower_NF, and ' - 'their choice is carried by their own statements, through Ordinal’s order instance ' - 'and operations (ZeroParadox/Ordinal/SnapNucleus.md § Axiom footprint).', + 'the only one: ZP-L’s least-fixed-point results (epsilon0_min_eq_max and ' + 'epsilon0_eq_nfp_bot, ZeroParadox/Ordinal/Epsilon0MinMax.lean) are not routed through ' + 'tower_NF (their files do not import ZeroParadox/Ordinal/ConstructiveOrdinals.lean, where ' + 'tower_NF is declared), and their choice is carried by their own statements, through ' + 'Ordinal’s order instance and operations (the statement controls ' + 'epsilon0MinMaxStatement and epsilon0EqNfpBotStatement, printed in that file; where the ' + 'choice enters: ZeroParadox/Ordinal/SnapNucleus.md § Axiom footprint).', ] )) E.append(sp(6)) E.append(body( - 'That diagnosis suggests its own remedy: build a carrier of notations denoting the ordinals up ' + 'The diagnosis above, that choice enters through Ordinal’s order instance and the ' + 'operations on it, never through the notations’ own comparison, suggests its own ' + 'remedy: build a carrier of notations denoting the ordinals up ' 'to ε0. E0Note is ordinal ' 'notations with a single point adjoined on top, that point standing for ε0. ' 'Below the top, comparison is the existing syntactic comparator and stays decidable; the map ' 'e0Repr sends the carrier into Mathlib’s Ordinal. Measured, the boundary is priced: the ' 'carrier side’s declarations carry no Classical.choice, and the map carries it at every ' - 'declaration. Staying constructive is free; crossing costs the classical assumption; and the ' + 'declaration. On the carrier, staying constructive is free; crossing costs the classical assumption; and the ' 'crossing is one named function.')) E.append(def_box( @@ -245,7 +257,8 @@ def build(): 'predicate is itself defined through the representation map.', 'The construction is not new. The carrier has the shape of Castéran’s ' 'generic sum of notation systems (hydra-battles, ON_plus — that file carries his name ' - 'alone, though the library as a whole is his and Contejean’s) with a one-point right ' + 'alone, while the library as a whole is the work of the hydra-battles authors) with a ' + 'one-point right ' 'summand, and is not an instance of it: ON_plus sums well-founded notation systems, and this ' 'carrier’s order is not well-founded (the second bullet above). The map is likewise ' 'not an ON_correct member (the bullet above). What is contributed is the measurement.', @@ -260,11 +273,13 @@ def build(): 'from within the notation system (no notation is a fixed point of ' 'x ↦ ωx; the tower climbs without bound). The matching ' 'minimality — that ε0 is the LEAST fixed point of ' - 'x ↦ ωx — is a separate, harder target: it quantifies over the ' + 'x ↦ ωx — is a separate target: it quantifies over the ' 'limit, which no notation names (tower_no_upper_bound; across the crossing, ' 'repr_lt_epsilon0), so it cannot be stated purely syntactically on ONote. ' - 'Leastness is proved on Ordinal (epsilon0_min_eq_max, with choice); a choice-free proof of ' - 'it on a well-founded carrier was not located as of 2026-10-08. What is proved here is the ' + 'Leastness is proved on Ordinal (epsilon0_min_eq_max, with choice); a choice-free derivation of ' + 'it in Lean on a well-founded carrier whose statements are choice-free was not located as ' + 'of 2026-10-08, searched again 2026-10-13 (ZeroParadox/Ordinal/SnapNucleus.md, section Axiom footprint, records the ' + 'search and the defined reading on E0Note). What is proved here is the ' 'from-below half, choice-free.', 'Prior art for leastness, classical: hydra-battles (Coq) proves epsilon0_lfp, that ' 'ε0 is the least fixed point of phi0, its name for x ↦ ωx ' @@ -313,7 +328,9 @@ def build(): 'only — choice-free, and free even of Quot.sound. Proved by structural recursion on ' 'ONote; repr / Ordinal are never touched.', 'Well-formedness (tower_NF): [propext, Classical.choice, Quot.sound] — Classical.choice ' - 'inherited from Mathlib’s NF / repr, which passes through the Ordinal type.', + 'inherited through Mathlib’s NF, defined via repr into Ordinal, whose order instance ' + 'and operations carry it; the type Ordinal itself reports [propext, Quot.sound] ' + '(Section III).', 'The taboo (em_of_wellOrder_comparable): [propext, Quot.sound] — choice-free by ' 'design, because the classical content is the hypothesis rather than the proof. Its ' 'converse (comparable_of_classical) carries Classical.choice, as it must.', @@ -327,9 +344,11 @@ def build(): 'results, as stated, are statement-carried (their statements carry choice); for ' 'ε0 itself, a choice-free Lean restatement of the fixed-point equation and ' 'its uniqueness on E0Note sets existence by definition, and a choice-free derivation in ' - 'Lean of the fixed point on a well-founded carrier, leastness included, was not ' - 'located as of 2026-10-08 (ZeroParadox/Ordinal/SnapNucleus.md, section Axiom footprint). ' - 'Zero sorry. Verified: lake build, October 2026.', + 'Lean of the fixed point on a well-founded carrier whose statements are choice-free, ' + 'leastness included, was not located as of 2026-10-08, searched again 2026-10-13 ' + '(ZeroParadox/Ordinal/SnapNucleus.md, section Axiom footprint).', + 'The footprints listed here are copies; the live record is the #print axioms output of ' + 'each named .lean file.', ] )) E.append(sp(6)) @@ -344,7 +363,9 @@ def build(): 'a carrier of notations denoting the ordinals up to ε0, with the crossing ' 'priced at one named map | ' 'leastness of ε0 is proved on Ordinal (epsilon0_min_eq_max, with choice); ' - 'a choice-free proof of it on a well-founded carrier was not located as of 2026-10-08.', + 'a choice-free derivation of it in Lean on a well-founded carrier whose statements are ' + 'choice-free was not located as of 2026-10-08, searched again 2026-10-13 (ZeroParadox/Ordinal/SnapNucleus.md, ' + 'section Axiom footprint).', S['endnote']), ] diff --git a/scripts/build_zpp.py b/scripts/build_zpp.py index cf952e93..924fc098 100644 --- a/scripts/build_zpp.py +++ b/scripts/build_zpp.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-P: The Fixed-Point Fork PDF Builder -Version 1.26 | October 2026 +Version 1.37 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.26' +VERSION = '1.37' FIRST_RELEASED = 'June 2026' @@ -47,16 +47,20 @@ def build(): 'fixed point. Read intuitively, the least fixed point is the inductive (well-founded) ' 'closure and the greatest is the coinductive (non-well-founded) closure; the collapse ' 'point is where the two closures meet. In the Zero Paradox that point is the diagonal ' - 'fixed point ⊥, the self-containing bottom.')) + 'fixed point, filled by ⊥ of the state semilattice in the Quine-atom role (CC-2), the ' + 'role of a point that steps to itself and to nothing else, whose occupancy is settled chart by chart: under a ' + 'self-application map that fixes ⊥ and nothing else it is the only occupant ' + '(selfApp_quine_role_iff); in Mathlib\'s ZFSet no set occupies the role ' + '(zfset_quine_role_unoccupied).')) E.append(body( 'This layer is a synthesis layer, not a foundational one: it adds no axiom or primitive. ' 'It names a pattern that several existing layers already realise, and it is organised in ' 'three tiers held to three different standards of proof. Tier 1 (Section I) is the ' 'abstract schema, proved in Lean over a complete lattice. Tier 2 (Section II) is the ' 'instance catalogue: each framework forks at its own contact point, and the instances are ' - 'theorems in their home layers. Tier 3 (Section III) is the unification — that the ' - 'contact points are faces of one object — which is a fenced conjecture, never a ' - 'formal claim. The fences in Section III are load-bearing: keeping the tiers separate is ' + 'theorems in their home layers. Tier 3 (Section III) is the unification, stated as a role ' + 'rather than an identity: one role, defined once, against which each chart either has an ' + 'occupant or provably has none, and no equation across charts is claimed. The fences in Section III are load-bearing: keeping the tiers separate is ' 'what makes the formal content honest.')) E.append(hr()) @@ -163,17 +167,20 @@ def build(): 'ZFC+AFA orthogonal-contact-point claim is the set-theory entry: in the standard ' 'category-theoretic characterisation (Aczel; Lambek), Foundation is the initial algebra ' '(μ) and AFA the final coalgebra (ν) of the bounded powerset functor, and the ' - 'Quine atom ⊥ = {⊥} is exactly an element present in ν but not in μ.')) + 'Quine atom (CC-2), a set equal to its own singleton, x = {x}, is exactly an element present in ' + 'ν but not in μ. No equation identifies it with ⊥ of a ZPSemilattice; the two are ' + 'measured against the Quine-atom role of Section III.')) E.append(data_table( headers=['Domain', 'The two closures fork into', 'Contact point / home layer'], rows_data=[ ['Set theory', 'Foundation (μ, well-founded) vs AFA (ν, non-well-founded)', - 'Quine atom ⊥ = {⊥}; ZP-J / ZP-K'], + 'Quine atom (CC-2), x = {x}; ZP-J / ZP-K'], ['Number systems', 'Archimedean ℝ vs non-Archimedean ℚp', - '0 (snap fails in ℝ, holds in ℚ2); ZP-B / ZP-F'], + '0: in ℝ no first step above it (AX-B1\'s form); ℚ2 removes the ' + 'topological obstruction to an irreversible step (c3_irreversible, a case of Mathlib’s TotallyDisconnectedSpace.eq_of_continuous: in ℚ2 no continuous path joins any two distinct points, so the step out from 0 is blocked as well) and supplies no first step; ZP-B / ZP-F'], ['Computation', 'total (well-founded) vs partial (non-terminating)', 'the Kleene quine / self-application; ZP-K'], @@ -190,9 +197,18 @@ def build(): 'Ostrowski\'s theorem says the nontrivial absolute values on ℚ are exactly the real ' '(Archimedean) one and the p-adic (non-Archimedean) ones — the complete, ' 'pairwise-inequivalent list. The contact point is 0: in the Archimedean completion ' - 'ℝ it is approached but never reached (density — the snap fails), while in ' - 'the 2-adic completion ℚ2 it is the unique fixed point of x ↦ 2x ' - 'and its valuation diverges (v2(0) = ∞ — the snap holds).')) + 'ℝ, a densely ordered field, 0 has no first step above it, AX-B1\'s form ' + '(f_snap_impossible, which, despite its name, states that no linearly ordered field has a ' + 'least positive element). In the 2-adic completion ℚ2, 0 is the unique ' + 'fixed point of x ↦ 2x (q2_unique_fp) and the only point of infinite valuation ' + '(v2(0) = ∞, padic_addVal_eq_top_iff); ℚ2 is totally disconnected (padic_snaps, an instance Mathlib already supplies), ' + 'which removes the topological obstruction to an irreversible step (c3_irreversible: no continuous ' + 'path in ℚ2 from a nonzero point to 0) and supplies no first step: under the norm ' + 'preorder 0 is least and has no first step (ZeroParadox/BottomCannotBe.lean § ROLE), ' + 'and on ℤ2, the 2-adic integers, 0 is least in the norm preorder and ' + 'greatest in the valuation order (z2_two_views). T-SNAP\'s shape needs no first step: ' + 't_snap_given holds at a step taken in a densely ordered join-semilattice (ℚ≥0 under ' + 'max, whose ⊥ is 0; ZeroParadox/Order/Snap.lean).')) E.append(result_box( 'Theorem: completions_exhaustive (Ostrowski.lean)', @@ -310,8 +326,25 @@ def build(): 'The tempting claim is that the contact points of all the instances — the Quine ' 'atom, the 2-adic 0, the Kleene quine, the self-referential element of the final ' 'coalgebra — are faces ' - 'of one object, the diagonal fixed point. ZP-P states this as a conjecture and fences it ' - 'precisely. The fences are not hedging; they mark a genuine boundary, and per-instance ' + 'of one object, the diagonal fixed point. ZP-P does not state that identity. It states ' + 'what the contact points are measured against as a role, defined once in the corpus’s shared ' + 'vocabulary of step relations (ZeroParadox/Die.lean, called the die; each carrier with its own ' + 'step relation is a chart): ' + 'the Quine-atom role, a point that steps to itself and to nothing else (Motion.SelfOnlyAt). ' + 'Each chart either has an occupant or provably has none, and each is a theorem: the ' + 'self-referential element of the final coalgebra occupies it (cofix_quine_role_occupied), ' + 'no well-founded set does (zfset_quine_role_unoccupied), on the 2-adic integers 0 is the only ' + 'occupant under doubling (z2_double_selfOnlyAt_iff), ⊥ is the only occupant ' + 'under a self-application map on a semilattice, given as an AbstractSelfApp instance ' + '(selfApp_quine_role_iff), and on Kleene\'s codes, stepping from a code ' + 'to the codes whose output is what a map assigns it, no single code ' + 'occupies it while, for a computable map respecting equal output, some class of codes up to ' + 'equal output does (codes_vs_classes). Under a function step, occupying the role is being a ' + 'fixed point (Motion.selfOnlyAt_ofFun_iff), so the 2-adic and self-application rows restate ' + 'their fixed points; the self-application row holds by the AbstractSelfApp class fields, so the ' + 'constant map to ⊥ satisfies it too. The ' + 'final-coalgebra chart has one point, so its occupancy restates its fork and adds nothing ' + 'further. The fences are not hedging; they mark a genuine boundary, and per-instance ' 'forks remain full theorems on either side of them.')) E.append(def_box( @@ -322,8 +355,10 @@ def build(): 'Kleene quine (a code), and an element of a final coalgebra (an object up to ' 'isomorphism) are terms of different types in different categories. The proposition ' '"x = y" across them is not false — it is not well-formed. So this is a type ' - 'boundary, not a missing proof. What is claimed formally is only that each framework ' - 'forks at its own contact point.', + 'boundary, not a missing proof, and no such identity is committed to either. What ' + 'relates the instances is the one role each chart is measured against. What is ' + 'claimed formally is that each framework forks at its own contact point, and which ' + 'charts have an occupant of the role.', ] )) E.append(sp(6)) @@ -388,7 +423,9 @@ def build(): 'is choice-free [propext, Quot.sound]; cofix_nonempty (ν inhabited) carries ' 'Classical.choice from the QPF corecursion machinery (the quotient layer).', 'Core choice-free, realisation choice-carrying — the framework\'s standing ' - 'pattern. Zero sorry. Verified: lake build, August 2026.', + 'pattern.', + 'The footprints listed here are copies; the live record is the #print axioms output of ' + 'each named .lean file.', ] )) E.append(sp(6)) @@ -399,8 +436,11 @@ def build(): 'End of ZP-P | The Fixed-Point Fork | fork_collapse_iff (choice-free spine) | ' 'Ostrowski number-system instance | categorical μ/ν instance ' '(Fix empty / Cofix inhabited) | hard fence: cross-instance identity is a type ' - 'boundary | soft fence: not every fork is μ/ν | ' - 'All FixedPointFork.lean / Ostrowski.lean / Coalgebra.lean theorems verified.', + 'boundary; what relates the instances is one role, which a point of each chart occupies or provably none does | ' + 'soft fence: not every fork ' + 'is μ/ν | ' + 'All FixedPointFork.lean / Ostrowski.lean / Coalgebra.lean theorems verified; the role ' + 'occupancies of Section III are verified at the declarations Section III names.', S['endnote']), ] diff --git a/scripts/build_zpq.py b/scripts/build_zpq.py index a57137c6..0d64dbb2 100644 --- a/scripts/build_zpq.py +++ b/scripts/build_zpq.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-Q: The Frame-Change PDF Builder -Version 1.13 | October 2026 +Version 1.25 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.13' +VERSION = '1.25' FIRST_RELEASED = 'July 2026' from reportlab.graphics.shapes import Drawing, Circle, Ellipse, PolyLine, String, Polygon @@ -61,7 +61,7 @@ def sphere_figure(): d.add(Circle(cx, cy - R, 4, fillColor=c0, strokeColor=c0)) # labels (Unicode direct, per the diagram standards) d.add(String(cx, cy + R + 8, '∞', fontName='DV', fontSize=13, fillColor=cI, textAnchor='middle')) - d.add(String(cx, cy - R - 14, '0 = ⊥', fontName='DV', fontSize=11, fillColor=c0, textAnchor='middle')) + d.add(String(cx, cy - R - 14, '0 = ⊥ of Q₂ (2-adic norm)', fontName='DV', fontSize=11, fillColor=c0, textAnchor='middle')) d.add(String(cx + R + 6, cy - 2, 'seam ‖x‖ = 1', fontName='DV', fontSize=8.5, fillColor=cmut, textAnchor='start')) d.add(String(cx - 14, cy - 60, 'one way ↓', fontName='DV', fontSize=8.5, fillColor=c0, textAnchor='start')) d.add(String(cx - 96, cy + 2, 'z → 1/z', fontName='DV', fontSize=8.5, fillColor=cI, textAnchor='start')) @@ -84,11 +84,11 @@ def build(): Paragraph(version_line(FIRST_RELEASED, VERSION), S['subtitle']), Paragraph( 'Synthesis layer, the sequel to ZP-P. The abstract frame-flip schema is proved ' - 'sorry-free and choice-free in Lean 4 (ForkFrameChange.lean); the per-domain realizations ' - 'are witnessed in their home layers (the valuation instance — the Riemann sphere ' - '— in SnapFrameChange.lean / RiemannSphere.lean; the categorical instance in ' - 'SeamFrameChange.lean). The universal cross-category identity is not a theorem — it ' - 'meets a proven wall (Cantor; Lawvere.lean). Adds no axiom; the bottom itself is never ' + 'sorry-free and choice-free in Lean 4 (ZeroParadox/Settheory/ForkFrameChange.lean); the per-domain realizations ' + 'are witnessed in their home layers (the valuation face — the Riemann sphere ' + '— in ZeroParadox/Multihomed/SnapFrameChange.lean / ZeroParadox/Valuation/RiemannSphere.lean; the categorical face in ' + 'ZeroParadox/Category/SeamFrameChange.lean). The universal cross-category identity is not a theorem — it ' + 'meets a proven wall (Cantor; ZeroParadox/Category/Lawvere.lean). Adds no axiom; the bottom itself is never ' 'positively represented.', S['note']), sp(10), @@ -105,10 +105,11 @@ def build(): 'way and reverses only under an inversion that swaps the two poles. These are not two facts. ' 'They are two faces of one self-dual object, and the inversion is the frame-change. ' 'The frame-change is that pole exchange — ⊥ being read as both 0 and ∞. Whether ' - 'the snap is an instance of it is the layer’s open conjecture. The snap is one ' - 'covering step off the zero face ' - '(⊥ ⋖ a, HasFirstStep), which is AX-B1, a modelling commitment; the frame-change is an ' - 'involution and is proved. Merging the two is what makes it look paradoxical that a frame-change ' + 'the snap is an instance of it is the layer’s open conjecture. The snap, T-SNAP’s ' + 'shape, is a join step off ⊥ of the state semilattice to a different state (t_snap_given); ' + 'that the step is a cover, ⊥ ⋖ a (HasFirstStep), is AX-B1’s first-step form, a ' + 'modelling commitment and a further hypothesis (t_snap_given_cover) that MachinePhase supplies ' + 'and ℚ≥0 does not; the frame-change is an involution and is proved. Merging the two is what makes it look paradoxical that a frame-change ' 'reverses while the snap does not, and that reversibility mismatch is exactly what an ' 'identification would have to resolve. ZP-Q holds it open rather than settling it either way. ' 'Read from one frame the frame-change is a bridge (it joins the poles continuously); ' @@ -119,8 +120,8 @@ def build(): 'Like ZP-P, this is a synthesis layer, organised in three tiers held to three standards of ' 'proof. Tier 1 (Section I) is the abstract schema, proved in Lean over a complete lattice: it ' 'extends ZP-P’s fork with its second face, the order-duality that swaps the two ' - 'closures. Tier 2 (Section II) is the instance catalogue: each domain’s frame-change is ' - 'a theorem in its home layer, and the valuation instance is the framework’s originating ' + 'closures. Tier 2 (Section II) is the face catalogue: each domain’s frame-change is ' + 'a theorem in its home layer, and the valuation face is the framework’s originating ' 'figure, the p-adic Riemann sphere. Tier 3 (Section III) is the universal form and its walls: ' 'the order-theoretic universal holds, the categorical (Lawvere) universal is a proven wall, ' 'and the cross-domain identity is a type boundary. The fences in Section III are load-bearing ' @@ -128,16 +129,18 @@ def build(): E.append(remark_box( 'A note on what is drawn', [ - 'ZP-Q characterises the bottom apophatically, and the register is itself frame-relative. ' + 'ZP-Q characterises the bottom apophatically (by what it is not, never by a positive ' + 'construction), and the register is itself frame-relative. ' 'Seen from outside — from any frame that looks at ⊥ — there is no ' 'interior: nothing sits behind the description waiting to be opened. The boundary is the ' 'whole of it. ⊥ is the seam the frame-change joins, or the tear it leaves, a ' - 'boundary of measure zero, all edge and no inside (read flat, this is the Quine atom ' - '⊥ = {⊥} from without — a single node, not a region — and the ' + 'boundary of measure zero, all edge and no inside (read flat, this is the Quine atom (CC-2) ' + 'from without, the occupant of the role "steps to itself and to nothing else" ' + 'under a self-application map supplied by AbstractSelfApp (selfApp_quine_role_iff) — a single node, not a region — and the ' 'tear on the sphere — a discontinuity, not a region).', 'Seen from ⊥’s own frame — inside the self-reference — the same ' 'point is the opposite: infinite depth. v2(0) = ∞; the endless regress ' - '⊥ ∈ ⊥ ∈ ⊥; unbounded surprisal. No-interior and ' + 'Q ∈ Q ∈ Q … of the AFA set Q = {Q} that plays the role; unbounded surprisal. No-interior and ' 'infinite-interior are the 0 ↔ ∞ poles of one coin, swapped by the ' 'frame-change: what has no thickness from without has nothing but depth from within. So ' 'the bottom is not an object behind the boundary — it is the boundary, whose own ' @@ -164,7 +167,7 @@ def build(): 'z ↦ 1/z, the categorical op-duality, lattice complementation.')) E.append(def_box( - 'Definition: the frame-change (ForkFrameChange.lean)', + 'Definition: the frame-change (ZeroParadox/Settheory/ForkFrameChange.lean)', [ 'For a complete lattice α and a monotone self-map f : α → α:', ' the two charts are lfp f (μ, the well-founded closure) and gfp f (ν, the ' @@ -224,18 +227,18 @@ def build(): )) E.append(sp(6)) - # ── Section II: The Instance Catalogue (Tier 2) ─────────────────────────────── + # ── Section II: The Face Catalogue (Tier 2) ─────────────────────────────── print('[build_zpq] Building Section II...') E += [ hr(), - Paragraph('Section II: The Instance Catalogue (Tier 2)', S['h1']), + Paragraph('Section II: The Face Catalogue (Tier 2)', S['h1']), hr(), ] E.append(body( 'The same frame-flip appears across the framework, each domain realising it with its own ' - 'concrete involution. ZP-Q does not re-prove each instance — each is a theorem in its ' - 'home layer — it records the catalogue and pins the two instances with a full ' + 'concrete involution. ZP-Q does not re-prove each face — each is a theorem in its ' + 'home layer — it records the catalogue and pins the two faces with a full ' 'frame-flip (valuation, category) to their Lean witnesses. The two poles of each row are the ' 'two charts; the frame-change is the involution that swaps them.')) @@ -243,7 +246,7 @@ def build(): headers=['Domain', 'The two poles (charts)', 'Frame-change — witness'], rows_data=[ ['Valuation', - '0 = ⊥ ↔ ∞', + '0 = ⊥ of Q2 (2-adic norm) ↔ ∞', 'z ↦ 1/z (rInv) — snap_is_frameflip'], ['Category', 'initial (μ) ↔ terminal (ν)', @@ -261,8 +264,9 @@ def build(): 'measure 0 ↔ surprisal ∞', '−log — info_bottom_diverges'], ['Reals', - '— (no discrete floor)', - 'inversion breaks at 0 — NO-GO (ZP-F)'], + '0 ↔ ∞ (no first step above 0)', + 'x ↦ 1/x on the one-point compactification — onePointInv_swaps_real; ' + 'holds, and is not a discriminator (the remark below)'], ], col_widths=[TW * 0.20, TW * 0.34, TW * 0.46], )) @@ -270,11 +274,13 @@ def build(): E.append(body( 'The valuation realization is the originating figure of the framework: the p-adic Riemann ' - 'sphere. Under the tower-rank encoding (P8.lean) the ω-tower climbing to ' - 'ε0 has stage-encodings that converge to the 2-adic floor 0 = ⊥ — so in ' - 'that chart the ascent to ε0 resolves back onto the floor (the encodings converge ' - 'to ⊥; ε0 ≠ ⊥). Viewed through the inversion rInv (the one-point ' - 'compactification of ℚ2, RiemannSphere.lean), the same encodings diverge to ' + 'sphere. Under the tower-rank encoding (ZeroParadox/Ordinal/P8.lean) the ω-tower climbing to ' + 'ε0 has stage-encodings that converge to ℤ[2]\'s 0 ' + '(cnf_encode_tower_tendsto_zero), least under the 2-adic norm and greatest under the 2-adic ' + 'valuation — so in that chart, read by the norm, the ascent toward ε0 ' + 'resolves back onto the floor (the encodings converge to 0; ε0 has no encoding, ' + 'and ε0 ≠ ⊥ of Ordinal, epsilon0_ne_bot). Viewed through the inversion rInv (the one-point ' + 'compactification of ℚ2, ZeroParadox/Valuation/RiemannSphere.lean), the same encodings diverge to ' '∞. rInv is the homeomorphism that swaps the poles 0 ↔ ∞.')) E.append(sp(6)) @@ -282,7 +288,8 @@ def build(): _fig.hAlign = 'CENTER' E.append(_fig) E.append(ccaption( - 'Figure 1. The p-adic Riemann sphere. The poles 0 = ⊥ (the floor) and ∞ (the ' + 'Figure 1. The p-adic Riemann sphere. The poles 0 = ⊥ (the floor, least under the ' + '2-adic norm) and ∞ (the ' 'ceiling) are antipodal; the equator ‖x‖ = 1 is the seam. Inside ' 'ℤp (the lower hemisphere) the ω-tower falls one way to 0; the ' 'inversion z → 1/z (rInv) swaps the poles 0 ↔ ∞ — continuous on the ' @@ -290,15 +297,17 @@ def build(): E.append(sp(8)) E.append(result_box( - 'Theorem: snap_is_frameflip (SnapFrameChange.lean)', + 'Theorem: snap_is_frameflip (ZeroParadox/Multihomed/SnapFrameChange.lean)', [ 'The one ω-tower’s encodings have two limits, one per chart: they fall to the ' - 'floor 0 = ⊥ in the encoding chart (converging to the floor itself — the SAME 0 they ' - 'started from, not a new one, ' - 'cnf_encode_tower_tendsto_zero), and rise to the antipode ∞ in the rInv chart ' + 'floor 0 of ℤ[2] in the encoding chart, read by the 2-adic norm ' + '(cnf_encode_tower_tendsto_zero; cnf_encode takes the values 2k and never starts ' + 'at 0, so the return to the SAME 0 the arc started from is a fact about the other encoding, ' + 'cnfToZp2: tower_image_loops_to_seed, snap_arc_z2_loop), and rise to the antipode ∞ in the rInv chart ' '(snap_frameflip_tower_tendsto_infty), with rInv the frame-change swapping the poles ' - '(rInv_swaps: 0 ↔ ∞). The encodings converge to ⊥; ε0 ≠ ⊥.', - 'The descent to ⊥ and the ascent to ∞ are the same tower-encodings under the ' + '(rInv_swaps: 0 ↔ ∞). The encodings converge to 0; ε0 ≠ ' + '⊥ of Ordinal (epsilon0_ne_bot).', + 'The descent to 0 and the ascent to ∞ are the same tower-encodings under the ' 'frame-change — the valuation-frame realisation of the BOTTOM’s two chart-readings. ' 'Note the scope: no snap transition appears in this statement (no c₀ → c₁, no ' '⊥ ⋖ a). The declaration handle snap_is_frameflip is retained for cross-reference ' @@ -325,14 +334,14 @@ def build(): E.append(sp(6)) E.append(result_box( - 'Theorem: catseam_is_frameflip (SeamFrameChange.lean)', + 'Theorem: catseam_is_frameflip (ZeroParadox/Category/SeamFrameChange.lean)', [ 'The zero-object seam Z = fD_functor.obj 0 is the μ-bottom (initial) in one chart ' 'and the ν-top (terminal) in the other; the op-duality frame-change swaps the two ' '— carrying Z’s initial-ness to a terminal-ness of Zop and its ' 'terminal-ness to an initial-ness of Zop (terminalOpOfInitial / ' 'initialOpOfTerminal). The seam is the op-self-dual zero object.', - 'Off the zero object the coincidence fails (SeamLimColim.lean: ' + 'Off the zero object the coincidence fails (ZeroParadox/Category/SeamLimColim.lean: ' 'generic_object_empty_lim_ne_colim) — as with 0 on the sphere, the frame-change ' 'fixes only the bottom.', 'Lean purity: [propext, Classical.choice, Quot.sound] — choice-carrying ' @@ -343,10 +352,19 @@ def build(): E.append(body( 'The remaining realizations are referenced, not re-proved here. Set theory: the Quine atom ' - '⊥ = {⊥} is the collapse of the Foundation / AFA fork (ZP-J, ZP-P; ' - 'fork_collapse_iff, selfMem_eq_singleton_bot). Computability: ZP-K carries the bottom\'s ' - 'computational face as a KleeneStructure requirement (botCode_is_quine); reading the bottom ' - 'as the Kleene quine is that commitment, not a theorem. That the bottom is the unique fixed ' + '(CC-2) is the collapse of the Foundation / AFA fork (ZP-J, ZP-P; fork_collapse_iff, ' + 'selfMem_eq_singleton_bot), stated as a role, a point that steps to itself and to nothing ' + 'else, whose occupancy is settled chart by chart, with no equation across charts: occupied by ⊥ in the lattice chart, ' + 'under a self-application map supplied by AbstractSelfApp (selfApp_quine_role_iff) and in the ' + 'QuineAtomHost an AFAStructure on L builds (quineAtomHost_quine_role_iff with ' + 'afaStructure_isQuineAtomHost), by no set in Mathlib\'s ZFSet ' + '(zfset_quine_role_unoccupied). Computability: ZP-K\'s class KleeneStructure requires a code ' + 'meeting a periodicity condition (botCode_is_quine) and equates it with nothing. The reading ' + 'that this code is the bottom\'s computational witness splits: its identity half is retired ' + '(no single code occupies the Quine-atom role under the eval step, ' + 'evalStepMotion_not_selfOnlyAt, while a class of codes up to equal eval does, for a ' + 'computable map respecting equal eval, codes_vs_classes), and its running half, that the bottom executes, is the occurrence ' + 'commitment. That the bottom is the unique fixed ' 'point of self-application is the AbstractSelfApp class field unique_fp (ZP-J), a requirement ' 'rather than a theorem. State / Hilbert: ⊥ is the ' 'unique finite-dimensional fixed point of the biproduct-diagonal X ↦ X ⊞ X (ZP-H; ' @@ -354,15 +372,27 @@ def build(): 'runs to ∞ (ZP-C; info_bottom_diverges, addVal_bot), the two joined by −log.')) E.append(remark_box( - 'Remark: the reals are the counterexample (the discriminator)', + 'Remark: the reals beside ℚ2 (what separates them)', [ - 'The real numbers are where the frame-change fails, and that is exactly what makes this ' - 'a diagnostic rather than a pattern read into every domain. ℝ has no discrete ' - 'floor to fall to (density), and its inversion is discontinuous at 0 with no repair. ' - 'Both features of the bottom — the infinitude at the zero and the one-way arrow ' - 'that reverses under inversion — are absent, and the snap fails (ZP-F). The ' - 'frame-flip is present precisely where the snap lives and absent precisely where it ' - 'does not.', + 'Inversion does not separate ℝ from ℚ2. Inside each field it is ' + 'discontinuous at 0. On the one-point compactification of any proper normed field it is ' + 'continuous and swaps 0 and ∞, a standard fact for the Riemann sphere (Forster, Lectures ' + 'on Riemann Surfaces, GTM 81, §§ 1–2, as cited by TauCeti; not retrieved), which ' + 'TauCeti formalizes for proper nontrivially normed fields: OnePoint.invChart (a chart) and ' + 'OnePoint.instContinuousConstSMul (the global action). It is proved ' + 'here with Mathlib alone (continuous_onePointInv, onePointInv_swaps, ' + 'ZeroParadox/Valuation/RiemannSphere.lean), so for ℝ as well as ℚ2 ' + '(continuous_onePointInv_real, onePointInv_swaps_real; for ℚ2, the sphere ' + 'above, continuous_rInv and rInv_swaps). What ' + 'separates the two is topology: ℝ is connected (place_topological_signature), so not ' + 'totally disconnected (real_no_snap), while ℚ2 is totally ' + 'disconnected (padic_snaps). Neither has a first step above 0, AX-B1’s form: in ' + 'ℝ because no linearly ordered field has a least positive element (ZP-F; ' + 'f_snap_impossible, which, despite its name, states exactly that), and in ' + 'ℚ2, which carries no order of its own, under the norm preorder ' + '(ZeroParadox/BottomCannotBe.lean § ROLE). T-SNAP’s shape does not need a ' + 'first step: t_snap_given holds at a step taken in a densely ordered join-semilattice ' + '(ℚ≥0 under max, ZeroParadox/Order/Snap.lean).', ] )) E.append(sp(6)) @@ -383,12 +413,14 @@ def build(): 'satisfies its hypotheses of a complete lattice and a monotone map, so none of them is an instance ' 'of it. It is universal over its own domain, not over the faces. At the categorical level the ' 'universal is a proven wall (below). What the faces share is a SHAPE realized concretely in each ' - 'domain, and the instance table’s last row — the reals, NO-GO — shows the shape ' - 'does not hold everywhere either. The fences are not hedging; they mark a genuine boundary, and ' - 'the per-domain frame-flips remain full theorems on either side of it.')) + 'domain. The face table’s last row, the reals, carries the same pole exchange on its ' + 'one-point compactification (onePointInv_swaps_real) and has no first step above 0 ' + '(f_snap_impossible), so the frame-flip does not separate ℝ from ℚ2; ' + 'total disconnectedness does (padic_snaps, real_no_snap). The two walls are not hedging: they mark ' + 'where the universal form stops, and each per-domain frame-flip remains a full theorem in its own domain.')) E.append(def_box( - 'The wall: the categorical universal is category-relative (Lawvere.lean)', + 'The wall: the categorical universal is category-relative (ZeroParadox/Category/Lawvere.lean)', [ 'Lawvere’s fixed-point theorem derives a fixed point from a point-surjection ' 'α → (α → β). ZP asks whether each bottom is such a ' @@ -399,7 +431,7 @@ def build(): 'literal Lawvere instances. Only in the effective category is there a genuine ' 'one, where the fixed-point-free diagonal construction is not admissible ' '— which is not the claim that no fixed-point-free computable endomap exists, since ' - 'c ↦ pair(c, c) is one; removing the obstruction does not by itself supply the ' + 'fun c => Code.pair c c is one (code_pair_diag_fixedPointFree); removing the obstruction does not by itself supply the ' 'witness, and the fixed point is cited rather than derived ' '(computability_face_fixedPoint). So the keystone ' 'unifies a shape, not a single mechanism.', @@ -410,7 +442,7 @@ def build(): E.append(def_box( 'Hard fence (permanent): cross-domain identity is a type boundary', [ - 'The claim that the contact points of all the instances — the p-adic 0, the Quine ' + 'The claim that the contact points of all the faces — the p-adic 0, the Quine ' 'atom, the Kleene quine, the categorical zero object — are numerically one object ' 'is not a theorem and cannot become one. Identity requires a shared type; these are ' 'terms of different types in different categories, so “x = y” across them is ' @@ -430,7 +462,7 @@ def build(): 'be nothing to cross. So the boundary is not the price of the connection — it is its ' 'condition. The keystone is bounded by the exact mechanism it is built from: the diagonal ' 'argument makes the fixed point and, in the same gesture, forbids its universal ' - 'identification. Per-instance frame-flips are theorems and are not hedged; the fences scope ' + 'identification. Per-face frame-flips are theorems and are not hedged; the fences scope ' 'only the universal cross-category claim.', bg=BLUE_LITE, border=BLUE )) @@ -453,6 +485,8 @@ def build(): ['fork_collapse_iff', 'ZeroParadox/Settheory/FixedPointFork.lean', 'choice-free'], ['snap_is_frameflip', 'ZeroParadox/Multihomed/SnapFrameChange.lean', 'Classical.choice'], ['rInv_swaps', 'ZeroParadox/Valuation/RiemannSphere.lean', 'Classical.choice'], + ['onePointInv_swaps', 'ZeroParadox/Valuation/RiemannSphere.lean', 'Classical.choice'], + ['onePointInv_swaps_real', 'ZeroParadox/Valuation/RiemannSphere.lean', 'Classical.choice'], ['catseam_is_frameflip', 'ZeroParadox/Category/SeamFrameChange.lean', 'Classical.choice'], ['nontrivial_lattice_no_witness', 'ZeroParadox/Category/Lawvere.lean', 'Classical.choice'], ['computability_face_fixedPoint', 'ZeroParadox/Category/Lawvere.lean', 'Classical.choice'], @@ -464,19 +498,21 @@ def build(): E.append(axiom_box( 'Axiom Purity', [ - 'Frame-flip schema (ForkFrameChange.lean): [propext, Quot.sound] — choice-free. The ' + 'Frame-flip schema (ZeroParadox/Settheory/ForkFrameChange.lean): [propext, Quot.sound] — choice-free. The ' 'universal needs no Axiom of Choice; the duality-swap is definitional.', - 'Valuation instance (SnapFrameChange.lean / RiemannSphere.lean): [propext, ' + 'Valuation face (ZeroParadox/Multihomed/SnapFrameChange.lean / ZeroParadox/Valuation/RiemannSphere.lean): [propext, ' 'Classical.choice, Quot.sound] — Classical.choice inherited from the p-adic / ' 'one-point-compactification analysis.', - 'Categorical instance (SeamFrameChange.lean): [propext, Classical.choice, Quot.sound] ' + 'Categorical face (ZeroParadox/Category/SeamFrameChange.lean): [propext, Classical.choice, Quot.sound] ' '— inherited from the ModuleCat / category-theory library.', - 'The wall (Lawvere.lean): the concrete Cantor no-witness results ' + 'The wall (ZeroParadox/Category/Lawvere.lean): the concrete Cantor no-witness results ' '(nontrivial_lattice_no_witness, q2_no_witness) and computability_face_fixedPoint ' '(Kleene\'s recursion theorem) carry Classical.choice; the abstract witness machinery ' '(fixedPoint_of_witness, no_witness_of_fixedPointFree) is axiom-free.', 'Core choice-free, realisation choice-carrying — the framework’s standing ' - 'pattern. Zero sorry. Verified: lake build, July 2026.', + 'pattern.', + 'The footprints listed here are copies; the live record is the #print axioms output of ' + 'each named .lean file.', ] )) E.append(sp(6)) @@ -488,7 +524,7 @@ def build(): 'universal) | the Riemann-sphere valuation face (snap_is_frameflip) and the ' 'op-duality categorical face (catseam_is_frameflip), neither an instance of it | the ' 'categorical universal is a ' - 'proven wall (Cantor; Lawvere.lean) | the fence is the bridge | the bottom is never ' + 'proven wall (Cantor; ZeroParadox/Category/Lawvere.lean) | the fence is the bridge | the bottom is never ' 'positively represented.', S['endnote']), ] diff --git a/scripts/build_zpr.py b/scripts/build_zpr.py index 4bc7f477..b91f078b 100644 --- a/scripts/build_zpr.py +++ b/scripts/build_zpr.py @@ -1,13 +1,13 @@ """ Zero Paradox — ZP-R: A Cross-Category Account of the Self-Referential Fixed Point — PDF Builder -Version 1.20 | October 2026 +Version 1.27 | November 2026 Follows all rules in scripts/PDF_Rendering_Standards.md. """ import os from zp_utils import * -VERSION = '1.20' +VERSION = '1.27' FIRST_RELEASED = 'July 2026' @@ -36,7 +36,7 @@ def build(): 'D∞ and its generalizations) 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 first finite stage of Soto-Andrade and Varela\'s ' - 'two-element example; Trimble; Bergman), and realized in the computability face ' + 'two-element example; Trimble; Bergman; stated there for order-preserving maps, ours for any map), and realized in the computability face ' '(Rogers / Kleene). Every theorem used is classical. Each result box (R1–R4) and each ' 'F1 property is backed by a machine-checked Lean 4 theorem, except one marked cited: that ' 'the computability fixed point is an instance of Lawvere\'s theorem. The rest is cited ' @@ -53,7 +53,9 @@ def build(): E.append(body( 'A recurring role in this framework is a fixed point of self-application — ' '"self-referential" in the sense of being defined by pointing at itself. Its occupants differ ' - 'by face: a self-containing set (⊥ of an AFA lattice, ⊥ = {⊥}) and a ' + 'by face: ⊥ of an AFA lattice, the occupant there of the Quine-atom role (a point that ' + 'steps to itself and to nothing else; quineAtomHost_quine_role_iff, for the host built from ' + 'the AFA structure), and a ' 'program equal to its own transform up to evaluation (a Kleene code). This document asks one checkable question: is a fixed point in that role an ' 'instance of Lawvere\'s fixed-point theorem (Lawvere 1969) — the ' 'categorical statement behind the diagonal arguments of Cantor, Russell, Gödel and Tarski, ' @@ -77,7 +79,8 @@ def build(): 'placement uses: that a fixed-point-free endomap of an object Y rules out, for every A, a ' 'point-surjection A → YA is Lawvere\'s Corollary 1.2 (p. 5 of the 2006 TAC ' 'reprint). Of the suggestion of Soto-Andrade and Varela (1984, pp. 1 and 18) ' - 'that every structure with the fixed point property is a retract of a reflexive ' + 'that every structure with the fixed point property (in the order and category sense used ' + 'throughout ZP-R: every endomap of the structure has a fixed point) is a retract of a reflexive ' 'domain, ZP-R answers the question only in Set, where it holds trivially (Section II), and ' 'makes no claim about the categories they intend.')) E.append(hr()) @@ -212,7 +215,8 @@ def build(): 'follows their remark that the converse of Lawvere\'s theorem fails for lattices with ' 'monotone maps; it is the case Y = 2 of Trimble\'s Cantor theorem for posets, that no poset ' 'map Y → 2Y is surjective, and the case P = 2 of Bergman\'s Corollary 7 ' - '(2008), that no isotone map from a poset to its lattice of downsets is surjective (both ' + 'of arXiv:0801.0751 (Corollary 3.2 in the 2008 journal version), that no isotone map from a ' + 'poset to its lattice of downsets is surjective (all three ' 'there for order-preserving maps; the Lean example allows any map, by counting two points ' 'against three monotone self-maps). A related question, about retracts rather than ' 'reflexive objects, is the suggestion of Soto-Andrade and Varela (1984, pp. 1 and 18) ' @@ -254,8 +258,8 @@ def build(): 'Witnesses: monotone_regime_derives_pinned (LawvereBridge.lean), for the fork; the last ' 'anonymous example of LawvereBridge.lean § VII, for the two-element chain (the first ' 'finite stage of Soto-Andrade and Varela\'s two-element example, 1984, §2.5, ' - 'pp. 15–16; Trimble, "No surjective map Y → 2Y"; Bergman 2008, ' - 'Corollary 7). Lean purity: monotone_regime_derives_pinned choice-free; in the ' + 'pp. 15–16; Trimble, "No surjective map Y → 2Y"; Bergman, ' + 'Corollary 7 of arXiv:0801.0751, Corollary 3.2 in the journal). Lean purity: monotone_regime_derives_pinned choice-free; in the ' 'two-element-chain example the no-surjection half is [propext], and Classical.choice enters ' 'through the Knaster–Tarski half (OrderHom.lfp on Mathlib\'s complete-lattice instance ' 'on Bool). ✓', @@ -272,8 +276,8 @@ def build(): 'gives every total computable endomap of codes a fixed point up to eval — two ' 'codes computing the same function.', 'That is weaker than "no fixed-point-free endomap", and the strong form is false: ' - 'c ↦ pair(c, c) is total and computable and returns its own input for no c (stated ' - 'in the Lean docstrings, not formalized as a declaration). The ' + 'fun c => Code.pair c c is total and computable and returns its own input for no c ' + '(code_pair_diag_fixedPointFree, ZeroParadox/Category/Lawvere.lean). The ' 'obstruction is absent at the level of eval, which is where the reflexive object ' 'lives — and the reason is that the effective category admits fewer maps, ' 'not that eval lands in a different type: no computable self-map on codes is ' @@ -397,7 +401,8 @@ def build(): 'instance, is definable in ZFC.', 'Reading: the framework treats the self-application fixed point as a role carried with its ' 'face, characterized rather than constructed as one global object. Its choice of a ' - 'non-well-founded foundation (ZF + AFA rather than ZFC; Aczel 1988; Barwise & Moss 1996) ' + 'non-well-founded foundation (ZFC− + AFA: Foundation replaced by AFA, Choice kept; Aczel 1988, ' + 'p. xviii; Barwise & Moss 1996, p. 72, whose ZFC− on p. 28 also has urelements) ' 'is a separate commitment, which this face-locality does not by itself require. A theorem stated for every suitable category can be ' 'witnessed in whichever category has Lawvere\'s hypothesis; the occupant it ' 'produces is defined only relative to that category.', @@ -428,9 +433,13 @@ def build(): 'supplied by the class fields fixed_bot and unique_fp (selfApp_pinnable), not by the engine, ' 'whose hypothesis fails on every ZPSemilattice with an element other than ⊥ ' '(nontrivial_lattice_no_witness). On every ZPSemilattice with an element other than ⊥, ' - 'that face\'s only link to the computability face is the KleeneStructure commitment: it ' - 'nominates a code meeting a periodicity condition (one that constant codes also meet) as the ' - 'computational witness of the bottom role, a commitment of the class and not a theorem ' + 'that face is linked to the computability face through the die\'s Quine-atom role, ' + 'whose occupancy is settled chart by chart: in the code chart no single code occupies it under the eval step ' + '(evalStepMotion_not_selfOnlyAt), and a class of codes up to equal eval does, for computable ' + 'eval-respecting maps (codes_vs_classes). KleeneStructure supplies a code meeting a periodicity ' + 'condition (one that constant codes also meet) and equates it with nothing. The reading it was ' + 'built for, that this code is the computational witness of ⊥, splits: its identity half is ' + 'retired, and its running half, that ⊥ executes, is the occurrence commitment ' '(ZeroParadox/Computability/Kleene.lean §II). On the one-element ZPSemilattice, as for ' 'the one-element set, the forward case holds trivially. The ' 'monotone face, in posets with monotone maps, runs it in neither direction on the two-element chain: on a complete lattice no monotone ' @@ -485,10 +494,14 @@ def build(): 'so Knaster–Tarski is not a corollary of Lawvere\'s theorem through a surjection onto a ' 'function space in posets; and Bergman, "On lattices and their ideal lattices, and posets and ' 'their ideal posets," Tbilisi Math. J. 1 (2008) 89–103 (arXiv:0801.0751), whose Corollary 7 ' - 'states that no isotone map from a subset of a poset P to the lattice of all downsets of P is ' - 'surjective. The ' - 'apophatic, characterize-not-construct treatment of self-referential objects: Aczel, ' - 'Non-Well-Founded Sets (1988); Barwise & Moss, Vicious Circles (1996).')) + 'in the arXiv numbering (Corollary 3.2 in the journal) states that no isotone map from a subset of a poset P to the lattice of all downsets of P is ' + 'surjective. Non-well-founded sets characterized by unique solutions and by corecursion: Aczel, ' + 'Non-Well-Founded Sets (1988); Barwise & Moss, Vicious Circles (1996), where AFA ' + 'is stated as the Solution Lemma (p. 72) and the Corecursion Theorem (p. 250) is given as their ' + 'version of Aczel\'s Special Final Coalgebra Theorem (their p. 264). Both books also construct: Aczel ' + 'builds a model of ZFC− + AFA (Theorem 3.10, p. 37) and Barwise and Moss a model ' + 'of ZFA (Chapter 9, pp. 103–115 in their index). Reading the self-referential object as ' + 'characterized rather than constructed is this document\'s reading, not theirs.')) E.append(body( 'Against this, the contribution of ZP-R is not a theorem but a placement: the ' 'per-face placement of the framework\'s self-application role relative to the Lawvere fixed ' @@ -598,8 +611,9 @@ def build(): 'Computability face (ComputableCrossing, Kleene): [propext, Classical.choice, Quot.sound] ' '— Classical.choice inherited from Mathlib\'s classical recursion theory (Kleene / ' 'Rogers), disclosed and not claimed otherwise.', - 'Core choice-free, realization choice-carrying — the framework\'s standing pattern. ' - 'Zero sorry. Verified: lake build, October 2026.', + 'Core choice-free, realization choice-carrying — the framework\'s standing pattern.', + 'The footprints listed here are copies; to re-measure one, run #print axioms on the named ' + 'declaration.', ] )) E.append(sp(6)) diff --git a/scripts/build_zpr_addendum.py b/scripts/build_zpr_addendum.py index 3712d0c9..f4070898 100644 --- a/scripts/build_zpr_addendum.py +++ b/scripts/build_zpr_addendum.py @@ -1,6 +1,6 @@ """ Zero Paradox — ZP-R Addendum: The Diagonal Family — PDF Builder -Version 1.18 | October 2026 +Version 1.25 | November 2026 Follows scripts/PDF_Rendering_Standards.md. Search record behind § IV's Gödel-first sentence (2026-10-06, ripgrep over ZeroParadox/**/*.lean): (a) godel_?(one|1|first)|first_?incompleteness|incompleteness_?(one|1|first)|godel_?sentence|true_?but_?unprovable -> 0 hits @@ -10,8 +10,9 @@ import os from zp_utils import * +from reportlab.platypus import KeepTogether -VERSION = '1.18' +VERSION = '1.25' FIRST_RELEASED = 'July 2026' @@ -41,7 +42,7 @@ def build(): 'the Gödel-first row carries a machine-checked Lean 4 witness. The diagonal-family unification is ' 'Lawvere (1969) / Yanofsky (2003), cited; the contribution is the formalization ' 'and the tie to the self-application role (the engine, the wall faces, and the Quine-atom ' - 'and Löb / Gödel 2nd floor faces choice-free; the computability floor faces choice-carrying). It supersedes the earlier private "Zero as a Wall" ' + 'and Löb / Gödel 2nd floor faces choice-free; the computability floor faces choice-carrying); abstract Löb and Gödel 2 are also formalized by Popescu & Traytel (Isabelle, 2019) and Saitou & Noguchi (Lean 4, arXiv:2609.13780). It supersedes the earlier private "Zero as a Wall" ' 'working draft.', S['note']), sp(10), @@ -64,7 +65,8 @@ def build(): 'that one fact into the wall faces. One direction is proved about the fork\'s two regimes: a ' 'self-loop rules out well-foundedness (mu_nu_branch_exclusion). The wall (μ) faces ' 'are Cantor, Russell, Turing, Tarski and Curry; the floor (ν) faces are the Quine ' - 'atom, the Kleene quine, the Löb sentence, and (with a twist) Rice. ' + 'atom, the Kleene quine, the Löb sentence (from a hypothesized Löb diagonal), and ' + '(with a twist) Rice. ' 'Most of the engine and the classical faces are already formalized in the framework\'s Wall ' 'module; this addendum adds the four faces formalized in the diagonal-family build (Tarski, ' 'Curry, Rice, Löb).')) @@ -140,7 +142,8 @@ def build(): 'Tarski (Tarski.lean) — the truth face', [ 'tarski_no_internal_truth: no internal universal truth-naming exists — truth is not ' - 'definable inside a system that can name all its own predicates (Tarski 1936). The liar ' + 'definable inside a system that can name all its own predicates (Tarski, conventionally dated ' + '1936). The liar ' 'sentence (tarski_liar_from_naming) is the explicit diagonal; the T-schema at the liar is ' 'absurd (tarski_Tschema_liar_absurd).', 'The bottom relationship: no floor — tarski_no_truth_bottom (¬ HasLawvereWitness ' @@ -176,17 +179,26 @@ def build(): 'At each floor face a fixed point is supplied, and the supplier differs by face. In the fork / ' 'AFA face it is ⊥ of the ZPSemilattice, by the class fields (a commitment, not engine ' 'output). In the computability face it is a Kleene code (Rogers\' fixed point). In the Löb ' - 'face it is given by a hypothesized Löb diagonal.')) + 'face it is given by a hypothesized Löb diagonal: the Lean takes it as the hypotheses hfix1, ' + 'hfix2, and in arithmetic the diagonal lemma supplies it (ZeroParadox/Settheory/Loeb.md).')) E.append(result_box( 'The Quine atom (SetTheoryAFA.lean) — the set-theoretic floor', [ - '⊥ = {⊥}: the self-containing ⊥ of the ZPSemilattice. t_exec / T-EXEC ' - '(t_exec_iff): every Quine atom equals ⊥ of the ZPSemilattice (IsQuineAtom q ↔ ' - 'q = ⊥), derived from the ZPSemilattice / AFAStructure class fields — location ' - 'and uniqueness of the floor in this face. Lives in ZF + AFA (walled off under Foundation, ' - 'Section II).', - 'Lean purity: choice-free. ✓', + 'The Quine atom (CC-2) is a role: a point that steps to itself and to nothing else ' + '(Motion.SelfOnlyAt, ZeroParadox/Die.lean), whose occupancy is settled chart by chart, with no equation across ' + 'charts. In the lattice chart its occupant is ⊥ of the ZPSemilattice, under a ' + 'self-application map supplied by AbstractSelfApp (selfApp_quine_role_iff) and in the ' + 'QuineAtomHost an AFAStructure on L builds (quineAtomHost_quine_role_iff with ' + 'afaStructure_isQuineAtomHost); t_exec / T-EXEC (t_exec_iff): every ' + 'Quine atom equals ⊥ of the ZPSemilattice (IsQuineAtom q ↔ q = ⊥), derived ' + 'from the ZPSemilattice / AFAStructure class fields — location and uniqueness of the ' + 'floor in this face. In Mathlib\'s ZFSet, where the role reads x = {x} ' + '(zfset_selfOnlyAt_mem_iff), it has no occupant (zfset_quine_role_unoccupied; walled off ' + 'under Foundation, Section II). In the final coalgebra of the one-child polynomial functor it ' + 'is occupied (cofix_quine_role_occupied), but that chart has one point (cofix_subsingleton), ' + 'so the occupancy restates the existence fork and adds nothing further.', + 'Lean purity: t_exec choice-free. ✓', ] )) E.append(sp(4)) @@ -207,7 +219,8 @@ def build(): )) E.append(sp(4)) - E.append(result_box( + # KeepTogether: the box split across pages 3-4 with only its last two rows under a repeated title. + E.append(KeepTogether(result_box( 'Löb (Loeb.lean) — the provability floor, given a Löb diagonal; and Gödel\'s second incompleteness', [ 'loeb: given a Löb diagonal (ψ ↔ (□ψ → A)), ⊢ ' @@ -215,12 +228,25 @@ def build(): 'provability (loeb_sentence_is_fixedpoint).', 'godel_two: given a Löb diagonal for falsum, a consistent system does not prove ' '□falsum → falsum — its own ' - 'consistency (Gödel\'s second incompleteness, the A = ⊥ corollary). Built from ' - 'scratch (no modal logic in Mathlib): an abstract ProvabilityLogic typeclass with the ' + 'consistency (Gödel\'s second incompleteness, the A = falsum corollary). The consistency ' + 'reading is Gödel\'s second theorem when the class is instantiated at a theory of arithmetic ' + 'and falsum is its falsum; in ' + 'the class, godel_two binds ' + 'falsum as an arbitrary sentence (ProvabilityLogic has no falsum constant and no ex-falso), so it ' + 'covers any unprovable sentence with a Löb diagonal.', + 'Two readings of the face: it is filed with the floors because the diagonal closes; the ' + 'unprovability of consistency is a limitation, which ZeroParadox/Settheory/Loeb.lean calls the ' + 'wall on the provability axis, in another sense than the μ wall faces of Section II.', + 'Built from scratch (no modal or provability logic located in the pinned Mathlib, searched ' + '2026-08-30 on three axes; ZeroParadox/Settheory/Loeb.lean; prior art for abstract provability: ' + 'Popescu & Traytel, CADE-27 (2019), and their Archive of Formal Proofs entry "An Abstract ' + 'Formalization of Gödel\'s Incompleteness Theorems", in Isabelle; Saitou & Noguchi, ' + '"Mechanizing Gödel\'s Incompleteness Theorems and Provability Logic", arXiv:2609.13780, in ' + 'Lean 4): an abstract ProvabilityLogic typeclass with the ' 'Hilbert–Bernays–Löb derivability conditions.', 'Lean purity: choice-free. ✓', ] - )) + ))) E.append(sp(4)) E.append(result_box( @@ -281,14 +307,17 @@ def build(): 'curry_paradox, curry_no_bottom (Curry.lean)'], ['Gödel 1st', 'between', 'self-reference is true-but-unprovable', 'not formalized here'], - ['Quine atom', 'ν', '⊥ = {⊥}: ⊥ of a ZPSemilattice, in the Quine-atom role', - 't_exec / t_exec_iff (SetTheoryAFA.lean)'], + ['Quine atom', 'ν', 'the Quine-atom role (a point that steps to itself and to nothing ' + 'else), occupied by ⊥ of a ZPSemilattice', + 't_exec / t_exec_iff (SetTheoryAFA.lean); selfApp_quine_role_iff (QuineDichotomy.lean)'], ['Kleene quine', 'ν', 'every computable self-map on codes has a fixed point up to eval', 'computability_face_fixedPoint (Lawvere.lean)'], ['Löb / Gödel 2nd', 'ν', 'the provability diagonal closes given a Löb diagonal ψ ' '(hypotheses hfix1, hfix2); consistency unprovable, for a consistent system given a Löb ' - 'diagonal for falsum', - 'loeb, godel_two (Loeb.lean)'], + 'diagonal for falsum (Gödel\'s second theorem when the class is instantiated at a theory of ' + 'arithmetic and falsum is its falsum; in the class, ' + 'falsum may be any sentence)', + 'loeb, loeb_sentence_is_fixedpoint, godel_two (ZeroParadox/Settheory/Loeb.lean)'], ['Rice', 'ν', 'a fixed point exists; every non-trivial semantic property is ' 'undecidable over all codes', 'rice_face_has_bottom, quine_exists_yet_rice, halting_undecidable (Rice.lean)'], @@ -350,19 +379,19 @@ def build(): 'individual faces are classical: Cantor; Russell (1901); Gödel (1931); Turing\'s halting ' 'problem; Tarski (1936); Curry (1942); Löb (1955); Kleene\'s recursion theorem; and ' 'Rice, "Classes of recursively enumerable sets and their decision problems," Trans. Amer. ' - 'Math. Soc. 74(2) (1953) 358–366. The ' + 'Math. Soc. 74(2) (1953) 358–366. The years given for Russell and Tarski are their ' + 'conventional datings; those primary publications were not read for this addendum. The ' 'point-surjective theorem is in Mathlib (Function.exists_fixed_point_of_surjective); the ' 'framework\'s engine re-derives it axiom-free for a self-contained family. The contribution of ' 'this addendum is the formalization of the faces formalized here (the engine, the wall faces, and the Quine-atom and ' 'Löb / Gödel 2nd floor faces choice-free; the computability floor faces choice-carrying) and its tie to the self-application role — a placement, not an extension.')) - E += [ + # KeepTogether: heading and box on one page (the box had split pp. 6-7). + E.append(KeepTogether([ hr(), Paragraph('Axiom Purity', S['h1']), hr(), - ] - - E.append(axiom_box( + axiom_box( 'Axiom Purity', [ 'The engine and the wall faces (negation_no_fixedpoint, lawvere_fixedpoint, ' @@ -375,9 +404,10 @@ def build(): 'inherited from Mathlib\'s classical recursion theory — disclosed, not claimed ' 'otherwise.', 'Core choice-free, computability realization choice-carrying — the framework\'s ' - 'standing pattern. Zero sorry. Verified: lake build, October 2026.', + 'standing pattern. Each declaration\'s footprint is the #print axioms block in its file\'s ' + 'PurityCheck section (ZeroParadox/Settheory/Loeb.lean, for example).', ] - )) + )])) E.append(sp(6)) E += [ @@ -385,7 +415,8 @@ def build(): Paragraph( 'End of ZP-R Addendum | The Diagonal Family | wall faces μ (Cantor, Russell, ' 'Turing, Tarski, Curry), each the contrapositive of one engine (negation has no fixed ' - 'point) | floor faces ν (Quine atom, Kleene, Löb / Gödel 2nd, Rice), each ' + 'point) | floor faces ν (Quine atom, Kleene, Löb / Gödel 2nd from a hypothesized ' + 'Löb diagonal, Rice), each ' 'fixed point supplied per face | the faces formalized here, Lean-witnessed ' 'except Gödel 1st | cross-face identity a type boundary | the map is a placement, not a new ' 'theorem.', diff --git a/ssot.json b/ssot.json index 42260595..19a46aff 100644 --- a/ssot.json +++ b/ssot.json @@ -151,9 +151,15 @@ "date": "2026-10-13", "prior_statement": "In information theory, L-INF gives unbounded surprisal: for every bound M some ball depth n has surprisal I(n) = n > M. Reading that unbounded floor as ⊥ of MachinePhase is the framework's reading, not part of l_inf.", "reason": "CARRYW3-1, wave 4 lane Z, pointer-or-delete rule W4-R1: deleted the Reading clause, which named the wrong carrier for the floor (the limit point 0 of Q2, not bottom of MachinePhase), had no antecedent for \"that unbounded floor\", and sat inside the Statement slot. What remains is what l_inf states." + }, + { + "by": "Tim — ruling 2026-11-01 \"Fix it now\" (additive); wording by agent (die arc 1b)", + "date": "2026-11-01", + "prior_statement": "In information theory, L-INF gives unbounded surprisal: for every bound M some ball depth n has surprisal I(n) = n > M.", + "reason": "E13 #13 / E14 #3 (LH2): additive only. \"ball depth\" labelled as the design identification (l_inf's n is a natural number; Surprisal.lean surprisal_eq_binary_info docstring), and the point-mass zero-information reading of the information-layer bottom added beside the unbounded-surprisal one, with pointers. Tim's sentence kept verbatim." } ], - "statement": "In information theory, L-INF gives unbounded surprisal: for every bound M some ball depth n has surprisal I(n) = n > M.", + "statement": "In information theory, L-INF gives unbounded surprisal: for every bound M some ball depth n has surprisal I(n) = n > M. In `l_inf` n is a natural number; reading it as a depth in the 2-adic ball hierarchy is a design identification (`surprisal_eq_binary_info`, ZeroParadox/Information/Surprisal.lean). Beside this reading the framework gives ⊥ in the information setting a second one, the degenerate distribution, a zero-information point mass (README, Information row): on a type with at most one outcome every distribution is the point mass (`pmf_subsingleton_isPure`).", "status": "proved", "to": null }, @@ -308,7 +314,21 @@ "bottom" ], "reason": null, - "statement": "Each domain bottom is the categorical bottom of its own real category (MC-1, correspondence half — formally realized).", + "restatements": [ + { + "by": "agent fix pass 2 for ZPH-NATIVE-ROLE-1 (orchestrator-briefed; wording awaits Tim's review)", + "date": "2026-11-05", + "prior_statement": "Each domain bottom is the categorical bottom of its own real category (MC-1, correspondence half — formally realized).", + "reason": "ZPH-NATIVE-ROLE-1 (content BEDROCK): \"the categorical bottom of its own real category\" is false for TopCat, where {0} ⊆ ℚ₂ is terminal and not initial (padic_bottom_not_initial, padic_bottom_isTerminal); the TopCat limit is floorConeIsLimit. Restated per category; backing in ClaimsMirror.claim_MC1_correspondence." + }, + { + "by": "agent fix pass 3 for ZPH-NATIVE-ROLE-1 (orchestrator-briefed; wording awaits Tim's review)", + "date": "2026-11-05", + "prior_statement": "MC-1, correspondence half (formally realized), characterized per real Mathlib category and differing by category: the state floor is initial in ModuleCat ℂ; the information floor is initial in KleisliCat PMF, with no return morphism into it; the p-adic floor {0} ⊆ ℚ₂ is the limit of the ball tower in TopCat, terminal there and not initial.", + "reason": "ZPH-NATIVE-ROLE-1 gate round 1 (copy-editor F1 MEANING; adversary/editorial two-pole): \"no return morphism into it\" was unscoped and false as written (the identity on Fin 0); fC_no_return is scoped to stages n > 0 of fC_functor. Added the missing poles: the ModuleCat ℂ floor is also terminal (fD_zero_isTerminal), the KleisliCat PMF floor is not terminal (kleisli_bottom_not_terminal); the three-way split is fork_positions_distinct. TopCat terminality rests on one-pointedness, not the limit. Backing extended in ClaimsMirror.claim_MC1_correspondence." + } + ], + "statement": "MC-1, correspondence half (formally realized), characterized per real Mathlib category and differing by category: the state floor is a zero object (initial and terminal) in ModuleCat ℂ; the information floor is initial and not terminal in KleisliCat PMF, with no morphism into it from any later stage of the functor; the p-adic floor {0} ⊆ ℚ₂ is terminal in TopCat (it has one point) and not initial, and separately the limit of the ball tower.", "status": "corr", "to": null }, @@ -652,8 +672,8 @@ "tree": "eacbc513a541d465b9937b33a53f923d3e9ea4b6" }, "counts": { - "declarations": 2985, - "files": 184 + "declarations": 3362, + "files": 208 }, "entries": [ { @@ -1026,6 +1046,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "00b26a10-904e-4518-9574-281dc651c97e", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_of_avoids", + "short": "t_snap_of_avoids" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_of_avoids", + "short": "t_snap_of_avoids", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Occurrence link (2026-11-03): CrossingTrials § VIII — a tape that fired at least once gives t_snap_given's hcc1/hocc by dropping the stutter prefix; firing at least once has measure one; typicality gives firing at least once. hw is the occurrence commitment as an explicit hypothesis.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -1062,6 +1120,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "00bcca3b-259d-410b-8c8d-ea69c63fb9c3", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.exists_MLRandom", + "short": "exists_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.exists_MLRandom", + "short": "exists_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "00c6c804-4ee1-422c-9ff5-6a13e354f340", + "new": { + "file": "ZeroParadox/Reals/ConnectedNoFirstStep.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_preconnected_of_firstStep", + "short": "not_preconnected_of_firstStep" + }, + "old": { + "file": "ZeroParadox/Reals/ConnectedNoFirstStep.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_preconnected_of_firstStep", + "short": "not_preconnected_of_firstStep", + "synthetic": true + }, + "ontology": { + "domain": [ + "reals" + ], + "object": [], + "role": [ + "no-go" + ] + }, + "reason": "ConnectedNoFirstStep: on a linear order with its order topology, preconnected forbids a first step (HasFirstStep) at every point, choice-free; converse under conditional completeness; controls Q, Z, Fin 2, {0} u [1,2]", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -1503,6 +1635,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "01e19772-5206-478e-9caa-42981356d114", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.blockWord", + "short": "blockWord" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.blockWord", + "short": "blockWord", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -1832,6 +2001,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "02905c5b-1f69-49c5-b546-20bb472fa88a", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroMaxZPS", + "short": "epsilonOrZeroMaxZPS" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroMaxZPS", + "short": "epsilonOrZeroMaxZPS", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -1903,6 +2109,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "02a4e125-87f3-4b39-b247-07b878c4716d", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.trueFreq_allTrue", + "short": "trueFreq_allTrue" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.trueFreq_allTrue", + "short": "trueFreq_allTrue", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -2454,6 +2697,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "03c966b8-9db7-40e0-9b0d-a9987b1e193a", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.firedRun", + "short": "firedRun" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.firedRun", + "short": "firedRun", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Occurrence link (2026-11-03): CrossingTrials § VIII — a tape that fired at least once gives t_snap_given's hcc1/hocc by dropping the stutter prefix; firing at least once has measure one; typicality gives firing at least once. hw is the occurrence commitment as an explicit hypothesis.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -2607,6 +2888,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "042f1c90-7b9a-4a2c-8641-f2d2a5003e4b", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.avg_eq_inv_card", + "short": "avg_eq_inv_card" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.avg_eq_inv_card", + "short": "avg_eq_inv_card", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -2828,6 +3146,76 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "04e94a4a-af12-4cb9-8f5e-6334ed3a15bb", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.orderIsoWithTopClassical", + "short": "orderIsoWithTopClassical" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.orderIsoWithTopClassical", + "short": "orderIsoWithTopClassical", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "04eae2ca-a667-41d6-bacf-b917b1d432f9", + "new": { + "file": "ZeroParadox/Ordinal/Epsilon0MinMax.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0EqNfpBotStatement", + "short": "epsilon0EqNfpBotStatement" + }, + "old": { + "file": "ZeroParadox/Ordinal/Epsilon0MinMax.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0EqNfpBotStatement", + "short": "epsilon0EqNfpBotStatement", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [] + }, + "reason": "errata lane A 2026-10-31: named witnesses and statement controls replacing prose measurements (CARRYW4-C8L-12, CARRY1008-32, CARRY1009-28)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -3341,6 +3729,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "05aa1a87-7c41-4b57-bf16-fc1487be1f7f", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.slotRun", + "short": "slotRun" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.slotRun", + "short": "slotRun", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -3522,6 +3948,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "062b753c-63a8-4f7f-a07b-464e2c271a95", + "new": { + "file": "ZeroParadox/Order/UpAndOver.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilon_succ_pinnedLimitAbove", + "short": "epsilon_succ_pinnedLimitAbove" + }, + "old": { + "file": "ZeroParadox/Order/UpAndOver.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilon_succ_pinnedLimitAbove", + "short": "epsilon_succ_pinnedLimitAbove", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "pinned-limit-r2-1103: PinnedLimitAbove (relative least fixed point), closure-ordinal-omega equivalence (Das & Melgaard 2023 Ex. 2.9), uniqueness of the PinnedLimit occupant under omega^, and the eps_(o+1) / corner occupants of the relative form; round-2 gate fixes", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -3711,6 +4172,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "066850ef-37d3-4172-8c97-957269654c0f", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.infty_isJoint", + "short": "NInf.infty_isJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.infty_isJoint", + "short": "NInf.infty_isJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -3934,6 +4430,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "06ce72a0-82ab-400e-b4cd-c6d65ba87dcc", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.exists_halving_block", + "short": "exists_halving_block" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.exists_halving_block", + "short": "exists_halving_block", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -4080,6 +4613,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "06fb81b5-b951-4232-a830-0028641f32fc", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_isDualJoint_of_isTop", + "short": "not_isDualJoint_of_isTop" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_isDualJoint_of_isTop", + "short": "not_isDualJoint_of_isTop", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0702cfac-932d-4e4e-8601-76172ac4b173", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.half_add_quarter_lt_one", + "short": "half_add_quarter_lt_one" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.half_add_quarter_lt_one", + "short": "half_add_quarter_lt_one", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -4152,6 +4757,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0759ab64-8cf4-4ef1-9759-9ca9ce964493", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.pinnedLimitUnique_succ", + "short": "pinnedLimitUnique_succ" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.pinnedLimitUnique_succ", + "short": "pinnedLimitUnique_succ", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "075c8798-8bf3-4ecd-b262-45583ed90401", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ZeroBlockTypical", + "short": "ZeroBlockTypical" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ZeroBlockTypical", + "short": "ZeroBlockTypical", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -4815,6 +5492,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "08fca641-1005-477e-af15-470e267f7934", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.fairTape_compressibleTapes_le", + "short": "fairTape_compressibleTapes_le" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.fairTape_compressibleTapes_le", + "short": "fairTape_compressibleTapes_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -5149,6 +5863,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0985988b-2ba1-4558-994b-2e304085bcef", + "new": { + "file": "ZeroParadox/Category/Lawvere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.code_pair_diag_fixedPointFree", + "short": "code_pair_diag_fixedPointFree" + }, + "old": { + "file": "ZeroParadox/Category/Lawvere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.code_pair_diag_fixedPointFree", + "short": "code_pair_diag_fixedPointFree", + "synthetic": true + }, + "ontology": { + "domain": [ + "computability" + ], + "object": [], + "role": [] + }, + "reason": "errata lane A 2026-10-31: named witnesses and statement controls replacing prose measurements (CARRYW4-C8L-12, CARRY1008-32, CARRY1009-28)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -5224,6 +5973,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "09ad6308-3b85-4bdd-8ed0-efbf3ee44edc", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.continuous_onePointInv_real", + "short": "continuous_onePointInv_real" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.continuous_onePointInv_real", + "short": "continuous_onePointInv_real", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "reals" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -5260,6 +6047,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0a13a2c5-4893-4078-80b7-a7f80c7cc2c4", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ballLine", + "short": "ballLine" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ballLine", + "short": "ballLine", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -5371,6 +6195,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0a41935c-7b37-4912-99b3-63ec26b1026f", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.bool_botHasFirstStep", + "short": "bool_botHasFirstStep" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.bool_botHasFirstStep", + "short": "bool_botHasFirstStep", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -6029,6 +6890,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0bc4b1b2-ab8b-4ef0-bb77-5d1ac0f7539e", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.nnreal_not_botHasFirstStep", + "short": "nnreal_not_botHasFirstStep" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.nnreal_not_botHasFirstStep", + "short": "nnreal_not_botHasFirstStep", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0bd24e0c-f8c2-46fc-9581-6d0b7c42394c", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.silentFrom", + "short": "silentFrom" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.silentFrom", + "short": "silentFrom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -6355,6 +7290,46 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0c746cf7-d9c7-472c-86e6-20d08ecbc306", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.end_top_covers_nothing", + "short": "end_top_covers_nothing" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.end_top_covers_nothing", + "short": "end_top_covers_nothing", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [ + "snap", + "ceiling" + ], + "role": [ + "no-go" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -6578,6 +7553,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0d12deab-03e4-416f-8127-704971f04c31", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo", + "short": "missingInfo" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo", + "short": "missingInfo", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -6940,6 +7952,83 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0ddadd5f-8e4b-412b-aca0-ca32a4e3769e", + "new": { + "file": "ZeroParadox/Multihomed/TreeObstructions.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.padic_bottom_isTerminal", + "short": "padic_bottom_isTerminal" + }, + "old": { + "file": "ZeroParadox/Multihomed/TreeObstructions.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.padic_bottom_isTerminal", + "short": "padic_bottom_isTerminal", + "synthetic": true + }, + "ontology": { + "domain": [ + "category", + "valuation" + ], + "object": [ + "bottom" + ], + "role": [ + "face" + ] + }, + "reason": "ZPH-NATIVE-ROLE-1 pass 2: name the TopCat terminality of {0} ⊆ Q₂ (was an anonymous example)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0ddcd4fb-e91e-418b-98f5-72000e8aa974", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.squaresTape_not_avoids", + "short": "squaresTape_not_avoids" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.squaresTape_not_avoids", + "short": "squaresTape_not_avoids", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality generalisation (2026-11-03): the squares tape fails the zero-block tests for trials p at every 0 < p <= 1.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -7048,6 +8137,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0e2b34e6-5982-4b50-b0f8-455086d1c235", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.le_succ", + "short": "le_succ" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.le_succ", + "short": "le_succ", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -7556,6 +8680,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0f075c7c-50b1-4d1a-a0bf-66519f4c2415", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.everyStepCovered", + "short": "everyStepCovered" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.everyStepCovered", + "short": "everyStepCovered", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -7631,6 +8790,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "0f77fcfd-0af7-4834-8fe3-ac976ef47a5d", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ballS_isClopen", + "short": "ballS_isClopen" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ballS_isClopen", + "short": "ballS_isClopen", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -9143,6 +10339,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "12ee8209-fe80-4741-8250-934edeac0d2e", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.PinnedLimitAbove", + "short": "PinnedLimitAbove" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.PinnedLimitAbove", + "short": "PinnedLimitAbove", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "pinned-limit-r2-1103: PinnedLimitAbove (relative least fixed point), closure-ordinal-omega equivalence (Das & Melgaard 2023 Ex. 2.9), uniqueness of the PinnedLimit occupant under omega^, and the eps_(o+1) / corner occupants of the relative form; round-2 gate fixes", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -9471,6 +10702,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "13dcfe05-5b1a-4dfe-961f-32bf060dbc64", + "new": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.withBotOrderTopCF", + "short": "withBotOrderTopCF" + }, + "old": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.withBotOrderTopCF", + "short": "withBotOrderTopCF", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lean 4.35 upgrade: new choice-free declarations (rulings 165, 168, 190)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -9835,6 +11103,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1490a847-4a93-4e94-b3ed-5e28903e2499", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.isJoint_image_of_isDualJoint", + "short": "isJoint_image_of_isDualJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.isJoint_image_of_isDualJoint", + "short": "isJoint_image_of_isDualJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -10205,6 +11508,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "159d8791-cdea-4866-b364-f76e989b01f7", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofNat_covBy", + "short": "ofNat_covBy" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofNat_covBy", + "short": "ofNat_covBy", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -11387,6 +12725,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "17fec512-69db-4fd1-a267-0d59303dafe1", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy_eq_log_iff", + "short": "shannonEntropy_eq_log_iff" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy_eq_log_iff", + "short": "shannonEntropy_eq_log_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -11610,6 +12985,83 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "18a27809-d3a5-46bd-9a69-8025efc0f52c", + "new": { + "file": "ZeroParadox/Settheory/Wall.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.zfset_selfOnlyAt_mem_iff", + "short": "zfset_selfOnlyAt_mem_iff" + }, + "old": { + "file": "ZeroParadox/Settheory/Wall.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.zfset_selfOnlyAt_mem_iff", + "short": "zfset_selfOnlyAt_mem_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [ + "bottom", + "wall-selfapp" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "18c2c1ec-5868-4958-abe6-bddcd14579b2", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.interior_of_not_eventuallyConst", + "short": "interior_of_not_eventuallyConst" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.interior_of_not_eventuallyConst", + "short": "interior_of_not_eventuallyConst", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12093,6 +13545,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "199f8462-386a-4aad-be58-47b19d68dd38", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofNat_le_det_iff", + "short": "ofNat_le_det_iff" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofNat_le_det_iff", + "short": "ofNat_le_det_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12422,6 +13911,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1a7790d2-abbf-4735-8b8c-0dfe1c833d81", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.hcov_iff_phi_cover", + "short": "hcov_iff_phi_cover" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.hcov_iff_phi_cover", + "short": "hcov_iff_phi_cover", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12532,6 +14058,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1abc722d-ff21-45a4-a758-13c190533359", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.det_padicTape_eq_infty_iff", + "short": "det_padicTape_eq_infty_iff" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.det_padicTape_eq_infty_iff", + "short": "det_padicTape_eq_infty_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "order" + ], + "object": [], + "role": [ + "core" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12571,6 +14135,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1acbfcc4-4d2a-494f-92ac-ef58f1e564ab", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.eq_half_of_maxEntropy", + "short": "eq_half_of_maxEntropy" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.eq_half_of_maxEntropy", + "short": "eq_half_of_maxEntropy", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12647,6 +14248,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1adc7a4a-5c04-48e4-ba9e-79e981a2db1c", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.allTrue_zeroBlockTypical", + "short": "allTrue_zeroBlockTypical" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.allTrue_zeroBlockTypical", + "short": "allTrue_zeroBlockTypical", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12863,6 +14501,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1bb2aabe-ebe7-4e26-a79e-a182e8747c45", + "new": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.cofixSelf_selfOnlyAt", + "short": "cofixSelf_selfOnlyAt" + }, + "old": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.cofixSelf_selfOnlyAt", + "short": "cofixSelf_selfOnlyAt", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [ + "bottom" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -12935,6 +14612,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1c738648-e892-42c1-8f4a-9beb3a68dd7b", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.rInv_arcS", + "short": "rInv_arcS" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.rInv_arcS", + "short": "rInv_arcS", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [ + "bottom" + ], + "role": [ + "face" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -13046,6 +14762,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1c88eb75-45c6-4b64-915c-855040bd36dd", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_fin_eq_zero_iff", + "short": "missingInfo_fin_eq_zero_iff" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_fin_eq_zero_iff", + "short": "missingInfo_fin_eq_zero_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -13303,6 +15056,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1d10a32a-14d2-4760-9b81-f9fbf6a60844", + "new": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.seam_role_unique_iff_wellFounded", + "short": "seam_role_unique_iff_wellFounded" + }, + "old": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.seam_role_unique_iff_wellFounded", + "short": "seam_role_unique_iff_wellFounded", + "synthetic": true + }, + "ontology": { + "domain": [ + "category" + ], + "object": [ + "wall-seam" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Die arc 3 2026-11-01: the seam role (exactly one SelfOnlyAt occupant) per chart: next-time chart of QPF coalgebras, lattice selfApp, module elements / zero object", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -13634,6 +15426,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1dd8618c-702c-4065-998a-a63ae055dd61", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlock", + "short": "zeroBlock" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlock", + "short": "zeroBlock", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1ddb1501-4fe4-447b-81e6-f039257607d5", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instOrderBot", + "short": "instOrderBot" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instOrderBot", + "short": "instOrderBot", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -14075,6 +15939,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1f46bf02-1883-4b96-a2f3-ff1778b32831", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_gc", + "short": "det_gc" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_gc", + "short": "det_gc", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -14112,6 +16011,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1f504f81-b238-49ca-ada3-f39d4d85b05d", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding_surjective", + "short": "epsilonOrZeroToLanding_surjective" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding_surjective", + "short": "epsilonOrZeroToLanding_surjective", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "1f546a72-154c-4656-8f6e-3a4f91d2ff73", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.two_pow_dvd_forall_iff", + "short": "two_pow_dvd_forall_iff" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.two_pow_dvd_forall_iff", + "short": "two_pow_dvd_forall_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -15229,6 +17202,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "21ccce92-2ea2-4f67-ab09-7a52dca2de3a", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.Motion.trichotomy_of_em", + "short": "trichotomy_of_em" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.Motion.trichotomy_of_em", + "short": "trichotomy_of_em", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -15594,6 +17602,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "226a834d-0a42-4276-bb9b-a3136331cc4c", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.EventuallyConstTape", + "short": "EventuallyConstTape" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.EventuallyConstTape", + "short": "EventuallyConstTape", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -15701,6 +17746,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2298dd7c-9208-485f-8f7f-895e6d341fa2", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_bot_pinnedLimitUnique", + "short": "det_bot_pinnedLimitUnique" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_bot_pinnedLimitUnique", + "short": "det_bot_pinnedLimitUnique", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -15740,6 +17820,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "23192d37-2109-4c20-9bcc-ad704e3332ff", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofWithTop_strictMono", + "short": "ofWithTop_strictMono" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofWithTop_strictMono", + "short": "ofWithTop_strictMono", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -16889,6 +19004,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "25ec1f64-f7fe-4d51-9396-1d1f9d559ae0", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ofDigits_two_partial_nat", + "short": "ofDigits_two_partial_nat" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ofDigits_two_partial_nat", + "short": "ofDigits_two_partial_nat", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -17219,6 +19371,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "26edfff5-79c0-4587-bda2-5cbc071e2209", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.IsDualJoint", + "short": "IsDualJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.IsDualJoint", + "short": "IsDualJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -17255,6 +19442,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "26eec1b1-59b7-4aab-87a7-9b46c4390bea", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.isMartinLofTest_of_mlTest", + "short": "isMartinLofTest_of_mlTest" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.isMartinLofTest_of_mlTest", + "short": "isMartinLofTest_of_mlTest", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -17702,6 +19926,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "275cf920-ca03-466f-989a-a2b105df2f50", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ballS", + "short": "ballS" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ballS", + "short": "ballS", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -18000,6 +20261,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2835cdb0-0dd7-45ac-af7b-9bdde7a6583d", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding", + "short": "epsilonOrZeroToLanding" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding", + "short": "epsilonOrZeroToLanding", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -18888,6 +21186,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2a2f0aed-ece4-4907-b6e3-9302dbb43256", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.tape_bot_le", + "short": "tape_bot_le" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.tape_bot_le", + "short": "tape_bot_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -18924,6 +21257,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2a5c4b35-cf78-4b09-925d-d7e90f4d43cf", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.slotMotion", + "short": "slotMotion" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.slotMotion", + "short": "slotMotion", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -19597,6 +21968,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2b8703ca-73e5-4f1f-8d23-63fbe9fffaea", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.detHom", + "short": "detHom" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.detHom", + "short": "detHom", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -19895,6 +22301,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2c25efc2-6dae-4261-ba8d-a892cf6a9963", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.pinnedLimitAbove_iff_of_bot", + "short": "pinnedLimitAbove_iff_of_bot" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.pinnedLimitAbove_iff_of_bot", + "short": "pinnedLimitAbove_iff_of_bot", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "pinned-limit-r2-1103: PinnedLimitAbove (relative least fixed point), closure-ordinal-omega equivalence (Das & Melgaard 2023 Ex. 2.9), uniqueness of the PinnedLimit occupant under omega^, and the eps_(o+1) / corner occupants of the relative form; round-2 gate fixes", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -20079,6 +22520,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2c82a460-8ced-42e8-aebe-0fbe2d80e498", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.botHasFirstStep_iff_exists_phi", + "short": "botHasFirstStep_iff_exists_phi" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.botHasFirstStep_iff_exists_phi", + "short": "botHasFirstStep_iff_exists_phi", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2c867f68-e9bd-4987-9e91-8d9a1f3b8752", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.appr_neg_two_pow", + "short": "appr_neg_two_pow" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.appr_neg_two_pow", + "short": "appr_neg_two_pow", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -20338,6 +22853,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2d6333c6-68c9-4b04-918e-ef096865ad89", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.avg_negMulLog_eq", + "short": "avg_negMulLog_eq" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.avg_negMulLog_eq", + "short": "avg_negMulLog_eq", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -20672,6 +23224,46 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2de01ae1-e9c1-4c02-8f55-6c8d351816c9", + "new": { + "file": "ZeroParadox/Category/SeamComparisonMap.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.hilbert_zero_seam_role_unique", + "short": "hilbert_zero_seam_role_unique" + }, + "old": { + "file": "ZeroParadox/Category/SeamComparisonMap.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.hilbert_zero_seam_role_unique", + "short": "hilbert_zero_seam_role_unique", + "synthetic": true + }, + "ontology": { + "domain": [ + "category" + ], + "object": [ + "wall-seam", + "bottom" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Die arc 3 2026-11-01: the seam role (exactly one SelfOnlyAt occupant) per chart: next-time chart of QPF coalgebras, lattice selfApp, module elements / zero object", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -20818,6 +23410,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2e8c47e3-1db7-4b37-b097-8528147ddbd3", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.pairwise_disjoint_domCyl", + "short": "pairwise_disjoint_domCyl" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.pairwise_disjoint_domCyl", + "short": "pairwise_disjoint_domCyl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -21401,6 +24030,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2fc6a3aa-8404-45c1-86e8-12d37fc5b160", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.apply_true_iff_ofNat_succ_le", + "short": "apply_true_iff_ofNat_succ_le" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.apply_true_iff_ofNat_succ_le", + "short": "apply_true_iff_ofNat_succ_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -21433,6 +24099,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "2fd4ed2d-eb67-4c91-b7d4-d0002971c223", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefixOf", + "short": "prefixOf" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefixOf", + "short": "prefixOf", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -22105,6 +24808,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "315618e8-20e3-424e-9f90-2dfbcd89ec27", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.em_of_allRosolini_lpo", + "short": "em_of_allRosolini_lpo" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.em_of_allRosolini_lpo", + "short": "em_of_allRosolini_lpo", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -22210,6 +24948,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "31db2020-ad64-4081-a950-c2db1c5bde4b", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.linearMaxZPS", + "short": "linearMaxZPS" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.linearMaxZPS", + "short": "linearMaxZPS", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -22531,6 +25306,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "32a24bb4-40e1-41e6-bf8e-3d20dd86aaeb", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.mlTest_of_isMartinLofTest", + "short": "mlTest_of_isMartinLofTest" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.mlTest_of_isMartinLofTest", + "short": "mlTest_of_isMartinLofTest", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -22680,6 +25492,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "32ec191e-ef7d-4d69-9f5f-f649a0bad81a", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.isMartinLofRandom_of_MLRandom", + "short": "isMartinLofRandom_of_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.isMartinLofRandom_of_MLRandom", + "short": "isMartinLofRandom_of_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23261,6 +26110,76 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "34c93bb7-4a63-4166-9334-e32bb6b56f3f", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instPartialOrder", + "short": "instPartialOrder" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instPartialOrder", + "short": "instPartialOrder", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "34d1b9d6-13f6-444e-a846-1911e4456bd9", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.pinnedLimit_iff_closure_omega", + "short": "pinnedLimit_iff_closure_omega" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.pinnedLimit_iff_closure_omega", + "short": "pinnedLimit_iff_closure_omega", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "pinned-limit-r2-1103: PinnedLimitAbove (relative least fixed point), closure-ordinal-omega equivalence (Das & Melgaard 2023 Ex. 2.9), uniqueness of the PinnedLimit occupant under omega^, and the eps_(o+1) / corner occupants of the relative form; round-2 gate fixes", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23449,6 +26368,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "353d1ed6-58d5-4dca-b48e-182a1ec066ac", + "new": { + "file": "ZeroParadox/Order/Snap.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_derived_cover", + "short": "t_snap_derived_cover" + }, + "old": { + "file": "ZeroParadox/Order/Snap.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_derived_cover", + "short": "t_snap_derived_cover", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [ + "snap" + ], + "role": [ + "core" + ] + }, + "reason": "2026-11-04 ruling 47 follow-up: name the MachinePhase instance of t_snap_given_cover (t_snap_derived's run meets hcc1, hocc, hcov) so the Foreword can cite it", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23487,6 +26445,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3558ee68-21fa-43cf-8cc1-eba5dce0ce9b", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom_of_isMartinLofRandom", + "short": "MLRandom_of_isMartinLofRandom" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom_of_isMartinLofRandom", + "short": "MLRandom_of_isMartinLofRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23632,6 +26627,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "35cc0a76-3bf8-4865-ba10-cde15724800d", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.trials_fires_once", + "short": "trials_fires_once" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.trials_fires_once", + "short": "trials_fires_once", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Occurrence link (2026-11-03): CrossingTrials § VIII — a tape that fired at least once gives t_snap_given's hcc1/hocc by dropping the stutter prefix; firing at least once has measure one; typicality gives firing at least once. hw is the occurrence commitment as an explicit hypothesis.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23707,6 +26739,82 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "35fd7638-3cd2-4967-9780-ab529d6a36a4", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom", + "short": "MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom", + "short": "MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3660e8e8-5a1e-4aed-b9e7-ae36d6bced2e", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.hahn_no_least_positive_value", + "short": "hahn_no_least_positive_value" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.hahn_no_least_positive_value", + "short": "hahn_no_least_positive_value", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [ + "snap" + ], + "role": [ + "no-go" + ] + }, + "reason": "Probe-2 landed in PolePassage: first step at 0 of an ordered group iff not dense, and the dense-valued HahnSeries control", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -23923,6 +27031,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "36bbf61a-2b0a-4812-8c15-dada562de43b", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ae_incompressible", + "short": "ae_incompressible" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ae_incompressible", + "short": "ae_incompressible", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -24330,6 +27475,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "37a2defd-d1cd-426f-b756-1c73c98c3a94", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.levelOf", + "short": "levelOf" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.levelOf", + "short": "levelOf", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -24730,6 +27912,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3870a884-67e6-428c-9e48-ba2b2380ccb2", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.bitDigit", + "short": "bitDigit" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.bitDigit", + "short": "bitDigit", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -24803,6 +28022,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "38c8bd0d-2917-46f7-942a-775aa0696d4d", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.rInv_eq_onePointInv", + "short": "rInv_eq_onePointInv" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.rInv_eq_onePointInv", + "short": "rInv_eq_onePointInv", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -25235,6 +28491,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "39eeb7c8-19de-48e3-83c4-84a4110943ec", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.no_nat_wait", + "short": "no_nat_wait" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.no_nat_wait", + "short": "no_nat_wait", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -25413,6 +28704,82 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3a606490-8edf-4e5d-a55f-ecc15c7234a9", + "new": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.constPF_child_noStepAt", + "short": "constPF_child_noStepAt" + }, + "old": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.constPF_child_noStepAt", + "short": "constPF_child_noStepAt", + "synthetic": true + }, + "ontology": { + "domain": [ + "category" + ], + "object": [ + "wall-seam" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Die arc 3 2026-11-01: the seam role (exactly one SelfOnlyAt occupant) per chart: next-time chart of QPF coalgebras, lattice selfApp, module elements / zero object", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3a6fa34b-7e26-4bde-b1d4-bf6d4d1ff066", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.AvoidsTests", + "short": "AvoidsTests" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.AvoidsTests", + "short": "AvoidsTests", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -26777,6 +30144,115 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3d824490-d377-43e8-9882-9ac0958cd716", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.kraft_measure", + "short": "kraft_measure" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.kraft_measure", + "short": "kraft_measure", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3da299db-096a-4c2c-9eb6-03192d07f067", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_isJoint_of_isBot", + "short": "not_isJoint_of_isBot" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_isJoint_of_isBot", + "short": "not_isJoint_of_isBot", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3dae618f-d104-4f50-87d9-ff01c9d8d582", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_accPt_range_of_strictMono", + "short": "not_accPt_range_of_strictMono" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_accPt_range_of_strictMono", + "short": "not_accPt_range_of_strictMono", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Ball line radii in ENNReal: isolated points accumulating only at 0 and top (BallLine.lean section V)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -27332,6 +30808,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3f90d91a-9de3-41d0-b02f-abb0770f6f59", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ofDigits_two_pos", + "short": "ofDigits_two_pos" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ofDigits_two_pos", + "short": "ofDigits_two_pos", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "3fa70181-49c6-4b44-9f78-e6e36fcfdfe1", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.isLUB_range_ofNat", + "short": "isLUB_range_ofNat" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.isLUB_range_ofNat", + "short": "isLUB_range_ofNat", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -27774,6 +31322,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "41066c2a-e33c-46b7-8f63-c946df6e3816", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ballRadii", + "short": "ballRadii" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ballRadii", + "short": "ballRadii", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Ball line radii in ENNReal: isolated points accumulating only at 0 and top (BallLine.lean section V)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -27951,6 +31536,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "41dbdf20-c808-4c87-85d9-2501ec75fead", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_eventuallyConst_of_MLRandom", + "short": "not_eventuallyConst_of_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_eventuallyConst_of_MLRandom", + "short": "not_eventuallyConst_of_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -28099,6 +31721,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4237bde1-5366-4916-81f5-c419880e557d", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.trials_constBlock", + "short": "trials_constBlock" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.trials_constBlock", + "short": "trials_constBlock", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -28173,6 +31832,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "425d7e34-6b55-4d24-86ca-3a2479362269", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.bot_eq", + "short": "bot_eq" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.bot_eq", + "short": "bot_eq", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -28585,6 +32279,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "43132054-33ee-446b-9b4f-d1004c8df45e", + "new": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.cofix_quine_role_occupied", + "short": "cofix_quine_role_occupied" + }, + "old": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.cofix_quine_role_occupied", + "short": "cofix_quine_role_occupied", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [ + "bottom" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -29507,6 +33240,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "448c8b78-20ad-4ee5-b488-81f51e02e8b4", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefixDetermined_of_continuous", + "short": "prefixDetermined_of_continuous" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefixDetermined_of_continuous", + "short": "prefixDetermined_of_continuous", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Weihrauch lane (2026-11-03): CrossingTrials § IX, the Cantor-topology face of the occurrence commitment's slot chart. Continuous tests on ℕ → Bool are exactly those fixed by one finite prefix; fired-at-least-once is open, not closed, and no continuous test decides it (fails at ⊥ of ℕ → Bool). Computable ⇒ continuous cited (Weihrauch 2000 Thm 2.2.3 p. 30), not proved.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -29694,6 +33464,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "44fff6aa-7e0b-4ade-a56d-ec04fde6b4cc", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.rosIncl_surjective_iff", + "short": "rosIncl_surjective_iff" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.rosIncl_surjective_iff", + "short": "rosIncl_surjective_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -29731,6 +33536,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "451de84c-db12-42fb-b18f-b6a86674af45", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.mem_prefixCyl_iff", + "short": "mem_prefixCyl_iff" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.mem_prefixCyl_iff", + "short": "mem_prefixCyl_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "453261ce-482f-4f34-a1fc-3f3b28cd9cfe", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.phaseMaxZPS", + "short": "phaseMaxZPS" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.phaseMaxZPS", + "short": "phaseMaxZPS", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -29805,6 +33684,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "456628c5-8f7f-4cdc-b17c-b13435472302", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.fairTape_prefixCyl", + "short": "fairTape_prefixCyl" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.fairTape_prefixCyl", + "short": "fairTape_prefixCyl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -29841,6 +33757,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "457a4d46-3d3e-4364-86d7-ee28bea2b840", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZero_bot_le", + "short": "epsilonOrZero_bot_le" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZero_bot_le", + "short": "epsilonOrZero_bot_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -30062,6 +34015,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "45d32b49-029f-487a-a1a3-d7af474f02b8", + "new": { + "file": "ZeroParadox/Settheory/APG.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.enat_lt_of_add_one_le", + "short": "enat_lt_of_add_one_le" + }, + "old": { + "file": "ZeroParadox/Settheory/APG.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.enat_lt_of_add_one_le", + "short": "enat_lt_of_add_one_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "new HEAD declarations (APG decoration uniqueness by valuation; constructive finite no-SelfCopyRef)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -30247,6 +34237,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4650681a-3d91-4e95-af9a-01511f874375", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0_isJoint", + "short": "epsilon0_isJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0_isJoint", + "short": "epsilon0_isJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -31765,6 +35790,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4915eedf-915f-4075-a3d6-84a6b719cc5d", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.padicTape_zero", + "short": "padicTape_zero" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.padicTape_zero", + "short": "padicTape_zero", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "order" + ], + "object": [], + "role": [ + "core" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -31838,6 +35901,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4942db16-57a4-4fd3-ab28-8aa30ea6f960", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.enat_top_isJoint", + "short": "enat_top_isJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.enat_top_isJoint", + "short": "enat_top_isJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -32057,6 +36155,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "49e5870f-1a4a-48f6-9449-aff49e3d7801", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.constBlock_eq_iUnion", + "short": "constBlock_eq_iUnion" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.constBlock_eq_iUnion", + "short": "constBlock_eq_iUnion", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -32461,6 +36596,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4b35c776-f4bc-4137-95e6-d5bb82ba2583", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ennreal_top_isJoint", + "short": "ennreal_top_isJoint" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ennreal_top_isJoint", + "short": "ennreal_top_isJoint", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -32536,6 +36706,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4b72b715-74e9-4a71-bd09-71c4ba395f83", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.constInf_fails", + "short": "constInf_fails" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.constInf_fails", + "short": "constInf_fails", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -33054,6 +37259,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4c478879-153f-4c62-9547-808ab63eabf1", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.closedBall_eq_ballLine", + "short": "closedBall_eq_ballLine" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.closedBall_eq_ballLine", + "short": "closedBall_eq_ballLine", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "face" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -33786,6 +38028,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4dfb8762-af44-4ce4-8aed-0c79ff74c0fc", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl_eq_cantorCylinder", + "short": "prefixCyl_eq_cantorCylinder" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl_eq_cantorCylinder", + "short": "prefixCyl_eq_cantorCylinder", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -33969,6 +38248,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4eb4e1c8-2445-4c13-877a-574f11107622", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.iUnion_ballLine", + "short": "iUnion_ballLine" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.iUnion_ballLine", + "short": "iUnion_ballLine", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [ + "ceiling" + ], + "role": [ + "face" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -34376,6 +38694,115 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4f86dde7-90b8-4c84-ac5e-65e14c890486", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl", + "short": "prefixCyl" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl", + "short": "prefixCyl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4faa9b74-d729-43dc-866b-03b8af11a41b", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy", + "short": "shannonEntropy" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy", + "short": "shannonEntropy", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "4fb8620d-44e6-420b-b2f9-729444096084", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_exactS", + "short": "det_exactS" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_exactS", + "short": "det_exactS", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -34813,6 +39240,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "508fa57b-f6e8-4689-8715-d074865257be", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.exactS", + "short": "exactS" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.exactS", + "short": "exactS", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -35512,6 +39974,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "519cff32-e8a7-4ee0-a39f-f14f9dcb03a3", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.EpsilonOrZero", + "short": "EpsilonOrZero" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.EpsilonOrZero", + "short": "EpsilonOrZero", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -35548,6 +40047,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "51b8af1d-49b5-4afb-bf50-df1fc4bb5f5d", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.lpo_of_toRos_surjective", + "short": "lpo_of_toRos_surjective" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.lpo_of_toRos_surjective", + "short": "lpo_of_toRos_surjective", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -36096,6 +40630,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "52f49f2f-4693-40d9-b398-2162e3cd562f", + "new": { + "file": "ZeroParadox/Order/DieJoints.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.isDualJoint_toDual_iff", + "short": "isDualJoint_toDual_iff" + }, + "old": { + "file": "ZeroParadox/Order/DieJoints.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.isDualJoint_toDual_iff", + "short": "isDualJoint_toDual_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-joints-1106: ruling 147 (Tim, 2026-11-06), cut points / joints / dual joints of an order and their instances (ZeroParadox/Order/DieJoints.lean), indexed in DieCannotBe § I, § XXVII, § XXIX", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -36245,6 +40814,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "537a8b54-2e3f-40ea-80de-b3adfc33b3aa", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.accPt_ballRadii_iff", + "short": "accPt_ballRadii_iff" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.accPt_ballRadii_iff", + "short": "accPt_ballRadii_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "order" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Ball line radii in ENNReal: isolated points accumulating only at 0 and top (BallLine.lean section V)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -36389,6 +40996,81 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "53c1d614-ea2e-4375-90e6-c3a4ad09d5b1", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ballLine_covBy", + "short": "ballLine_covBy" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ballLine_covBy", + "short": "ballLine_covBy", + "synthetic": true + }, + "ontology": { + "domain": [ + "order", + "valuation" + ], + "object": [ + "snap" + ], + "role": [ + "core" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "53d85bcc-c813-45e5-8b25-782022e44c52", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.tape_le_iff", + "short": "tape_le_iff" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.tape_le_iff", + "short": "tape_le_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -37094,6 +41776,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "567cbd95-f84f-489d-a5f6-40c52dced0ab", + "new": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.cofix_subsingleton", + "short": "cofix_subsingleton" + }, + "old": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.cofix_subsingleton", + "short": "cofix_subsingleton", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01 round 1 fix: the Cofix idPF_Coalgebra chart has one point", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -37278,6 +41997,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "56c0a6f3-9e26-4a50-ad60-a35c36248042", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_eq_zero_iff", + "short": "missingInfo_eq_zero_iff" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_eq_zero_iff", + "short": "missingInfo_eq_zero_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -37423,6 +42179,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "572a2133-2874-48d1-9875-f6f02d032770", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.hahnArc", + "short": "hahnArc" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.hahnArc", + "short": "hahnArc", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Probe-2 landed in PolePassage: first step at 0 of an ordered group iff not dense, and the dense-valued HahnSeries control", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -37686,6 +42479,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5783176c-649e-462e-baa6-bcde33856cc5", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.interior_of_MLRandom", + "short": "interior_of_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.interior_of_MLRandom", + "short": "interior_of_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -38122,6 +42952,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "58591904-25da-4d43-832e-bfed531a1d9a", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_involutive", + "short": "onePointInv_involutive" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_involutive", + "short": "onePointInv_involutive", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -39370,6 +44237,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5ac35f0d-2af4-4b9c-9972-0412f063c48a", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.PinnedLimitUnique", + "short": "PinnedLimitUnique" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.PinnedLimitUnique", + "short": "PinnedLimitUnique", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -39447,6 +44349,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5af7103c-e766-4967-8a5e-f724688baa5e", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.brudno_fair_of_MLRandom", + "short": "brudno_fair_of_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.brudno_fair_of_MLRandom", + "short": "brudno_fair_of_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -40766,6 +45705,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5da8fdcd-b6d6-4bcb-9ae2-8b25ce7a14b9", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_eq_kl", + "short": "missingInfo_eq_kl" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.missingInfo_eq_kl", + "short": "missingInfo_eq_kl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41355,6 +46331,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5f1fb134-3478-4174-b701-7f2851c00966", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.eq_infty_of_succ_le", + "short": "eq_infty_of_succ_le" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.eq_infty_of_succ_le", + "short": "eq_infty_of_succ_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41466,6 +46477,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5f6829bf-faa7-4ef7-a8d2-37775c1feaef", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instBoundedOrder", + "short": "instBoundedOrder" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instBoundedOrder", + "short": "instBoundedOrder", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41644,6 +46690,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "5fee66e1-1948-4302-b3d5-1e221cb4db4c", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv", + "short": "onePointInv" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv", + "short": "onePointInv", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41721,6 +46804,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "60855e53-e019-4d2e-9057-c128e422e43b", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.appendFalse", + "short": "appendFalse" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.appendFalse", + "short": "appendFalse", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "60b96dce-09b9-47cf-be1b-97faeffcf2c3", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.PhaseLanding", + "short": "PhaseLanding" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.PhaseLanding", + "short": "PhaseLanding", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41760,6 +46917,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "60ef057d-39a0-4e38-a203-6bf15362c187", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_negS", + "short": "det_negS" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_negS", + "short": "det_negS", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -41948,6 +47140,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "614759ca-f6cb-417a-ad53-6af11b79e62b", + "new": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.padicTape", + "short": "padicTape" + }, + "old": { + "file": "ZeroParadox/Category/IgnoranceSeam.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.padicTape", + "short": "padicTape", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "ignorance-seam-viii: the bend NInf.det on 2-adic digit tapes is the 2-adic valuation (IgnoranceSeam.lean § VIII)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -42021,6 +47251,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6163ea3e-1df7-43e1-bee4-299ad5d167e5", + "new": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.snapEmbed_selfOnlyAt_c1", + "short": "snapEmbed_selfOnlyAt_c1" + }, + "old": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.snapEmbed_selfOnlyAt_c1", + "short": "snapEmbed_selfOnlyAt_c1", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "lane F arc 2 round 2: role transport at c1; doubling occupancy iff", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -42247,6 +47514,83 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6205842d-2382-4506-a867-ac6fe99886a4", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.arcS", + "short": "arcS" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.arcS", + "short": "arcS", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "ordinal" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6234570b-77e8-4008-b49a-c7beab1975f1", + "new": { + "file": "ZeroParadox/Settheory/Loeb.lean", + "namespace": "ZeroParadox.ProvabilityLogic", + "qualified": "ZeroParadox.ProvabilityLogic.loeb_diagonal_of_loeb_axiom", + "short": "loeb_diagonal_of_loeb_axiom" + }, + "old": { + "file": "ZeroParadox/Settheory/Loeb.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox.ProvabilityLogic", + "qualified": "ZeroParadox.ProvabilityLogic.loeb_diagonal_of_loeb_axiom", + "short": "loeb_diagonal_of_loeb_axiom", + "synthetic": true + }, + "ontology": { + "domain": [ + "logic" + ], + "object": [ + "bottom" + ], + "role": [ + "go" + ] + }, + "reason": "Lane B2 errata 2026-11-01: reverse arrow of Löb in the abstract ProvabilityLogic class (Löb's principle at A as an explicit hypothesis gives □A → A as a Löb diagonal).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -42753,6 +48097,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "637471da-3f10-4b7b-a4a9-ff6993403b61", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_fire", + "short": "det_fire" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_fire", + "short": "det_fire", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -43184,6 +48563,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "64aab034-fea6-4296-a669-04f718746747", + "new": { + "file": "ZeroParadox/Ordinal/Epsilon0MinMax.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0MinMaxStatement", + "short": "epsilon0MinMaxStatement" + }, + "old": { + "file": "ZeroParadox/Ordinal/Epsilon0MinMax.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilon0MinMaxStatement", + "short": "epsilon0MinMaxStatement", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [] + }, + "reason": "errata lane A 2026-10-31: named witnesses and statement controls replacing prose measurements (CARRYW4-C8L-12, CARRY1008-32, CARRY1009-28)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -43369,6 +48783,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "65230bdc-85ec-40cd-85bd-7c007f961b35", + "new": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.mem_ballLine_iff_le_valuation", + "short": "mem_ballLine_iff_le_valuation" + }, + "old": { + "file": "ZeroParadox/Valuation/BallLine.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.mem_ballLine_iff_le_valuation", + "short": "mem_ballLine_iff_le_valuation", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Ball line landed in BallLine.lean: closed balls about 0 of Q_2 indexed by Z, covers at vertices, none at the ends, radius chart", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -43518,6 +48969,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "65c8f592-230a-42ef-af4e-dfcc09ce825d", + "new": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.constPF_nextTime", + "short": "constPF_nextTime" + }, + "old": { + "file": "ZeroParadox/Category/RootCutDegeneracy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.constPF_nextTime", + "short": "constPF_nextTime", + "synthetic": true + }, + "ontology": { + "domain": [ + "category" + ], + "object": [ + "wall-seam" + ], + "role": [ + "scaffolding" + ] + }, + "reason": "Die arc 3 2026-11-01: the seam role (exactly one SelfOnlyAt occupant) per chart: next-time chart of QPF coalgebras, lattice selfApp, module elements / zero object", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -43999,6 +49489,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "66eaab80-c142-4a1d-bfc9-924e71f4d1cb", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy_le_log", + "short": "shannonEntropy_le_log" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.shannonEntropy_le_log", + "short": "shannonEntropy_le_log", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "67285818-6942-4377-b3ce-aa836d29e620", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.allRosolini_of_em", + "short": "allRosolini_of_em" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.allRosolini_of_em", + "short": "allRosolini_of_em", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -44075,6 +49637,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "67531dee-271d-4d86-893c-f2660fb5b548", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.detSeq_eq_true_iff", + "short": "detSeq_eq_true_iff" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.detSeq_eq_true_iff", + "short": "detSeq_eq_true_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -44445,6 +50042,45 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "67f1a59c-f0c5-4a9a-8d6a-b695ef6f6573", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.join_run_never_returns", + "short": "join_run_never_returns" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.join_run_never_returns", + "short": "join_run_never_returns", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [ + "snap" + ], + "role": [ + "no-go" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -44664,6 +50300,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "688915ea-4c54-4185-a58f-fa30e36d9510", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom_fair_iff_le_KPPlain", + "short": "MLRandom_fair_iff_le_KPPlain" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.MLRandom_fair_iff_le_KPPlain", + "short": "MLRandom_fair_iff_le_KPPlain", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -44851,6 +50524,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "68f51cc1-5b74-4b06-86fa-d0a60e3dba0e", + "new": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.dest_cofixSelf", + "short": "dest_cofixSelf" + }, + "old": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.dest_cofixSelf", + "short": "dest_cofixSelf", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -45926,6 +51636,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6b606b15-ca57-4bf0-8ac2-c9d16753b7a3", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.toRos_surjective_iff", + "short": "toRos_surjective_iff" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.toRos_surjective_iff", + "short": "toRos_surjective_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -45999,6 +51744,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6b99fd05-62ce-4a36-b399-cbcd23ea2353", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.compressible_card", + "short": "compressible_card" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.compressible_card", + "short": "compressible_card", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -46152,6 +51934,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6bd56a87-1724-48e7-bdcf-b96c1cbc1623", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instOrderTop", + "short": "instOrderTop" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.instOrderTop", + "short": "instOrderTop", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -46262,6 +52079,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6bf6d0ac-f109-48b2-b042-8cb19635b2fe", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_swaps", + "short": "onePointInv_swaps" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_swaps", + "short": "onePointInv_swaps", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -46705,6 +52559,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "6d11c409-7df9-4031-a4ef-159eb33a3c9c", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_eventuallyConst_iff_not_dyadic", + "short": "not_eventuallyConst_iff_not_dyadic" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_eventuallyConst_iff_not_dyadic", + "short": "not_eventuallyConst_iff_not_dyadic", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -48264,6 +54155,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "70003017-f623-46f2-8a6a-ccc9207cd927", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.phaseUp_coe", + "short": "phaseUp_coe" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.phaseUp_coe", + "short": "phaseUp_coe", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -48486,6 +54414,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "704852da-e2ec-4949-882f-791d3d96c3fc", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.trials_zeroBlock", + "short": "trials_zeroBlock" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.trials_zeroBlock", + "short": "trials_zeroBlock", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -48563,6 +54528,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "70b603f4-5e2a-4350-9129-3713153be5bf", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.Motion.em_of_trichotomy_propStep", + "short": "em_of_trichotomy_propStep" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.Motion.em_of_trichotomy_propStep", + "short": "em_of_trichotomy_propStep", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -48966,6 +54966,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "726bc71b-3701-4943-92b6-78024287ce15", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.shortWords", + "short": "shortWords" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.shortWords", + "short": "shortWords", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -49331,6 +55368,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7331c57d-6c25-4106-b164-0a47227cf497", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefix_of_mem_prefixCyl", + "short": "prefix_of_mem_prefixCyl" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefix_of_mem_prefixCyl", + "short": "prefix_of_mem_prefixCyl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -49408,6 +55482,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "735b1231-9413-4d1f-8bb9-407f0bbfb881", + "new": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding_strictMono", + "short": "epsilonOrZeroToLanding_strictMono" + }, + "old": { + "file": "ZeroParadox/Information/SnapEpsilonZero.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.epsilonOrZeroToLanding_strictMono", + "short": "epsilonOrZeroToLanding_strictMono", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -49704,6 +55815,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "740a6e83-cf00-4b84-9215-a64db696747a", + "new": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_swaps_real", + "short": "onePointInv_swaps_real" + }, + "old": { + "file": "ZeroParadox/Valuation/RiemannSphere.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.onePointInv_swaps_real", + "short": "onePointInv_swaps_real", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "reals" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "RiemannSphere § 0: inversion on OnePoint K over any proper normed field, with ℚ₂ and ℝ instances (ZPQ-REALS-NO-REPAIR-1 evidence, ruling 64)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -49740,6 +55889,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7415f416-3a2e-4bf1-aae8-08d2c8a3ee70", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.blockWord_length", + "short": "blockWord_length" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.blockWord_length", + "short": "blockWord_length", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -50106,6 +56292,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "74ac1b04-6c28-4ef0-964c-784c933f8815", + "new": { + "file": "ZeroParadox/Order/PowerSet.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.psListMem", + "short": "psListMem" + }, + "old": { + "file": "ZeroParadox/Order/PowerSet.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.psListMem", + "short": "psListMem", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lean 4.35 upgrade: new choice-free declarations (rulings 165, 168, 190)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -51426,6 +57649,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "77f9e3d7-389a-4eab-8d10-69bbe14fd010", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.iUnion_mem_option_prefixCyl", + "short": "iUnion_mem_option_prefixCyl" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.iUnion_mem_option_prefixCyl", + "short": "iUnion_mem_option_prefixCyl", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -51502,6 +57762,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "78027330-5a2a-4289-b209-2dbc2d7cfbf8", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofWithTop", + "short": "ofWithTop" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.ofWithTop", + "short": "ofWithTop", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -51801,6 +58096,78 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "788a14b4-6f0b-405a-874b-920b80f86953", + "new": { + "file": "ZeroParadox/Ordinal/OrdinalChoiceEssential.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ordTotalAsWritten", + "short": "ordTotalAsWritten" + }, + "old": { + "file": "ZeroParadox/Ordinal/OrdinalChoiceEssential.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ordTotalAsWritten", + "short": "ordTotalAsWritten", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [] + }, + "reason": "errata lane A 2026-10-31: named witnesses and statement controls replacing prose measurements (CARRYW4-C8L-12, CARRY1008-32, CARRY1009-28)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "78a1974b-0019-4c87-b12a-a32d1a127d5b", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.squaresTape", + "short": "squaresTape" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.squaresTape", + "short": "squaresTape", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -52469,6 +58836,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7a07a1d1-717c-431c-bcd2-19b73fd0f7aa", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.real_zero_infty_connected", + "short": "real_zero_infty_connected" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.real_zero_infty_connected", + "short": "real_zero_infty_connected", + "synthetic": true + }, + "ontology": { + "domain": [ + "reals" + ], + "object": [], + "role": [ + "no-go" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -52616,6 +59020,46 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7a8e9955-a93d-474c-ab36-6f6294c70360", + "new": { + "file": "ZeroParadox/Settheory/Wall.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.zfset_quine_role_unoccupied", + "short": "zfset_quine_role_unoccupied" + }, + "old": { + "file": "ZeroParadox/Settheory/Wall.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.zfset_quine_role_unoccupied", + "short": "zfset_quine_role_unoccupied", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [ + "bottom", + "wall-selfapp" + ], + "role": [ + "no-go" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -53578,6 +60022,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7cb7e747-59c5-4f77-b420-20668f38f770", + "new": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.cofixSelf", + "short": "cofixSelf" + }, + "old": { + "file": "ZeroParadox/Settheory/Coalgebra.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.cofixSelf", + "short": "cofixSelf", + "synthetic": true + }, + "ontology": { + "domain": [ + "set-theory" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lane Q 2026-11-01: the Quine-atom role (SelfOnlyAt) stated in the die, unoccupied in ZFSet, occupied in Cofix idPF_Coalgebra", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -53904,6 +60385,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7d91ffcc-96e2-4d26-b518-fb8bb159b481", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.infty_not_mem_range_ofNat", + "short": "infty_not_mem_range_ofNat" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.infty_not_mem_range_ofNat", + "short": "infty_not_mem_range_ofNat", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55073,6 +61589,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "7f7f9880-b303-4963-8055-bb6a05604e81", + "new": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.z2MulMotion_selfOnlyAt_iff", + "short": "z2MulMotion_selfOnlyAt_iff" + }, + "old": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.z2MulMotion_selfOnlyAt_iff", + "short": "z2MulMotion_selfOnlyAt_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "lane F arc 2: snapEmbed in the die (Incompleteness.lean § I-b)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55331,6 +61884,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "808c7607-01f0-4ad5-8c3c-61ee92ebea72", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl_eq_pi", + "short": "prefixCyl_eq_pi" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.prefixCyl_eq_pi", + "short": "prefixCyl_eq_pi", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55630,6 +62220,83 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "811876cb-6eda-4e8a-8034-36701cc41bba", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ZeroBlockTest", + "short": "ZeroBlockTest" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ZeroBlockTest", + "short": "ZeroBlockTest", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "813bb5f4-d6c7-416c-8c87-1e81c58c8bd2", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.hahnArc_loop", + "short": "hahnArc_loop" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.hahnArc_loop", + "short": "hahnArc_loop", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation" + ], + "object": [ + "bottom", + "ceiling" + ], + "role": [ + "no-go" + ] + }, + "reason": "Probe-2 landed in PolePassage: first step at 0 of an ordered group iff not dense, and the dense-valued HahnSeries control", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55777,6 +62444,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8171b3db-6c7c-4a1f-bd30-b0edb4b320ba", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.nnrealMaxZPS", + "short": "nnrealMaxZPS" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.nnrealMaxZPS", + "short": "nnrealMaxZPS", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55813,6 +62517,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "818bb0fd-85d2-4815-b446-510f29a413b3", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlockTest_silentFrom", + "short": "zeroBlockTest_silentFrom" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlockTest_silentFrom", + "short": "zeroBlockTest_silentFrom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -55849,6 +62590,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "81ac3705-4bd4-4c91-b6ec-a75e86b1aa89", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.covered_limit_searchable", + "short": "covered_limit_searchable" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.covered_limit_searchable", + "short": "covered_limit_searchable", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -56448,6 +63224,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8315444f-0577-44bd-83e5-d9f2a8e23844", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.snap_of_firstStep_MLRandom", + "short": "snap_of_firstStep_MLRandom" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.snap_of_firstStep_MLRandom", + "short": "snap_of_firstStep_MLRandom", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -56958,6 +63771,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "841edb45-c912-4350-8df7-cad9a4e91524", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.no_continuous_test_fires_once", + "short": "no_continuous_test_fires_once" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.no_continuous_test_fires_once", + "short": "no_continuous_test_fires_once", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "no-go", + "face" + ] + }, + "reason": "Weihrauch lane (2026-11-03): CrossingTrials § IX, the Cantor-topology face of the occurrence commitment's slot chart. Continuous tests on ℕ → Bool are exactly those fixed by one finite prefix; fired-at-least-once is open, not closed, and no continuous test decides it (fails at ⊥ of ℕ → Bool). Computable ⇒ continuous cited (Weihrauch 2000 Thm 2.2.3 p. 30), not proved.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -57031,6 +63882,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "843d87ee-f752-4bdd-a076-2db5e50b5b24", + "new": { + "file": "ZeroParadox/Reals/MarkovSpectralGap.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.fairCoinFin2", + "short": "fairCoinFin2" + }, + "old": { + "file": "ZeroParadox/Reals/MarkovSpectralGap.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.fairCoinFin2", + "short": "fairCoinFin2", + "synthetic": true + }, + "ontology": { + "domain": [ + "reals" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lean 4.35 upgrade: new choice-free declarations (rulings 165, 168, 190)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -57555,6 +64443,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "85fb38f0-0134-4eff-ae49-a48abdd114e7", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.compressibleTapes", + "short": "compressibleTapes" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.compressibleTapes", + "short": "compressibleTapes", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -58034,6 +64959,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "86c3f939-1128-47bf-bbab-f802a2985c96", + "new": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.withTopPartialOrderCF", + "short": "withTopPartialOrderCF" + }, + "old": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.withTopPartialOrderCF", + "short": "withTopPartialOrderCF", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lean 4.35 upgrade: new choice-free declarations (rulings 165, 168, 190)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -58369,6 +65331,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "87cbbdd5-64a1-4907-bcea-075632724470", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_of_fires_once", + "short": "t_snap_of_fires_once" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.t_snap_of_fires_once", + "short": "t_snap_of_fires_once", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Occurrence link (2026-11-03): CrossingTrials § VIII — a tape that fired at least once gives t_snap_given's hcc1/hocc by dropping the stutter prefix; firing at least once has measure one; typicality gives firing at least once. hw is the occurrence commitment as an explicit hypothesis.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -58512,6 +65512,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "883c8a96-c645-4fe9-bd24-b9bebc478be9", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.slotRun_isRun", + "short": "slotRun_isRun" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.slotRun_isRun", + "short": "slotRun_isRun", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -58734,6 +65772,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "88ed3fd8-9ef9-4da6-b30b-60426b38eb28", + "new": { + "file": "ZeroParadox/Order/UpAndOver.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.ordinalCornerStep_pinnedLimitAbove", + "short": "ordinalCornerStep_pinnedLimitAbove" + }, + "old": { + "file": "ZeroParadox/Order/UpAndOver.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.ordinalCornerStep_pinnedLimitAbove", + "short": "ordinalCornerStep_pinnedLimitAbove", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "pinned-limit-r2-1103: PinnedLimitAbove (relative least fixed point), closure-ordinal-omega equivalence (Das & Melgaard 2023 Ex. 2.9), uniqueness of the PinnedLimit occupant under omega^, and the eps_(o+1) / corner occupants of the relative form; round-2 gate fixes", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -59168,6 +66241,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8a16f519-12cc-4f15-8efd-6d5f0fc37ea8", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.nat_no_top", + "short": "nat_no_top" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.nat_no_top", + "short": "nat_no_top", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -59318,6 +66426,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8a723cfe-5226-4fba-9b6b-1492e56ac2e9", + "new": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.withTopPreorderCF", + "short": "withTopPreorderCF" + }, + "old": { + "file": "ZeroParadox/Order/ChoiceFreeWithTop.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.withTopPreorderCF", + "short": "withTopPreorderCF", + "synthetic": true + }, + "ontology": { + "domain": [ + "order" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "Lean 4.35 upgrade: new choice-free declarations (rulings 165, 168, 190)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -59612,6 +66757,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8b02710b-0000-42e4-8d82-a77553f528db", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.negS", + "short": "negS" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.negS", + "short": "negS", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -59649,6 +66829,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8b09fde1-f762-4080-82c9-59392dd061cb", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.oneBlock", + "short": "oneBlock" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.oneBlock", + "short": "oneBlock", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Typicality bridge (2026-11-01): CrossingTrials § IV-VII — almost surely gives some run; zero-block tests; typicality as an explicit hypothesis; the slot machine as a die motion.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8b1525de-a5c2-469e-8820-9f112c7b5c2e", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.continuous_of_prefixDetermined", + "short": "continuous_of_prefixDetermined" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.continuous_of_prefixDetermined", + "short": "continuous_of_prefixDetermined", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "go" + ] + }, + "reason": "Weihrauch lane (2026-11-03): CrossingTrials § IX, the Cantor-topology face of the occurrence commitment's slot chart. Continuous tests on ℕ → Bool are exactly those fixed by one finite prefix; fired-at-least-once is open, not closed, and no continuous test decides it (fails at ⊥ of ℕ → Bool). Computable ⇒ continuous cited (Weihrauch 2000 Thm 2.2.3 p. 30), not proved.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -60165,6 +67419,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8c3dd89a-3d43-45ad-9b6f-a5a5eab90378", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.tapeReal", + "short": "tapeReal" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.tapeReal", + "short": "tapeReal", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -60577,6 +67868,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8e4d0870-4726-42b6-9664-81c44f073be2", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.le_def", + "short": "le_def" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.le_def", + "short": "le_def", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -60871,6 +68197,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8f75b651-8657-423f-9d67-3f55777cab14", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.not_continuousAt_bot_of_decides_fires_once", + "short": "not_continuousAt_bot_of_decides_fires_once" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.not_continuousAt_bot_of_decides_fires_once", + "short": "not_continuousAt_bot_of_decides_fires_once", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "no-go" + ] + }, + "reason": "Weihrauch lane (2026-11-03): CrossingTrials § IX, the Cantor-topology face of the occurrence commitment's slot chart. Continuous tests on ℕ → Bool are exactly those fixed by one finite prefix; fired-at-least-once is open, not closed, and no continuous test decides it (fails at ⊥ of ℕ → Bool). Computable ⇒ continuous cited (Weihrauch 2000 Thm 2.2.3 p. 30), not proved.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -61054,6 +68418,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "8fe19ae8-601f-4d73-ab33-da6f799996bd", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.card_shortWords_le", + "short": "card_shortWords_le" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.card_shortWords_le", + "short": "card_shortWords_le", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -62271,6 +69672,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "920d15b3-c238-450d-a20f-cca897299548", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.isSuccLimit_infty", + "short": "isSuccLimit_infty" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.isSuccLimit_infty", + "short": "isSuccLimit_infty", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-pinnedlimit-1103: Tim's die role PinnedLimit (Die.lean § XXIV: role, NInf order + occupant, link, WLPO separation, WithTop control) and the ε₀ occupant (Epsilon0MinMax § III); Tim ruled 2026-11-03", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -62714,6 +70150,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "92ed3fbf-1e54-4cea-9880-06c6919c3c3c", + "new": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.snapEmbedHom", + "short": "snapEmbedHom" + }, + "old": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.snapEmbedHom", + "short": "snapEmbedHom", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "lane F arc 2: snapEmbed in the die (Incompleteness.lean § I-b)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -62752,6 +70225,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "93045c5f-6524-4103-81ae-c7446ccd77fd", + "new": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.PrefixFree", + "short": "PrefixFree" + }, + "old": { + "file": "ZeroParadox/Information/MaxEntropy.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.PrefixFree", + "short": "PrefixFree", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/MaxEntropy.lean (experimental, Tim ruling 154): fair coin maximizes entropy, missing information zero iff fair, chain to mlRandom_and_snap_ae under binEntropy p = log 2, Kraft in measure form, almost every fair tape incompressible for any prefix-free decoder. The occurrence commitment is reduced, not discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -63620,6 +71130,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "95029f86-f17f-4ebd-a01a-c50816479b17", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlockTest_isMLTest", + "short": "zeroBlockTest_isMLTest" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.zeroBlockTest_isMLTest", + "short": "zeroBlockTest_isMLTest", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New file ZeroParadox/Information/TwoRequirements.lean (experimental): BotHasFirstStep (cover of bot of L, AX-B1's form) and tape typicality (zero-block, local Martin-Loef, frequency/strong law) as hypotheses giving t_snap_given_cover's conclusion; tape-to-real dyadic iff. Hypotheses, neither discharged.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -63800,6 +71347,43 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "95812e5c-cf49-4332-bf83-d7fa6b333244", + "new": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.trials_eq_bernoulliMeasure", + "short": "trials_eq_bernoulliMeasure" + }, + "old": { + "file": "ZeroParadox/Information/BrudnoBridge.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.trials_eq_bernoulliMeasure", + "short": "trials_eq_bernoulliMeasure", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "New experimental files ZeroParadox/Information/BrudnoBridge.lean (trials and MLRandom bridged to Milovanov's kolmogorov-complexity-lean, citing his Brudno and Levin-Schnorr theorems) and ZeroParadox/Information/SnapEpsilonZero.lean (snap_of_firstStep_MLRandom instantiated on WithBot Ordinal and on EpsilonOrZero, with an order isomorphism between them).", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -63876,6 +71460,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "95a74722-5848-42b3-9dc2-77470033b22d", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.Motion.wem_of_selectedTotal_propStep", + "short": "wem_of_selectedTotal_propStep" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.Motion.wem_of_selectedTotal_propStep", + "short": "wem_of_selectedTotal_propStep", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-tagged-1101: Prop-step trichotomy/selector reductions (EM, WEM), Rosolini lifting RosPart with toRos onto iff LPO, wlpo_of_discrete_tag (Die §§ VIII, IX, XXIII); Tim authorised 2026-11-01", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -63982,6 +71601,47 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "9604fafb-19bf-458d-8b44-d136d8825bfa", + "new": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.arc_q2Val", + "short": "arc_q2Val" + }, + "old": { + "file": "ZeroParadox/Valuation/PolePassage.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.arc_q2Val", + "short": "arc_q2Val", + "synthetic": true + }, + "ontology": { + "domain": [ + "valuation", + "ordinal" + ], + "object": [ + "bottom", + "ceiling" + ], + "role": [ + "core" + ] + }, + "reason": "Pole-passage probe landed (experimental PolePassage): the snap arc on the 2-adic sphere, its inversion, the clopen separation of 0 and infinity, and the q2Val return", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -64720,6 +72380,44 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "979216c2-b0ac-450d-8f24-22879f40a712", + "new": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.firedRun_isRun", + "short": "firedRun_isRun" + }, + "old": { + "file": "ZeroParadox/Information/CrossingTrials.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.firedRun_isRun", + "short": "firedRun_isRun", + "synthetic": true + }, + "ontology": { + "domain": [ + "information", + "order" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "Occurrence link (2026-11-03): CrossingTrials § VIII — a tape that fired at least once gives t_snap_given's hcc1/hocc by dropping the stutter prefix; firing at least once has measure one; typicality gives firing at least once. hw is the occurrence commitment as an explicit hypothesis.", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -64975,6 +72673,41 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "984b7ed8-e37b-44d1-9339-5c289fdddc32", + "new": { + "file": "ZeroParadox/Die.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_not_injective", + "short": "det_not_injective" + }, + "old": { + "file": "ZeroParadox/Die.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.NInf.det_not_injective", + "short": "det_not_injective", + "synthetic": true + }, + "ontology": { + "domain": [ + "unscoped" + ], + "object": [], + "role": [] + }, + "reason": "die-bend-1104: Tim's \"bend\" (ruling 38): first-occurrence time det as a Galois insertion of tapes onto NInf, order reversed (Die.lean § XXV)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, { "claims": { "citations": [], @@ -65121,6 +72854,80 @@ "sorry_free": true } }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "988bd772-a6dd-4eda-94d0-17a11a42dd25", + "new": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.machineJoinMotion_selfOnlyAt_iff", + "short": "machineJoinMotion_selfOnlyAt_iff" + }, + "old": { + "file": "ZeroParadox/Ordinal/Incompleteness.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.machineJoinMotion_selfOnlyAt_iff", + "short": "machineJoinMotion_selfOnlyAt_iff", + "synthetic": true + }, + "ontology": { + "domain": [ + "ordinal" + ], + "object": [], + "role": [ + "scaffolding" + ] + }, + "reason": "lane F arc 2: snapEmbed in the die (Incompleteness.lean § I-b)", + "verify": { + "axioms": null, + "sorry_free": true + } + }, + { + "claims": { + "citations": [], + "witness_of": [] + }, + "disposition": "new", + "id": "98a1e320-e2ad-4701-9d95-da9179f13284", + "new": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "namespace": "ZeroParadox", + "qualified": "ZeroParadox.mlRandom_and_snap_ae", + "short": "mlRandom_and_snap_ae" + }, + "old": { + "file": "ZeroParadox/Information/TwoRequirements.lean", + "kind": null, + "line": null, + "prefix": "ZeroParadox", + "qualified": "ZeroParadox.mlRandom_and_snap_ae", + "short": "mlRandom_and_snap_ae", + "synthetic": true + }, + "ontology": { + "domain": [ + "information" + ], + "object": [], + "role": [ + "infra" + ] + }, + "reason": "TwoRequirements ensemble form: with BotHasFirstStep L and 0` stays mandatory, but passing it is **not** evidence the ledger is - empty — it checks mechanical preconditions, not open findings. +- `check_release_ready.py ` stays mandatory. Its ledger leg reads the TAGS: a bedrock finding + recorded under the wrong kind or grade passes it, so a green leg is evidence about the ledger as + written, not about the corpus. diff --git a/tools/process/naming-and-labels.md b/tools/process/naming-and-labels.md index 2c263702..6a1238b2 100644 --- a/tools/process/naming-and-labels.md +++ b/tools/process/naming-and-labels.md @@ -22,12 +22,16 @@ When assigning a label, ask: "Is this result the central claim of its section, o ### Readable Name Convention — CC-2 is "the Quine atom" (framework-wide, additive) -**Standing rule (Tim, 2026-06-09).** CC-2 (⊥ = {⊥}, the self-containing bottom) is the conceptual keystone of the framework — it is what forces ZF+AFA, makes ⊥ immune to external description, and is the single contact point between ZFC+Foundation and ZF+AFA. The bare label "CC-2" undersells it on two counts: it reads as a minor sequence code, and the "CC = Conditional Claim" prefix is now **stale** — CC-2 was upgraded to a Forced Metatheoretic Commitment (closed via ZP-J T-EXEC), so it is no longer a conditional claim. This is the same situation AX-1 was in before it became T-SNAP. +**Standing rule (Tim, 2026-06-09).** CC-2 (in ZF+AFA, ⊥ = {⊥}, the self-containing bottom) is the conceptual keystone of the framework — it is what forces ZF+AFA, makes ⊥ immune to external description, and is the single contact point between ZFC+Foundation and ZF+AFA. The bare label "CC-2" undersells it on two counts: it reads as a minor sequence code, and the "CC = Conditional Claim" prefix is now **stale** — CC-2 was upgraded to a Forced Metatheoretic Commitment (closed via ZP-J T-EXEC), so it is no longer a conditional claim. This is the same situation AX-1 was in before it became T-SNAP. **The convention — ADDITIVE, never eliminative:** - Present CC-2 with the readable name **"the Quine atom."** This is a recognized set-theory term (Quine, Aczel) — it carries real gravity and a literature anchor, and it is NOT ZP-invented jargon (avoid inventing a ZP-branded name — that would undo the de-jargoning work). - **Keep "CC-2" as the formal handle and note it alongside** — e.g., "the Quine atom (CC-2)" on first/significant mention. Do NOT remove or rename the CC-2 identifier anywhere; every existing cross-reference stays valid. -- Gloss once per document as "the self-containing bottom, ⊥ = {⊥}." +- Gloss once per document as "the Quine atom (CC-2): the role of a point that steps to itself and to + nothing else, whose occupancy is settled chart by chart." The occupancy theorems are per chart: + `selfApp_quine_role_iff`, `quineAtomHost_quine_role_iff`, `cofix_quine_role_occupied`, + `zfset_quine_role_unoccupied` (unoccupied in `ZFSet`). In ZF+AFA the occupant satisfies `⊥ = {⊥}`; + scope that equation as the next bullet says, never as the gloss. - **⚠ SCOPE THE GLOSS — BANKED 2026-08-01 (Tim), NOT YET ROLLED OUT.** `⊥ = {⊥}` is well-formed and true **in the ZF+AFA metatheory** — that is anti-foundation's actual content and Aczel's Quine atom is a real object, so **do NOT retire it** (a flat retirement would deny a true theorem of a real set @@ -93,9 +97,10 @@ commitment" to one object; it names the **bottom family**. The "MC = Modeling Co (the same arc as AX-1→T-SNAP and CC-2→FMC). The earlier "correspondence derived / identity a commitment" split is superseded: -- **Correspondence half — now formally realized.** Each domain bottom is the categorical bottom - (limit or initial object) of its own *real* Mathlib category: F_B `fB_functor : ℕᵒᵖ ⥤ TopCat` - (⊥ = inverse limit `⋂ B(0,2⁻ⁿ) = {0}`), F_D `fD_functor : ℕ ⥤ ModuleCat ℂ` (⊥ = initial object +- **Correspondence half — now formally realized**, differently per *real* Mathlib category: + F_B `fB_functor : ℕᵒᵖ ⥤ TopCat` (the floor `{0} ⊆ ℚ₂` is the limit of the ball tower, + `floorConeIsLimit`; terminal, `padic_bottom_isTerminal`; not initial, `padic_bottom_not_initial`; + the set equation `⋂ B(0,2⁻ⁿ) = {0}` is `fB_bottom_is_limit`), F_D `fD_functor : ℕ ⥤ ModuleCat ℂ` (⊥ = initial object `StateSpace 0`), F_C `fC_functor : ℕ ⥤ KleisliCat PMF` (⊥ = initial object `Fin 0`, with `fC_no_return` = AX-G2 as a theorem). Bundled witness: `mc1_correspondence` (`MC1Bridge.lean`). So the bare label "MC = Modeling Commitment" now **undersells** this half. diff --git a/tools/process/prior-art.md b/tools/process/prior-art.md index 7bddb413..a7cb777d 100644 --- a/tools/process/prior-art.md +++ b/tools/process/prior-art.md @@ -50,9 +50,9 @@ statement of what the theorem obstructs.** Purity was checked before swapping, p precedent: no regression. **3. One literature search** if the object has a name (Glauber dynamics, coalgebra, covering -relation). **Run the LADDER in § 2a** — it has four rungs and the last one is not optional. +relation). **Run the LADDER in § 2a** — it has five rungs and the last one is not optional. -## 2a. The literature-search LADDER — four rungs, and a citation is not confirmed until rung 4 +## 2a. The literature-search LADDER — papers → theoremsearch (one formal phrasing) → Lean libraries → open web → retrieve; a citation is not confirmed until rung 5 **Adopted 2026-08-23, after calibrating `theoremsearch` (an MCP theorem-statement search over the arXiv-era literature) against cases where this project already knew the answer. The measurements are @@ -63,7 +63,7 @@ once declared Aczel unobtainable while it sat on disk. **Grep loosely** — scan intra-word spaces, so a tight-pattern miss is not evidence of absence. **Rung 2 — `theoremsearch`.** Claim-shaped rather than file-shaped: it matches on *statement*, which is -the thing a title search cannot reach. Three standing rules, each measured: +the thing a title search cannot reach. Five standing rules, each measured: - **THREE PHRASINGS MINIMUM**, along the four axes in § `R-NOTINLIB` (body: `tools/process/not-in-the-library.md`) — POLARITY, PART OF SPEECH, VOCABULARY, DISPLAY. Measured: the noun form put the right theorem at rank 1 and the **verb** form dropped it out of the top 5 entirely, @@ -77,20 +77,48 @@ the thing a title search cannot reach. Three standing rules, each measured: API's confidence. - **A NULL RESULT IS UNINFORMATIVE.** The index is coverage-bounded and the bound is invisible from the result. Never write "no prior art exists" from a rung-2 null; it does not even license - "none located as of <date>" on its own, because rung 3 has not run yet. - -**Rung 3 — the open web.** Runs when rung 2 returns no good match, **and also when it returns a + "none located as of <date>" on its own, because rungs 3 and 4 have not run yet. +- **ONE PHRASING RUNS WITH `formality: "formal"`; `"both"` does not count.** The default is + `"informal"`, so without it no Lean library is searched, and under `"both"` informal hits crowd the + capped list (2026-10-31: a Carleson query returned 6 carleson-repo hits under `"formal"`, 0 under + `"both"`). Coverage, a dated sample (2026-10-31): hits in Mathlib, pfr, carleson, FLT, + HarderNarasimhan; misses on the probes run, teorth/equational_theories and this repository. A formal + null is coverage-bounded. +- **A TOOL PRESENT BUT REFUSED IS NOT RUN, NEVER A NULL** — by the permission mode, or by an error that + is not a rate limit. Record the refusal message verbatim (2026-10-31: every rung-2 call of one review + was refused by the permission mode). + +**Rung 3 — Lean libraries, always run.** LeanExplore (Justin Asher, arXiv:2506.11085): `search_summary`, +two phrasings minimum (`packages=[...]` narrows to named packages), then `get_source_code` on any +candidate plus its elaborated type, because the returned text can omit section binders (2026-10-31: +`OrderHom.lfp` lost `[CompleteLattice α]`). Inside this project's dependency closure, running it is the +only route: `#check` and `exact?` in a scratchpad `.lean`, run with `lake env lean ` from +the repo root. Outside it (FLT, carleson, pfr), Tim ruled 2026-10-31 that the source file read via +`get_source_link`, section `variable` lines included, is cited **PARTLY VERIFIED: source read, type not +elaborated**. `get_dependencies` returns a partial list as a JSON-encoded string (2026-10-31: for +`Nat.Partrec.Code.fixed_point₂`, some statement constants, but not `Partrec₂` from its hypothesis, nor +the proof's constants), and LeanExplore's snapshot is not the pinned Mathlib, so confirm a hit at the pin. +Then GitHub code search with `extension:lean`, not `language:Lean` (2026-10-31: 9 files against 0), +`perPage` ≤ 10 and `-repo:timbrigham/ZeroParadox`, for the Reservoir long tail (about 920 packages, +2026-10-31). The LeanExplore half may be recorded NOT RUN if the tools are unavailable or refused; the +code search is always required. Its null is uninformative too; both services are rate-limited, and only +a rate-limit response is a wait. A Lean-only prior art is cited by repository, declaration name and +commit read, plus that verification status. Full rules: `.claude/commands/prior-art-review.md`, rung B2. + +**Rung 4 — the open web.** Runs when rung 2 returns no good match, **and also when it returns a neighbourhood hit whose actual source needs identifying**. This is where everything pre-arXiv lives — Lawvere 1969, Aczel 1988, Ostrowski, Gentzen, Carlström — and `theoremsearch` structurally cannot return -those as sources, only as things other people cite. Skipping rung 3 on a rung-2 null is how a coverage +those as sources, only as things other people cite. Skipping rung 4 on a rung-2 null is how a coverage gap becomes a recorded novelty claim. -**Rung 4 — RETRIEVE AND READ THE FULL DOCUMENT.** File it in `papers/` as `author_topic_year[_id].pdf`, +**Rung 5 — RETRIEVE AND READ THE FULL DOCUMENT.** File it in `papers/` as `author_topic_year[_id].pdf`, **validating before filing** (a tiny PDF is an error page, not a paper). **A citation is not confirmed until this rung.** Draft-from-source is unchanged by any of the above: existence may be cited freely; a source's *content* may not be asserted without the passage in hand. -⚠ **RUNGS 1-3 ARE DISCOVERY. ONLY RUNG 4 IS VERIFICATION.** The ladder makes finding candidates +⚠ **RUNGS 1-4 ARE DISCOVERY. ONLY RUNG 5 IS VERIFICATION.** For a Lean declaration, rung 5's +retrieval is its source text plus its elaborated type; outside the dependency closure it reaches only +PARTLY VERIFIED. The ladder makes finding candidates cheaper; it does not make any of them citable. See § 2b for the measurement that settles this. ## 2b. Why the ladder is shaped this way — the calibration, 2026-08-23 @@ -105,8 +133,8 @@ content-exact statements. Veltri, Ahrens–Capriotti–Spadotti and Yanofsky wer **Coverage is real and provable.** arXiv:2104.02549 is **verifiably absent** from the index while sitting in `papers/`. So a gate blocking on "no prior art found" would have returned clear for a claim whose prior -art this project is physically holding. ⚠ `paper_filter` takes a **TITLE, not an arXiv id** — passing an -id returns empty, which reads exactly like absence. Verify the filter before believing its zero. +art this project is physically holding. `paper_filter` needs a FULL arXiv id, despite the schema's "prefix": +on 2026-10-31 `0801.209` returned empty and `0801.2097` hit. Verify the filter before believing its zero. **Precision: one correct abstention, and one control that was itself wrong.** The two-forks universal negative (`ZeroParadox/Algebra/WheelFrac.md`) drew only unrelated combinatorics — correct abstention. @@ -122,8 +150,10 @@ arXiv:2104.02549 — *"≤ is connex, `(X≤Y) ⊎ (X≥Y)`"* ⟹ LEM. **From th as Thm 38(d) renumbered for the journal version. Opening the PDF on disk shows they are different statements** — connexity versus splitting. Trusting the body would have produced a wrong citation. -Three reasons the body is not a passage, all observed: `label` and `link` come back **null**, so there is -no in-paper locator and numbering shifts between versions of one work; the `slogan` field is an **LLM +Three reasons the body is not a passage, all observed: the `name` field carries the in-paper label on +arXiv hits (2026-10-31, `paper_filter="0801.2097"`: Miller's own labels, two distinct statements both +"Theorem 2" because an appendix restarts the numbering), but numbering is version-specific and +unverified until the source is open, and `link` is **null** on Lean Repo hits; the `slogan` field is an **LLM paraphrase** sitting beside the body and is the most quotable thing on the screen; and ambient hypotheses are inconsistently present — sometimes in the body (*"If H preserves monomorphisms…"*), sometimes not, which is precisely the AMM Thm 8.1 trap this project already records (those conditions are the @@ -131,8 +161,8 @@ which is precisely the AMM Thm 8.1 trap this project already records (those cond ⚠ **WHY THIS IS NOT A GATE, and the reasoning transfers to the next such tool.** A gate must be able to fail informatively. Here a null is uninformative (coverage) and a hit is a candidate, not a finding — so -enforcement would manufacture the appearance of coverage, which is `RLY25-1` exactly. This is the rung-5 -shape from § *WHEN A FAILURE RECURS*: **the screen may replace the ENUMERATION, never the VERDICT.** +enforcement would manufacture the appearance of coverage, which is `RLY25-1` exactly. This is rung 5 of +the recurrence escalation ladder (`R-NOCONV`), not of the literature ladder above: **the screen may replace the ENUMERATION, never the VERDICT.** ⚠ **ITS CONTROLS SHIP WITH IT**, per the `check_checkers.py` move — the control is the deliverable. The two standing controls are the WheelFrac two-forks negative (must return nothing usable) and a Lawvere / @@ -268,9 +298,10 @@ free analyticity lemmas, and the standard NAME for a thing described longhand. name you would never have guessed, and it reaches the attribute-generated siblings (`@[to_dual]`, `@[simps]`) that have **no source line to grep**. 3. **One literature search** if the object has a name — **run the LADDER in order: `.claude-local/papers/` - → `theoremsearch` → the open web → RETRIEVE THE FULL DOCUMENT.** Three phrasings minimum at - `theoremsearch`; ignore its similarity score; **its null is UNINFORMATIVE** (coverage-bounded). - **Rungs 1–3 are DISCOVERY, only rung 4 is VERIFICATION** — a returned body is not a passage in hand. + → `theoremsearch` (one phrasing `formality: "formal"`) → Lean libraries (LeanExplore, GitHub + `extension:lean`) → the open web → RETRIEVE THE FULL DOCUMENT.** Three phrasings minimum at + `theoremsearch`; ignore its similarity score; **every null is UNINFORMATIVE** (coverage-bounded). + **Rungs 1–4 are DISCOVERY, only rung 5 is VERIFICATION** — a returned body is not a passage in hand. 📖 `tools/process/prior-art.md` §§ 2a–2b. **⚠ AND WHEN YOU FETCH A SOURCE, FILE IT** — `.claude-local/papers/`, named diff --git a/tools/process/unstated-adjacency.md b/tools/process/unstated-adjacency.md index c6365fd4..cbf66fef 100644 --- a/tools/process/unstated-adjacency.md +++ b/tools/process/unstated-adjacency.md @@ -41,8 +41,9 @@ lands on, not five sections away. are free** — a theorem over `σ → Option σ` is elementary *because* it covers everything, and covering everything is the payoff; state both halves. (2) **Adjacency is not identity.** "Turing machines are witnesses" is licensed; "the bottom is a Turing machine" is a cross-carrier identity and the same type -boundary as everywhere else. The `QuineHost` precedent is the model: never "we commit to AFA", always "here -are the requirements, and AFA is a witness meeting them." +boundary as everywhere else. The `QuineHost` precedent is the model: "here are the requirements, and AFA +is a witness meeting them" states the adjacency, and that adopting AFA is CC-2's commitment (Tim, +2026-11-03) is stated beside it as a commitment, never as "the bottom is the AFA set". ### ⭐ THE TWO RULES ABOVE AND BELOW PULL OPPOSITE WAYS. The resolution: ONE LINE at the site, the FULL STATEMENT at the canonical home. (Tim, 2026-08-15.) diff --git a/tools/verify/check_release_ready.py b/tools/verify/check_release_ready.py index cc902706..b9b554b7 100644 --- a/tools/verify/check_release_ready.py +++ b/tools/verify/check_release_ready.py @@ -10,6 +10,11 @@ Exit 1 = one or more blocking checks failed -> NO-GO. Exit 2 = usage error. + python check_release_ready.py --ledger-only [--defects PATH] +runs only the defect-ledger leg (the release rule: no open content BEDROCK / BEDROCK-CANDIDATE +unit and no untagged open unit in DEFECTS.md): exit 0 CLEAR, 1 BLOCKED, 3 UNREADABLE. `--defects` +overrides the ledger path in either mode; by default it is the MAIN checkout's .claude-local. + Design: the deterministic checks are auto-verified and split into [FAIL] blocking, high-confidence, unambiguous; [WARN] best-effort / fragile-to-parse / hygiene -> surfaced, not blocking; @@ -109,6 +114,14 @@ def norm_ver(v): } +def take_exempt(path): + """True if `path` owes no take: a TAKE_EXEMPT basename, or any `Vendored` directory component + (Tim, ruling 81: "The "vendored" folder should be overridden as needed... None of it should + need a take.").""" + parts = path.replace('\\', '/').split('/') + return parts[-1] in TAKE_EXEMPT or 'Vendored' in parts[:-1] + + def c_engineers_takes(): """Every ZP-X Lean file carries a filled Engineer's Take. @@ -126,7 +139,7 @@ def c_engineers_takes(): if '.lake' in norm: continue base = os.path.basename(norm) - if base in TAKE_EXEMPT: + if take_exempt(norm): continue txt = read(path) for pat in ('TODO (Tim)', 'TODO: Engineer'): @@ -408,6 +421,179 @@ def c_untracked_pdfs(): return not pdfs +# --------------------------------------------------------------------------- the defect ledger +# +# The release rule (Tim, 2026-10-08, made permanent 2026-10-30): a release blocks only on OPEN +# `DEFECTS.md` units tagged CONTENT and BEDROCK (BEDROCK-CANDIDATE included, until graded). Content +# is what ships: the root PDFs and the prose of `scripts/build_*.py`, `ZeroParadox/**`, root `.md`, +# `.zenodo.json`, the HTML pages. ORDINARY content findings ship as public erratum issues; tooling, +# published-process (`.claude/commands/**`) entries and Tim-gated questions do not block. +# +# The open-unit test is the one printed in DEFECTS.md's own header, applied verbatim: a heading +# (`##` to `#####`) is open if it carries the word OPEN and none of the closing words, or says +# PARTLY CLOSED / still OPEN; a table row whose first cell is a bold or backticked id is judged by the +# same test over its first two cells. An open unit whose tag cannot be read cannot be graded, so it +# FAILS CLOSED rather than being folded into a bucket. + +DEFECTS_REL = os.path.join('.claude-local', 'DEFECTS.md') +CLOSING_WORDS = ('CLOSED', 'WITHDRAWN', 'RESOLVED', 'RETRACTED', 'SUPERSEDED', 'DISCHARGED', 'ACCEPTED') +_HEADING = re.compile(r'^(#{2,5})\s+(.*)$') +_ROW = re.compile(r'^\|\s*(\*\*[^*|]+\*\*|`[^`|]+`)\s*\|([^|]*)\|') +_TAG = re.compile(r'\[([a-z][a-z+-]*)\s*·\s*([^\]]+)\]') +_SEVERITIES = ('BEDROCK', 'BEDROCK-CANDIDATE', 'ORDINARY') +_KINDS = ('content', 'tooling', 'published-process') + +# R-ZERONULL: three distinct VALUES, never one value with three messages. +LEDGER_CLEAR = 'CLEAR' # read, and no open content bedrock / untagged unit +LEDGER_BLOCKED = 'BLOCKED' # read, and at least one blocking unit +LEDGER_UNREADABLE = 'UNREADABLE' # not read at all; NOT evidence of a clear ledger + + +def defects_path(): + """(path, how) - DEFECTS.md in the MAIN checkout's `.claude-local`. + + `.claude-local` is its own gitignored repository, so a worktree does not carry it; the main + checkout is the parent of the shared git directory, which is the same answer from either. `None` + for the path means the location could not be derived, and the caller reports it as UNREADABLE.""" + rc, out = git('rev-parse', '--path-format=absolute', '--git-common-dir') + if rc == 0 and out.strip(): + main_root = os.path.dirname(os.path.normpath(out.strip())) + return os.path.join(main_root, DEFECTS_REL), 'main checkout (from the shared git dir)' + return None, 'main checkout could not be derived (rev-parse exit %s)' % rc + + +def _is_open(text): + if 'PARTLY CLOSED' in text or re.search(r'\bstill OPEN\b', text): + return True + if not re.search(r'\bOPEN\b', text): + return False + return not any(re.search(r'\b%s\b' % w, text) for w in CLOSING_WORDS) + + +def _grade(tag_kind, tag_sev): + """(kind, severity) for one tag, or None if either half is unreadable. + + Kind: anything naming `content` (`content+tooling` included) is content, because content is what + ships and the worse reading wins; `published-process` is itself; `tooling` and the bare `process` + are tooling (the ruling: tooling is everything else). Severity: any BEDROCK-prefixed grade is + bedrock (`BEDROCK-class` included), CANDIDATE kept apart; any ORDINARY-prefixed grade is ordinary + (`ORDINARY (recorded BLOCKING)` included - the audit's scale has no BLOCKING grade).""" + k = tag_kind.strip() + if 'content' in k.split('+'): + kind = 'content' + elif k == 'published-process': + kind = 'published-process' + elif k in ('tooling', 'process'): + kind = 'tooling' + else: + return None + s = tag_sev.strip().upper() + if s.startswith('BEDROCK'): + sev = 'BEDROCK-CANDIDATE' if s.startswith('BEDROCK-CANDIDATE') or s.startswith('BEDROCK CANDIDATE') \ + else 'BEDROCK' + elif s.startswith('ORDINARY'): + sev = 'ORDINARY' + else: + return None + return kind, sev + + +def _rank(g): + """Lower is more blocking: a release-blocking grade first, then by severity, content first.""" + blocks = g[0] == 'content' and g[1] != 'ORDINARY' + return (not blocks, _SEVERITIES.index(g[1]), g[0] != 'content') + + +def _unit_grade(text): + """The most blocking readable tag in `text`, or None when no tag reads.""" + grades = [g for g in (_grade(m.group(1), m.group(2)) for m in _TAG.finditer(text)) if g] + return min(grades, key=_rank) if grades else None + + +def scan_defects(text): + """{'units': [(line_no, kind, sev, label)], 'untagged': [(line_no, label)]} over open units.""" + units, untagged = [], [] + fence = False + for n, raw in enumerate(text.splitlines(), 1): + ln = raw.rstrip() + if ln.lstrip().startswith('```'): + fence = not fence + continue + if fence: + continue + m = _HEADING.match(ln) + if m: + judged, label = m.group(2), m.group(2) + else: + r = _ROW.match(ln) + if not r: + continue + judged, label = r.group(1) + ' | ' + r.group(2), r.group(1) + if not _is_open(judged): + continue + label = label.strip()[:90] + g = _unit_grade(ln) + if g is None: + untagged.append((n, label)) + else: + units.append((n, g[0], g[1], label)) + return {'units': units, 'untagged': untagged} + + +def c_defects_ledger(path=None): + """The release rule, mechanically. Returns (status, detail, counts, path_read). + + `status` is one of LEDGER_CLEAR / LEDGER_BLOCKED / LEDGER_UNREADABLE. A missing or unreadable + ledger is UNREADABLE - a distinct value from CLEAR, failing the gate with its own message, + because an absent list of defects is not a list with no defects in it.""" + how = 'given on the command line' + if path is None: + path, how = defects_path() + if path is None: + fail('Defect ledger UNREADABLE - %s; a release cannot be graded without it' % how) + return LEDGER_UNREADABLE, how, None, None + try: + text = read(path) + except (OSError, UnicodeDecodeError) as exc: + fail('Defect ledger UNREADABLE - %s (%s): %s. This is NOT a clear ledger' + % (path, how, exc.__class__.__name__)) + return LEDGER_UNREADABLE, str(exc), None, path + res = scan_defects(text) + counts = {(k, s): 0 for k in _KINDS for s in _SEVERITIES} + for _, k, s, _ in res['units']: + counts[(k, s)] += 1 + counts['untagged'] = len(res['untagged']) + blocking = [u for u in res['units'] if u[1] == 'content' and u[2] in ('BEDROCK', 'BEDROCK-CANDIDATE')] + for n, k, s, label in blocking: + fail('Open content %s defect (DEFECTS.md:%d) - %s' % (s, n, label)) + for n, label in res['untagged']: + fail('Open defect with no readable [kind · SEVERITY] tag (DEFECTS.md:%d) - cannot be graded, ' + 'so it blocks - %s' % (n, label)) + for n, k, s, label in res['units']: + if k != 'content' and s != 'ORDINARY': + warn('Open %s %s defect (DEFECTS.md:%d, does not block a release) - %s' % (k, s, n, label)) + ordc = counts[('content', 'ORDINARY')] + if ordc: + warn('%d open ORDINARY content defect(s) - owed as public erratum issues (or fixes), not a ' + 'release blocker' % ordc) + status = LEDGER_BLOCKED if (blocking or res['untagged']) else LEDGER_CLEAR + detail = '%d blocking (content bedrock %d, untagged %d)' % ( + len(blocking) + len(res['untagged']), len(blocking), len(res['untagged'])) + return status, detail, counts, path + + +def print_defect_counts(counts): + print(' open units by kind x severity (the rule in DEFECTS.md\'s header):') + print(' %-18s %8s %18s %9s %6s' % ('kind', 'BEDROCK', 'BEDROCK-CANDIDATE', 'ORDINARY', 'total')) + grand = 0 + for k in _KINDS: + row = [counts[(k, s)] for s in _SEVERITIES] + grand += sum(row) + print(' %-18s %8d %18d %9d %6d' % (k, row[0], row[1], row[2], sum(row))) + print(' %-18s %8s %18s %9s %6d' % ('untagged', '', '', '', counts['untagged'])) + print(' %-18s %8s %18s %9s %6d' % ('all open units', '', '', '', grand + counts['untagged'])) + + # --------------------------------------------------------------------------- runner def line(status, name, detail=''): @@ -483,6 +669,60 @@ def selftest(): git = real_git fails[:], warns[:] = saved + # The release rule's open-unit and grade reading, over in-memory ledgers. + print(' DEFECT LEDGER (MUST FIRE on content bedrock / untagged, MUST SUPPRESS the rest)') + + def _blocks(text): + r = scan_defects(text) + return bool(r['untagged']) or any(k == 'content' and s != 'ORDINARY' for _, k, s, _ in r['units']) + for label, text, want in ( + ('open content BEDROCK blocks', '## X-1 - **OPEN** `[content · BEDROCK]`\n', True), + ('open BEDROCK-class blocks', '#### X-2 OPEN `[content · BEDROCK-class]`\n', True), + ('open content CANDIDATE blocks', '## X-3 OPEN [content · BEDROCK-CANDIDATE]\n', True), + ('open untagged heading blocks', '## X-4 - **OPEN 2026-10-31**\n', True), + ('open bedrock table row blocks', '| **X-5** | OPEN | f `[content · BEDROCK]` |\n', True), + ('PARTLY CLOSED bedrock blocks', '## X-6 PARTLY CLOSED [content · BEDROCK]\n', True), + ('closed content BEDROCK passes', '## X-7 **CLOSED** (was OPEN) [content · BEDROCK]\n', False), + ('open content ORDINARY passes', '## X-8 OPEN [content · ORDINARY]\n', False), + ('open tooling BEDROCK passes', '## X-9 OPEN [tooling · BEDROCK]\n', False), + ('fenced heading is not a unit', '```\n## X-10 OPEN\n```\n', False)): + ok = _blocks(text) is want + bad += 0 if ok else 1 + print(' %-34s %s' % (label, 'ok' if ok else '*** WRONG ***')) + saved = (fails[:], warns[:]) + try: + st = c_defects_ledger(os.path.join(HERE, 'no-such-dir', 'DEFECTS.md'))[0] + finally: + fails[:], warns[:] = saved + ok = st == LEDGER_UNREADABLE and st != LEDGER_CLEAR + bad += 0 if ok else 1 + print(' %-34s %s' % ('missing ledger is UNREADABLE', 'ok' if ok else '*** got %s ***' % st)) + + # Ruling 81: a take-less file under a `Vendored` directory passes; a take-less file elsewhere + # still fails. Driven through c_engineers_takes over a temp tree, so the exemption is RUN. + print(' ENGINEER\'S TAKE (MUST SUPPRESS Vendored/, MUST FIRE elsewhere)') + import tempfile + global LEAN_GLOB + real_glob = LEAN_GLOB + saved = (fails[:], warns[:]) + try: + with tempfile.TemporaryDirectory() as td: + for label, rel, want in ( + ('take-less Vendored file passes', 'Vendored/X.lean', True), + ('take-less non-vendored file fails', 'Order/X.lean', False)): + d = os.path.join(td, label.replace(' ', '_')) + os.makedirs(os.path.dirname(os.path.join(d, rel))) + with open(os.path.join(d, rel), 'w', encoding='utf-8') as f: + f.write('theorem t : True := trivial\n') + LEAN_GLOB = os.path.join(d, '**', '*.lean') + got = c_engineers_takes() + ok = got is want + bad += 0 if ok else 1 + print(' %-34s %s' % (label, 'ok' if ok else '*** got %s ***' % got)) + finally: + LEAN_GLOB = real_glob + fails[:], warns[:] = saved + print('\n selftest: %s' % ('PASS' if not bad else 'FAIL (%d)' % bad)) return 1 if bad else 0 @@ -493,8 +733,31 @@ def main(): print('ZP Release-Readiness Gate - CONTROLS') print('=' * 64) return selftest() + defects_override = None + if '--defects' in args: + i = args.index('--defects') + if i + 1 >= len(args): + print('usage: --defects needs a path') + return 2 + defects_override = args[i + 1] + del args[i:i + 2] + if args and args[0] == '--ledger-only': + # The defect-ledger leg alone. Exit 0 CLEAR, 1 BLOCKED, 3 UNREADABLE - three values, so a + # caller branching on the code cannot read an unread ledger as a clear one. + st, detail, counts, path = c_defects_ledger(defects_override) + print('defect ledger: %s - %s' % (st, detail)) + print(' %s: %s' % ('COULD NOT READ' if st == LEDGER_UNREADABLE else 'read', + path or '(no path derived)')) + if counts is not None: + print_defect_counts(counts) + for w in warns: + print(' ! %s' % w) + for f in fails: + print(' X %s' % f) + return {LEDGER_CLEAR: 0, LEDGER_BLOCKED: 1, LEDGER_UNREADABLE: 3}[st] if not args or args[0].startswith('-'): - print('usage: python %s (e.g. v2.7)' % SELF) + print('usage: python %s [--defects PATH] (e.g. v2.7)' % SELF) + print(' python %s --ledger-only [--defects PATH]' % SELF) return 2 tag = args[0] @@ -511,6 +774,14 @@ def main(): line('PASS' if c_conflict_markers() else 'FAIL', 'No conflict markers (tracked files)') line('PASS' if c_releases_entry(tag) else 'FAIL', f'RELEASES.md has "## {tag}" entry') line('PASS' if c_doc_links() else 'FAIL', 'README/GUIDE linked PDFs exist') + d_status, d_detail, d_counts, d_path = c_defects_ledger(defects_override) + line({LEDGER_CLEAR: 'PASS', LEDGER_BLOCKED: 'FAIL', LEDGER_UNREADABLE: 'FAIL'}[d_status], + 'No open content BEDROCK / BEDROCK-CANDIDATE or untagged defect', + '%s: %s' % (d_status, d_detail)) + print(' %s: %s' % ('COULD NOT READ' if d_status == LEDGER_UNREADABLE else 'read', + d_path or '(no path derived - see the failure below)')) + if d_counts is not None: + print_defect_counts(d_counts) print('BEST-EFFORT / HYGIENE (warn-only):') line('PASS' if c_register_vs_script_version() else 'WARN', 'register <-> script VERSION') @@ -537,6 +808,9 @@ def main(): 'Companion synced for every formal doc whose version bumped.', 'Major-vs-minor version decision is correct; Lean-only-change release question raised if applicable.', '.zenodo.json description reflects this release (cannot be updated retroactively).', + 'Every open ORDINARY content finding in DEFECTS.md is fixed or on a public erratum issue ' + '(labels erratum, open question), its issue number beside the ledger row. No bedrock item ' + 'is filed as an erratum, and no grade was lowered to make this release.', 'Release body drafted and Tim approved it BEFORE `gh release create`.', 'Post-release: confirm the Zenodo snapshot minted. README badge is the CONCEPT DOI ' '(auto-resolves to latest) - NO per-release badge edit needed.', diff --git a/tools/verify/required.v2.json b/tools/verify/required.v2.json index 0a602878..e88ba078 100644 --- a/tools/verify/required.v2.json +++ b/tools/verify/required.v2.json @@ -89,6 +89,11 @@ "scope": [ "ZeroParadox/*.lean" ], + "scope_exclude": [ + "ZeroParadox/Vendored/*", + "ZeroParadox/Ordinal/NaturalOpsPow.lean" + ], + "_scope_exclude_why": "Tim, 2026-11-01 (AskUserQuestion, 'Narrow ledger scope'): the checker skips vendored files by design (`is_vendored`: anything under Vendored/ plus the backports listed in tools/verify/vendored_files.txt) and the pre-push hook reports them exempt, but the registry scope still counted them, so a push changing a vendored header could never be satisfied by any run. This mirrors the existing written exemption; it adds none. ⚠ Keep this list in step with tools/verify/vendored_files.txt — a backport added there must be added here.", "reason": "reads the LEAN CORPUS only -- it walks the tree and takes fn.endswith('.lean'), so its verdict is about ZeroParadox/*.lean (218 files) and nothing else. With no declared scope the registry's strict default bound it to all 504 tracked paths, so it recorded ~218 of 504 for ever and re-running reproduced it identically; the gap was a missing DECLARATION, not a producer that skipped work. NB the glob is `ZeroParadox/*.lean` and NOT `ZeroParadox/**/*.lean`: `**/` requires at least one '/' and drops the five files directly under ZeroParadox/ (AxiomProfile, BottomCannotBe, ClaimsMirror, DiagonalFixedPoint, Miniature) -- three of which R-COREOBJ names as authoritative -- while rendering as 213/213 COMPLETE. Measured 2026-08-26." }, "check_pov": { @@ -129,6 +134,11 @@ "scope": [ "ZeroParadox/*.lean" ], + "scope_exclude": [ + "ZeroParadox/Vendored/*", + "ZeroParadox/Ordinal/NaturalOpsPow.lean" + ], + "_scope_exclude_why": "Same as check_prose._scope_exclude_why (Tim, 2026-11-01): mirrors the checker's own `is_vendored` exemption; adds none. Keep in step with tools/verify/vendored_files.txt.", "reason": "reads the LEAN CORPUS only -- it walks the tree and takes fn.endswith('.lean'), so its verdict is about ZeroParadox/*.lean (218 files) and nothing else. With no declared scope the registry's strict default bound it to all 504 tracked paths, so it recorded ~218 of 504 for ever and re-running reproduced it identically; the gap was a missing DECLARATION, not a producer that skipped work. NB the glob is `ZeroParadox/*.lean` and NOT `ZeroParadox/**/*.lean`: `**/` requires at least one '/' and drops the five files directly under ZeroParadox/ (AxiomProfile, BottomCannotBe, ClaimsMirror, DiagonalFixedPoint, Miniature) -- three of which R-COREOBJ names as authoritative -- while rendering as 213/213 COMPLETE. Measured 2026-08-26." }, "check_invariants": {