# The Binary Snap (⊥ → ε₀) - Dictionary and Map *A dictionary and map of the framework's central transition, the snap - what it is, what it is not, and where each characterization is established, most with a machine-checked Lean witness linked to the source.* [![Lean Action CI](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) For the framework's *object*, the bottom element ⊥, see its companion reference [The Bottom Element](BOTTOMELEMENT.md). For the formal framework index and Lean verification, see [README](README.md). For plain-language introductions and reading paths, see [GUIDE](GUIDE.md). For the claim-by-claim status of every result, see the [Claims Ledger](CLAIMS.md). --- ## What this is 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 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). --- ## The short version: the snap, tiered by confidence The snap is the framework's one theorem - the one-way departure from ⊥ into the first structured state ε₀ - and its central *action*. Everything provable is checkable: clone the repo and run `#print axioms `. **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; 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)). (`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 limit of the tower's 2-adic images 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); 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. 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. --- ## Dictionary ### 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. 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 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) | | verb | *constructive, from below, choice-free*: on ordinal notations, each tower term strictly exceeds the last, ω^x has no fixed point, and the tower is strictly monotone - footprints printed in `ZeroParadox/Ordinal/ConstructiveOrdinals.lean` § PurityCheck | [`exp_lt_term`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean), [`omegaPow_no_fixedpoint`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean), [`tower_strictMono`](ZeroParadox/Ordinal/ConstructiveOrdinals.lean) | | noun | the closure reached, *co-witnessed*: ε₀ stands with the limit of the tower's 2-adic images and the machine snap in one triangle | [`zpm_triangle`](ZeroParadox/Ordinal/Incompleteness.lean) | | noun | *what departs*: the floor the snap leaves - the three-name identity (Quine atom = order-bottom ⊥ = join-identity, axiom-free); the Kleene fixed point is joined to it by a class field, not by this theorem | [`t_exec`](ZeroParadox/Settheory/SetTheoryAFA.lean), [`t_comp`](ZeroParadox/Computability/Kleene.lean), [`kleene_quine_is_bot`](ZeroParadox/Computability/Kleene.lean) | ### The snap is not (characterization by exclusion) Each exclusion is either a **proved obstruction** (a Lean-checked wall), a **retired or out-of-scope reading** (dropped as ill-typed, like the cross-frame identity, or outside what the framework claims), or an **open** question. The value is here as much as in the positive handles: the walls are what keep the synthesis honest. | the snap is not... | witness (or meta / open) | |---|---| | *one mechanism across categories*. The per-domain frame-flips share a shape, not a single categorical map. In Set no nontrivial total type carries a Lawvere fixed-point witness (Cantor), so the lattice and 2-adic faces are provably not Set-level Lawvere instances - 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 is instead a genuine recursion fixed point, but in the effective category, where the fixed-point-free diagonal construction is not admissible. `Reading:` CARRIER - the verdict is category-relative. 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 the faces is the diagonal shape, not one mechanism - order-theoretic, not categorical. A proved obstruction, not a gap | [`nontrivial_lattice_no_witness`](ZeroParadox/Category/Lawvere.lean), [`q2_no_witness`](ZeroParadox/Category/Lawvere.lean), [`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean) | | *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); 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) | --- ## The boundary map The dictionary above sorts the snap by *aspect* - what it is, what it does. This section re-cuts the same results by *field*. Walk into any one of the framework's domains and ask a single question: **is the departure from ⊥ available here, or is it walled?** Every cell has a verdict; nothing is left merely posited. **Available does not mean it happens.** No field in this table establishes that the snap *occurs* - that follows from the occurrence commitment (instantiation occurs) together with DA-1 (closed given DP-2), and [`tsnap_holds_but_nothing_moves`](ZeroParadox/Order/Snap.lean) exhibits a model in which T-SNAP holds and nothing moves. What each row records is that the field's own structure supplies the ingredients and raises no obstruction. One row is different in kind: in the reals the snap is provably blocked. The pattern is worth stating plainly. The self-referential *shape* - the diagonal fixed point - recurs across every face, but the faces are not one object across them - they are one **family** (MC-1): the numerical identity is retired as ill-typed (object equality across categories does not typecheck and is not invariant under equivalence). What is available across almost every field is the *snap itself*, each by its own native mechanism. One field is the telling exception: in the real numbers the snap provably fails, and the failure is a theorem. Every row here cites machine-checked results; what singles out the reals is that theirs records an *obstruction* where the others record a *mechanism*. **Two notions, kept apart.** There is a narrower, stronger one - a genuine Lawvere fixed point, self-application with no escape - and it is walled across almost every field: Cantor forbids the Set-level witness for any nontrivial total type ([`nontrivial_lattice_no_witness`](ZeroParadox/Category/Lawvere.lean), [`q2_no_witness`](ZeroParadox/Category/Lawvere.lean)), so only the computability face carries a genuine one ([`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean), in the effective category). The snap is available far more widely than that fixed point is genuine. "The Lawvere fixed point is genuine in only one field" (read off the Lawvere register) and "the snap is available across almost every field" (read off the table below) are both true - they measure different things. One shared technique; a different procedure in each field. | field | the snap here is... | by what mechanism, or against what wall | witness (links to Lean source) | |---|---|---|---| | computability | **Available** | a genuine self-reference fixed point - a machine run on its own code, whose halting is undecidable, so no finite description settles what it does | [`self_halting_undecidable`](ZeroParadox/Computability/Kleene.lean), [`computability_face_fixedPoint`](ZeroParadox/Category/Lawvere.lean) | | valuation (p-adic) | **Available** | the ultrametric sends the floor to v(0) = ⊤, and the doubling dynamics contracts every starting law onto that floor | [`addVal_bot`](ZeroParadox/Valuation/FloorWitness.lean), [`attracting_attractor`](ZeroParadox/Valuation/BottomInvariant.lean) | | 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 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. --- *Generated by `build_snap_map.py`. Witness names are resolved against the Lean source at generation time and link to the file that declares them; a name that does not resolve fails loud as a warning, and the `meta` / `open` entries (marked as such) have no Lean witness. To update: edit the catalogue and rerun. The links render natively on GitHub.*