Cosmology Rung Descent Unit Step Shift Up Bot Unit Step

The bottom-rung raise

In the Recognition Science framework, a ledger (a discrete record of events) assigns each cell an integer rung (a level or height), and the unit-step invariant (every adjacent pair of cells differs by at most one rung) keeps the structure locally coherent. The declaration shiftUp_bot_unitStep is a formal theorem stating that if every rung is at least some integer m, and you raise every cell sitting exactly at rung m by one rung, the unit-step invariant still holds for the whole edge set. This is the mirror image of a descent theorem: lowering the top rung also preserves the invariant. Both moves are the natural parameter-free relaxation steps in the framework's dynamics, which descends or ascends one rung at a time when a distinction is forced.

The proof works by examining cut edges, those with exactly one endpoint in the raised set. A bottom-rung cell's neighbor cannot be below it, and the unit-step rule forbids it from being two rungs above, so the neighbor must sit exactly one rung up. After the raise, both endpoints meet at rung m+1, leaving the gap zero. Edges with both endpoints raised shift together, and edges with neither endpoint raised are unchanged, so the invariant survives everywhere. The theorem requires only a lower bound on the rungs, which can be read off the field itself when the edge set is nonempty.

The framework's machine-checked library of formal theorems also proves the necessity of the extreme-rung condition. On a three-site chain with rungs 0, 1, 2, descending the bottom cell sends it to -1, making the gap to its rung-1 neighbor equal to 2, which breaks the unit-step rule. This counterexample shows that raising or lowering a non-extreme cell is unsafe; the restriction in the theorem is not cosmetic. The honest status is that a generic move does not preserve the invariant, but the forced top-rung descent and bottom-rung raise do, so the cost law applies to the next cycle along those updates.

What the theorem does not claim is broader than what it proves. It does not assert that every descent or ascent preserves the invariant, and the counterexample shows exactly why. It also does not claim that the unit-step invariant is preserved by real-valued mean moves, which the framework's earlier phase proved false. The theorem concerns the integer rung field the cost meter charges, not any continuous relaxation. Finally, it does not claim that the bottom-rung raise is physically realized in the framework's dynamics; it establishes a conditional preservation result, leaving the question of which moves the engine actually posts to the surrounding theory.

/-- **Bottom-rung raise preserves `UnitStep` unconditionally** (dual of `shiftDown_top_unitStep`).
If `m` bounds every rung from below and `S` is the set of cells at rung `m`, raising `S` by one
rung keeps the field unit-step: a bottom cell's neighbour is forced to be exactly one rung up, so
after the raise the cut gap is `0`. -/
theorem shiftUp_bot_unitStep (k : V → ℤ) (E : Finset (V × V)) (m : ℤ)
    (hunit : UnitStep k E) (hlb : ∀ p ∈ E, m ≤ k p.1 ∧ m ≤ k p.2) :
    UnitStep (shiftUp (fun v => k v = m) k) E := by
  intro p hp
  obtain ⟨hlb1, hlb2⟩ := hlb p hp
  have hstep := hunit p hp
  by_cases h1 : k p.1 = m <;> by_cases h2 : k p.2 = m
  · rw [shiftUp_pos _ k h1, shiftUp_pos _ k h2]
    have hsame : (k p.1 + 1) - (k p.2 + 1) = k p.1 - k p.2 := by ring
    rw [hsame]; exact hstep
  · -- k p.1 = m (raised), k p.2 ≠ m: neighbour forced to m + 1
    have hb2 : m < k p.2 := lt_of_le_of_ne hlb2 (Ne.symm h2)
    have hk2 : k p.2 = m + 1 := by omega
    rw [shiftUp_pos _ k h1, shiftUp_neg _ k h2]
    left; omega
  · -- k p.2 = m (raised), k p.1 ≠ m: symmetric
    have hb1 : m < k p.1 := lt_of_le_of_ne hlb1 (Ne.symm h1)
    have hk1 : k p.1 = m + 1 := by omega
    rw [shiftUp_neg _ k h1, shiftUp_pos _ k h2]
    left; omega
  · rw [shiftUp_neg _ k h1, shiftUp_neg _ k h2]; exact hstep

/-- **Necessity counterexample.** Descending the *bottom* cell (rung `0`) of the chain `0, 1, 2`
sends it to `-1`, so the edge to the rung-`1` neighbour has gap `2` and `UnitStep` fails. Only
descending the top rung is safe; the top-rung hypothesis of `shiftDown_top_unitStep` is necessary,
not cosmetic. -/
theorem ckLevels_descend_min_breaks :
    ¬ UnitStep (shiftDown (fun v => v = (0 : Fin 3)) ckLevels) ckEdges := by
  unfold UnitStep; decide

What this page does not claim

The theorem does not claim that every descent or ascent preserves the unit-step invariant. The theorem does not claim that real-valued mean moves preserve the invariant. The theorem does not claim that the bottom-rung raise is a move the framework's dynamics actually performs.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Cosmology/RungDescentUnitStep.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: