import Mathlib.Algebra.Order.Field.Basic import Mathlib.Order.Cover import Mathlib.Data.Real.Basic /-! # ZP-F: The Real Numbers as Counterexample ## Engineer's Take Any numerical system — notably the reals or the rationals — is structurally incapable of modeling the snap. They represent continuity to infinite regression. While amazing tools at macro scales, they assume continuity that simply does not exist at the scale that we are evaluating. It's almost like the break between quantum physics and Newtonian. --- ## Formal Overview (AI-assisted) The Binary Snap requires a setting where halving does not undercut every candidate first step. ℝ fails that test by construction — so does any field with a compatible linear order ([Field F] [LinearOrder F] [IsStrictOrderedRing F]). In ℚ₂ the halving argument does not apply (dividing by 2 moves AWAY from zero, lowering the valuation), and v₂(0) = +∞ while every non-zero element has finite valuation. **That removes the obstruction; it does not supply a first step** — the 2-adic norms still accumulate at zero (‖2ⁿ‖₂ = 2⁻ⁿ), so zero is a limit of the non-zero elements there, not isolated from them. The first step is AX-B1 (§ 0), a commitment. **General case (any [Field F] [LinearOrder F] [IsStrictOrderedRing F]):** F-DENSITY : ∀ ε : F, 0 < ε → 0 < ε/2 ∧ ε/2 < ε F-NO-MIN : F has no minimal positive element F-SNAP-BLOCKED : Any candidate first step from 0 in F can be halved F-SNAP-IMPOSSIBLE: The Binary Snap cannot occur in any LinearOrderedField **Real numbers (ℝ, the canonical instance):** R-DENSITY, R-NO-MIN, R-SNAP-BLOCKED, R-SNAP-IMPOSSIBLE follow as corollaries by instantiating F = ℝ. All results follow from the LinearOrderedField axioms — no topology, no measure theory. -/ namespace ZeroParadox /-! ### General case: any LinearOrderedField -/ /-! ## § 0. AX-B1 AS AN EXPLICIT COMMITMENT **The framework's one substantive modelling commitment is DISCRETENESS**, and until now it was in the least visible of the three encodings (CLAUDE.md, "Commitments Go In HYPOTHESES"): baked into a carrier. `ax_b1_distinct : nullState ≠ firstAtomicState := by decide` only checks that the two constructors of a two-element type differ — **it does not check the choice of a discrete alphabet over a continuum**, which is the actual commitment. Stated as a predicate, the commitment becomes visible at every use site, and something else falls out for free: **it is exactly what the reals lack.** `f_snap_impossible` in this same file proves no ordered field has it. The commitment and its counterexample are now the same proposition, in opposite directions. The ZP-C forcing lemmas (`pmf_subsingleton_isPure`, `binaryState_exhaustive`) discharge the "no half-state" worry — leaving ⊥ needs a second outcome — but they force only the ≥ 2 lower bound. **The residual commitment is that the outcome space is DISCRETE, and that is `HasFirstStep`.** -/ section AxB1 /-- **AX-B1, in standard order-theoretic vocabulary: the bottom is COVERED by something.** Mathlib's `CovBy` (notation `a ⋖ b`) says `b` is directly above `a` with nothing strictly between. The framework's discreteness commitment is exactly `∃ a, bot ⋖ a`, so AX-B1 is kept as the name and `CovBy` supplies the content and the lemmas. **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_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. **Second standard name, pointer only (added 2026-08-02).** Where a bottom element exists, `bot ⋖ a` is Mathlib's notion of `a` being an **atom**: `bot_covBy_iff` (`Mathlib/Order/Atoms.lean`) states `⊥ ⋖ a ↔ IsAtom a`, so `HasFirstStep bot` says **the order has an atom** (`∃ a, IsAtom a`). *(Not "AX-B1 is atomicity": `IsAtomic` is strictly stronger — it requires every non-bottom element to sit above an atom, which `bot_covBy_iff` does not give. Corrected 2026-08-02.)* Before this note the framework had been describing a named order-theoretic notion longhand; **measure the corpus count on demand rather than recording one here** — a count written at the site of the only mentions falsifies itself, which the first draft of this very note did by asserting "zero". **The match is NOT exact, which is why this is a pointer and not a redefinition:** `bot_covBy_iff` needs `[PartialOrder α] [OrderBot α]`; `HasFirstStep` needs only `[LT α]`, and `axb1_fails_in_ordered_field` below has no `OrderBot` at all — an ordered field has no bottom, so the atom framing does not even apply to the counterexample that does the work here. `IsAtomless` (which would state the ordered-field side directly) **is not in this Mathlib pin**. -/ def HasFirstStep {α : Type*} [LT α] (bot : α) : Prop := ∃ a, bot ⋖ a -- `Statement:` AX-B1 at a state `a` is AX-B1 at the bottom of its up-set `Set.Ici a`. -- Mathlib's `covBy_iff_atom_Ici` (`Mathlib/Order/Atoms.lean`) is the standard framing: a cover of `a` -- is an atom of `Set.Ici a`. example {α : Type*} [PartialOrder α] (a : α) : HasFirstStep (⟨a, le_rfl⟩ : Set.Ici a) ↔ HasFirstStep a := by have key : ∀ (b : α) (h : a ≤ b), ((⟨a, le_rfl⟩ : Set.Ici a) ⋖ ⟨b, h⟩) ↔ a ⋖ b := fun b h => ⟨fun ⟨hlt, hno⟩ => ⟨hlt, fun c hac hcb => hno (c := ⟨c, hac.le⟩) hac hcb⟩, fun ⟨hlt, hno⟩ => ⟨hlt, fun c hac hcb => hno (c := c.1) hac hcb⟩⟩ exact ⟨fun ⟨⟨b, hb⟩, h⟩ => ⟨b, (key b hb).1 h⟩, fun ⟨b, h⟩ => ⟨⟨b, h.le⟩, (key b h.le).2 h⟩⟩ -- `Statement:` AX-B1's scope, conditional form — every state with anything above it has a first step — -- holds on the two states `Bool` (the top owes no step) and on `ℕ`, and fails on `ℝ`. A standard -- sufficient condition is a successor order: `Order.covBy_succ_of_not_isMax`. example : ∀ a : Bool, (∃ b, a < b) → HasFirstStep a := by intro a ⟨b, hab⟩ cases a <;> cases b · exact absurd hab (by decide) · exact ⟨true, by decide, fun c h1 h2 => by cases c <;> simp_all⟩ · exact absurd hab (by decide) · exact absurd hab (by decide) example : ∀ a : ℕ, (∃ b, a < b) → HasFirstStep a := fun a _ => ⟨a + 1, Nat.lt_succ_self a, fun c h1 h2 => by omega⟩ example : ¬ ∀ a : ℝ, (∃ b, a < b) → HasFirstStep a := by intro h obtain ⟨c, hc⟩ := h 0 ⟨1, one_pos⟩ exact hc.2 (c := c / 2) (half_pos hc.1) (half_lt_self hc.1) -- `Statement:` the universal form — every state has a first step — fails on two states, at the top. example : ¬ ∀ a : Bool, HasFirstStep a := by intro h obtain ⟨c, hc⟩ := h true exact absurd hc.1 (by cases c <;> decide) -- `Statement:` in any partial order, if `a < b` and every `c` in `[a, b]` is `a` or `b`, then `a ⋖ b`. -- This is the partial-order case of Mathlib's `covBy_of_eq_or_eq`, which is stated over any preorder. example {α : Type*} [PartialOrder α] {a b : α} (hab : a < b) (h : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b) : a ⋖ b := covBy_of_eq_or_eq hab h -- `Statement:` conversely, given decidable equality, `a ⋖ b` makes every `c` in `[a, b]` equal to `a` -- or to `b`. example {α : Type*} [PartialOrder α] [DecidableEq α] {a b : α} (h : a ⋖ b) : ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b := fun c hac hcb => if hca : c = a then Or.inl hca else if hcb' : c = b then Or.inr hcb' else absurd (lt_of_le_of_ne hcb hcb') (h.2 (lt_of_le_of_ne hac (Ne.symm hca))) -- `Statement:` with no decidability, only the negative form: `a ⋖ b` leaves no `c` in `[a, b]` that is -- neither `a` nor `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) 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. -- 10(3) (2017), Prop 3.4, p. 173, "Excluded middle states that 2 = Ω"; for one element, de -- Jong–Escardó arXiv:2102.08812, Examples 28(i), p. 9: "The pair (0_V, P) witnesses nontriviality of -- Ω_V if and only if ¬¬P holds, while it witnesses positivity if and only if P holds." example : (False : Prop) ⋖ True ∧ ((∀ c : Prop, False ≤ c → c ≤ True → c = False ∨ c = True) ↔ ∀ p : Prop, p ∨ ¬ p) := by refine ⟨⟨⟨fun h => h.elim, fun h => h trivial⟩, fun c h1 h2 => h1.2 fun hc => h2.2 fun _ => hc⟩, ⟨fun h p => ?_, fun h c _ _ => ?_⟩⟩ · rcases h p (fun h => h.elim) (fun _ => trivial) with h0 | h1 · exact Or.inr fun hp => h0 ▸ hp · exact Or.inl (h1 ▸ trivial) · rcases h c with hp | hn · exact Or.inr (propext ⟨fun _ => trivial, fun _ => hp⟩) · exact Or.inl (propext ⟨hn, False.elim⟩) -- `Reading:` AX-B1 includes that `bot` be covered (`HasFirstStep bot`) and that `[bot, a]` hold exactly -- `bot` and its cover `a`. With decidable equality the second follows from the first (above); on -- `Prop` the two differ only in cost: the cover is free, the two-element interval costs excluded -- middle, and classically both hold. /-- `Statement:` if every cover in every partial order on a `Type` has a two-point closed interval (`Set.Icc a b = {a, b}`, the statement of Mathlib's `CovBy.Icc_eq`), excluded middle holds; the reduction is the `Prop` control above, at `False ⋖ True`. -/ theorem em_of_covBy_Icc_eq (h : ∀ (α : Type) [PartialOrder α] (a b : α), a ⋖ b → Set.Icc a b = {a, b}) : ∀ p : Prop, p ∨ ¬ p := by intro p have hcov : (False : Prop) ⋖ True := ⟨⟨fun h => h.elim, fun h => h trivial⟩, fun c h1 h2 => h1.2 fun hc => h2.2 fun _ => hc⟩ have hp : p ∈ Set.Icc (False : Prop) True := ⟨fun h => h.elim, fun _ => trivial⟩ rw [h Prop False True hcov] at hp rcases hp with h0 | h1 · exact Or.inr fun hp' => h0 ▸ hp' · exact Or.inl (h1 ▸ trivial) /-- **The first step is unique.** This is Mathlib's `CovBy.unique_right`, and it is cited as such — proved here by hand only to keep the footprint at `[propext]`. Mathlib's version routes through `LinearOrder` machinery that pulls in `Classical.choice`, and the framework prefers the pure route where one is available. Same statement, cheaper proof. -/ theorem firstStep_unique {α : Type*} [LinearOrder α] {bot a b : α} (ha : bot ⋖ a) (hb : bot ⋖ b) : a = b := by rcases lt_trichotomy a b with h | h | h · exact absurd h (hb.2 ha.1) · exact h · exact absurd h (ha.2 hb.1) /-- **What the commitment buys.** Assume AX-B1 and the snap's target exists and is UNIQUE, so the transition has a well-defined destination. The hypothesis is visible on the face of the statement, so no reader can mistake the conclusion for something derived without it. -/ theorem axb1_gives_unique_target {α : Type*} [LinearOrder α] (bot : α) (h : HasFirstStep bot) : ∃! a : α, bot ⋖ a := by obtain ⟨a, ha⟩ := h exact ⟨a, ha, fun b hb => firstStep_unique hb ha⟩ -- `Statement:` the `LinearOrder` hypothesis is load-bearing. On `Set Bool`, `∅` has a first step -- (AX-B1 holds) through two distinct covers, and no least element lies strictly above `∅`. example : (∅ : Set Bool) ⋖ {true} ∧ (∅ : Set Bool) ⋖ {false} ∧ ({true} : Set Bool) ≠ {false} ∧ ¬ ∃ m : Set Bool, IsLeast {x | (∅ : Set Bool) < x} m := by have cov : ∀ b : Bool, (∅ : Set Bool) ⋖ {b} := Set.empty_covBy_singleton refine ⟨cov true, cov false, fun h => absurd (h ▸ Set.mem_singleton true : true ∈ ({false} : Set Bool)) (by simp), fun ⟨m, hm, hlow⟩ => ?_⟩ have ht : m ⊆ {true} := hlow (cov true).1 have hf : m ⊆ {false} := hlow (cov false).1 obtain ⟨x, hx⟩ := Set.nonempty_iff_ne_empty.2 (show m ≠ ∅ from hm.ne') exact absurd ((Set.mem_singleton_iff.1 (ht hx)).symm.trans (Set.mem_singleton_iff.1 (hf hx))) (by decide) -- `Statement:` the converse holds in any partial order: a least element strictly above `bot` covers it. example {α : Type*} [PartialOrder α] (bot a : α) (h : IsLeast {x | bot < x} a) : bot ⋖ a := ⟨h.1, fun c hbc hca => absurd hca (not_lt_of_ge (show c ≥ a from h.2 hbc))⟩ -- `Statement:` and on a linear order a cover of `bot` is the least element strictly above it -- (Mathlib's `CovBy.ge_of_gt`); the `Set Bool` example above is why linearity is needed. example {α : Type*} [LinearOrder α] (bot a : α) (h : bot ⋖ a) : IsLeast {x | bot < x} a := ⟨h.1, fun _ hx => h.ge_of_gt hx⟩ /-- **An order is dense iff AX-B1 fails at EVERY element — a BICONDITIONAL over the whole order, and it is Mathlib's** `denselyOrdered_iff_forall_not_covBy`. The right-hand side quantifies over all elements. Density rules out a first step at each one, `0` of an ordered field included (`axb1_fails_in_ordered_field`); one element without a first step does not make an order dense (the two controls below). -/ theorem axb1_fails_everywhere_iff_dense {α : Type*} [Preorder α] : DenselyOrdered α ↔ ∀ bot : α, ¬ HasFirstStep bot := by rw [denselyOrdered_iff_forall_not_covBy] exact ⟨fun h bot ⟨a, hcov⟩ => h bot a hcov, fun h a b hcov => h a ⟨b, hcov⟩⟩ -- `Statement:` control, the iff does not hold at one element: in `Bool`, `true` has no first step, -- and `Bool` is not dense (`false ⋖ true`). example : ¬ HasFirstStep true ∧ ¬ DenselyOrdered Bool := by refine ⟨fun ⟨c, hc⟩ => absurd hc.1 (by cases c <;> decide), fun hd => ?_⟩ exact axb1_fails_everywhere_iff_dense.mp hd false ⟨true, by decide, fun c h1 h2 => by cases c <;> simp_all⟩ -- `Statement:` control, with something above the element: in `WithTop (WithTop ℚ)`, `0` has no first -- step, and the order is not dense (the inner `⊤` is covered by the outer `⊤`). example : ¬ HasFirstStep (((0 : ℚ) : WithTop ℚ) : WithTop (WithTop ℚ)) ∧ ¬ DenselyOrdered (WithTop (WithTop ℚ)) := by refine ⟨fun ⟨a, h0a, hc⟩ => ?_, fun hd => ?_⟩ · induction a using WithTop.recTopCoe with | top => exact hc (c := ((1 : ℚ) : WithTop ℚ)) (by simp) (WithTop.coe_lt_top _) | coe b => induction b using WithTop.recTopCoe with | top => exact hc (c := (((1 : ℚ) : WithTop ℚ) : WithTop (WithTop ℚ))) (by simp) (WithTop.coe_lt_coe.2 (WithTop.coe_lt_top _)) | coe r => have hr : (0 : ℚ) < r := by simpa using h0a exact hc (c := (((r / 2 : ℚ) : WithTop ℚ) : WithTop (WithTop ℚ))) (by simpa using half_pos hr) (by simpa using half_lt_self hr) · refine axb1_fails_everywhere_iff_dense.mp hd ((⊤ : WithTop ℚ) : WithTop (WithTop ℚ)) ⟨⊤, WithTop.coe_lt_top _, fun c h1 h2 => ?_⟩ induction c using WithTop.recTopCoe with | top => exact lt_irrefl _ h2 | coe b => exact (not_top_lt (WithTop.coe_lt_coe.1 h1)) end AxB1 section General variable {F : Type*} [Field F] [LinearOrder F] [IsStrictOrderedRing F] /-- F-DENSITY: For any positive element ε in a LinearOrderedField, ε/2 is also positive and strictly smaller. The halving argument works in any ordered field. -/ theorem f_density (ε : F) (hε : 0 < ε) : 0 < ε / 2 ∧ ε / 2 < ε := ⟨half_pos hε, half_lt_self hε⟩ /-- F-NO-MIN: No LinearOrderedField has a minimal positive element. Any candidate minimum is undercut by its own half. -/ theorem f_no_minimal_positive : ¬∃ ε : F, 0 < ε ∧ ∀ δ : F, 0 < δ → ε ≤ δ := by intro ⟨ε, hpos, hmin⟩ exact absurd (hmin (ε / 2) (half_pos hpos)) (not_le.mpr (half_lt_self hpos)) /-- F-SNAP-BLOCKED: Any candidate first step ε₀ > 0 from 0 in a LinearOrderedField is blocked — ε₀/2 is a smaller positive element, so ε₀ is not a first step. -/ theorem f_snap_blocked (ε₀ : F) (hε : 0 < ε₀) : ∃ δ : F, 0 < δ ∧ δ < ε₀ := ⟨ε₀ / 2, half_pos hε, half_lt_self hε⟩ /-- F-SNAP-IMPOSSIBLE: The Binary Snap cannot occur in any LinearOrderedField. A snap requires a minimal first step with nothing below it — impossible when halving is always available. -/ theorem f_snap_impossible : ¬∃ ε₀ : F, 0 < ε₀ ∧ ¬∃ δ : F, 0 < δ ∧ δ < ε₀ := by intro ⟨ε₀, hpos, hno_smaller⟩ exact hno_smaller (f_snap_blocked ε₀ hpos) /-- **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_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 is the same fact reached by hand, and is kept because it is the elementary route a reader can check without the order-theory library. -/ theorem axb1_fails_in_ordered_field : ¬ HasFirstStep (0 : F) := by rintro ⟨a, hcov⟩ exact not_covBy_of_denselyOrdered hcov end General /-! ### Real numbers: canonical instance -/ section Reals /-- R-DENSITY: Density at zero for ℝ — the canonical LinearOrderedField instance. -/ theorem r_density (ε : ℝ) (hε : 0 < ε) : 0 < ε / 2 ∧ ε / 2 < ε := f_density ε hε /-- R-NO-MIN: ℝ has no minimal positive element. -/ theorem r_no_minimal_positive : ¬∃ ε : ℝ, 0 < ε ∧ ∀ δ : ℝ, 0 < δ → ε ≤ δ := f_no_minimal_positive /-- R-SNAP-BLOCKED: Any candidate first step in ℝ can be halved. -/ theorem r_snap_blocked (ε₀ : ℝ) (hε : 0 < ε₀) : ∃ δ : ℝ, 0 < δ ∧ δ < ε₀ := f_snap_blocked ε₀ hε /-- R-SNAP-IMPOSSIBLE: The Binary Snap cannot occur in ℝ. -/ theorem r_snap_impossible : ¬∃ ε₀ : ℝ, 0 < ε₀ ∧ ¬∃ δ : ℝ, 0 < δ ∧ δ < ε₀ := f_snap_impossible end Reals /-! ## Classification Note: Ordered Fields and the Snap The results above establish that the Binary Snap cannot occur in any LinearOrderedField. **The underlying reason is DENSITY, not the Archimedean property:** in any ordered field halving is available, so between 0 and any positive x there is something smaller — there is no "first step" from zero. Neither theorem below has an Archimedean hypothesis, and none is needed. ⚠ **A DIFFERENT result DOES turn on the Archimedean property, and the two must not be conflated.** `archimedean_iff_survival_eventually_lt` (`ZeroParadox/Information/Surprisal.lean`) proves that the **repeated-trials / eventual-certainty** argument holds in an ordered field *if and only if* that field is Archimedean. That is a claim about a **probability accumulating over trials**, not about the order admitting a first step. Both are true and they are about different objects: * the **snap** is blocked in **every** ordered field, Archimedean or not — density does it (`f_snap_impossible` below; ℝ(t) is a non-Archimedean ordered field where the snap still fails); * the **repeated-trials argument** works in **exactly** the Archimedean ordered fields. Do not read the second as reinstating the claim this note struck. *(Corrected 2026-08-01. This section was headed "Archimedean Fields and the Snap" and said "the underlying reason is the Archimedean property". That is false: a non-Archimedean ordered field such as ℝ(t) is still **dense**, so the snap is blocked there too. Being Archimedean is not what does the work; being an ordered field is. The struck claim survived here for months after the same wording was corrected in `ZeroParadox/Valuation/Padic.lean` — an adversary gate found it by grepping the CLAIM rather than the file.)* **ZP-F / ZP-B classification.** *(Ostrowski's theorem classifies the absolute values on ℚ up to equivalence, so it governs the ℝ-versus-ℚ_p split only. It does **not** classify ℝ(t), which is not a completion of ℚ — the first bullet is therefore wider than Ostrowski and rests on `f_snap_impossible`, not on the classification. Heading corrected 2026-08-02; it previously read "Classification (Ostrowski's theorem)" while governing a bullet containing ℝ(t).)* - **Ordered fields** (ℝ, ℚ, and equally the non-Archimedean ones like ℝ(t)): the snap is **impossible** — proved in this file by two distinct theorems, `f_snap_impossible` (by halving) and `axb1_fails_in_ordered_field` (via density and `CovBy`): the same fact reached two ways, with distinct statements. They are **not** the same declaration and no equation between them is asserted. - Non-Archimedean **and not an ordered field** (ℚ₂): the snap is **not blocked**, which is a strictly weaker statement than being forced. *(The p-adics admit no compatible linear order. Only the **elementary direction** is used: in an ordered field every square is ≥ 0, so a sum of squares cannot be −1; and −1 **is** a sum of squares in every ℚ_p (its Stufe is finite — 4 for ℚ₂). That direction needs no Artin–Schreier. Artin–Schreier is the **converse** — formally real ⟹ orderable — which is the deep half and is not required here — the theorem is named for a biconditional, and only the elementary direction is load-bearing for this claim.)* **ZP-B does NOT force the snap, and cannot.** What it proves is topological: the gap at 0 is clopen (`t3_isolation`) and the return across it admits no continuous path (`c3_irreversible`, via `t5_totallyDisconnected`). Neither yields a first step, and no metric result could: the 2-adic norm values accumulate at 0 (‖2ⁿ‖₂ = 2⁻ⁿ), so ℚ₂ has no closest non-zero element either — ZP-B's own `eps0 k = 2 ^ k` reads as a 2-adic norm: a nonzero `x : ℚ₂` of valuation `v` has `‖x‖ = 2 ^ (-v)` (Mathlib `Padic.norm_eq_zpow_neg_valuation`), so at the chosen finest valuation `v` the exponent is `k = -v`, a contingent value. **The first step is AX-B1** (§ 0), not a 2-adic consequence. So the classification is a statement about where the snap is RULED OUT. Ostrowski's theorem (see `ZeroParadox/Valuation/Ostrowski.lean` for the framework's own statement of it) separates the Archimedean completions of ℚ from the non-Archimedean ones; **ZP-F rules the snap out in every ordered field** — which is what this file actually proves, and is wider than the Archimedean completion — and ZP-B removes the topological obstruction in ℚ₂. *(Corrected 2026-08-01: this read "ZP-F rules the snap out on the Archimedean side", which understates a theorem needing no Archimedean hypothesis. The identical phrasing in `ZeroParadox/Valuation/Padic.lean` was struck in the same arc, **as of `a565649`** — and only on the second attempt: the first pass corrected this file while asserting the sibling had already been fixed, when it had not. **Do not restate another file's state as fact in a correction note — including this one, which is why it is dated: grep the claim there instead.**)* That the snap actually occurs there is carried by AX-B1 together with the framework's commitments, never by C3 or T5 alone. See `ZeroParadox/Valuation/Padic.lean` (`c3_irreversible`, `t5_totallyDisconnected`, `t3_isolation`) for the non-Archimedean side. -/ section PurityCheck #print axioms firstStep_unique #print axioms axb1_gives_unique_target #print axioms em_of_covBy_Icc_eq #print axioms axb1_fails_in_ordered_field #print axioms axb1_fails_everywhere_iff_dense #print axioms f_density #print axioms f_no_minimal_positive #print axioms f_snap_blocked #print axioms f_snap_impossible #print axioms r_density #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