The whole object in one picture: the pole 0 = ∞, a single discrete step of ε₀ away from bottom, and a return to bottom. The floor ⊥ is 0 (order) and ∞ (measure) at once; ε₀ — that one step — is the minimum ordinal closed under ω·, never a bottom and never 0. Encoded into the 2-adic integers, the ω-tower ⊥ → ε₀ is a loop — it starts at the floor ⊥ₙ, steps off by ε₀, and reapproaches. But the bottom it lands on is a new ⊥ₙ₊₁ — its own successor null, provably distinct just by virtue of having left and come back. Floor (⊥ₙ) and ceiling (⊥ₙ₊₁) are both ⊥; ε₀ opens the gap between them.
The object, in one loop. Every stage of the ω-tower, encoded into ℤ₂ by cnfToZp2, is one trajectory: it starts at the floor 0 (cnfToZp2 (towerNONote 0) = 0); it departs by a single discrete jump — every stage n ≥ 1 is off 0, and the 2-adic norm goes 0 → 1/2 with no continuous path between (the snap’s discreteness); and it reapproaches 0 as n → ∞. But the ⊥ it returns to is a new instance — its own successor null (t_iz_limit_is_new_null, axiom-free), provably distinct (c_da2_novelty, DA-2) just by having left and come back — and it seeds the next arc. Start, departure, reapproach to a new ⊥: the whole framework, as one turn of a succession.
What is drawn vs. what is claimed. This is the ℤ₂ realization of the snap-arc, via the map cnfToZp2 — one concrete carrier, machine-checked (snap_arc_z2_loop). It loops because the tower’s 2-adic norm reapproaches 0, landing back on the floor — not because the pole and its closure are one point: ε₀ is never 0 and never ⊥ (epsilon0_ne_zero, epsilon0_ne_bot) — it is a single discrete step of ε₀ off bottom — the minimum, opening the gap between the two bottoms ⊥ₙ, ⊥ₙ₊₁ — both least fixed point and tower-supremum at once (min ≡ max, epsilon0_min_eq_max), and the finite stages never even reach 0. The pole itself, ⊥ = 0 = ∞, is 0 as floor and ∞ as measure — carried by v(0) = ∞ (addVal_bot) and the inversion swapping 0 ↔ ∞ on the p-adic sphere (rInv_swaps), not a naive numeric equality. And there is no cross-type identity to settle either way: ε₀ (an ordinal) and the value 0 (in ℤ₂) are different types, so cnfToZp2 only co-witnesses the two closures — it never identifies them (cnf_bridge_type_boundary, per MC-1 / ZP-P). And the “new instance each return” is the framework’s own reading (DA-2 / T-IZ, both machine-checked): in ℤ₂ the value returns to 0, and that terminal ⊥ is a fresh successor null — the succession the loop lives inside.
The whole trajectory, not the route. The endpoints and the discrete stages are exact: it departs the floor (cnfToZp2 (towerNONote 0) = 0), each stage n sits at 2-adic valuation exactly n — norm 2⁻ⁿ (cnfToZp2_tower_valuation) — and it reapproaches the floor onto a new bottom (tower_converges_to_zero). But the figure cannot map the route between them — not for want of a formula, but because the path runs through internal variables with no external visibility. ℤ₂ is ultrametric, so there is no continuous path between the isolated stages to begin with; and what the state is inside the gap has no external description — the same apophatic character that makes ⊥ itself undescribable from outside. So this maps the trajectory as a whole — that it leaves bottom and returns — never the actual route between.