Cosmology Recognition Unit Step Preservation Chain3 Unit Step

The three-site chain

In the Recognition Science framework, recognition keeps a discrete record of events, and the cost of recording those events is forced by a proved theorem. That cost law sits on an invariant called the unit-step condition: adjacent rungs, or levels, may differ by at most one. The declaration chain3_unitStep is a machine-checked proof that a specific three-site chain satisfies this condition before any update happens.

The chain is simple: three sites in a line, with levels 0, 1, and 2. The two edges are between sites 0 and 1, and between sites 1 and 2. The theorem states that both gaps are at most one, which is true: the gaps are exactly 1 and 1. This is the starting state, the baseline that any update rule must respect if it is to preserve the unit-step invariant.

The more interesting part is what happens next. The framework's update rule, called a pair resolution, averages the levels of two connected sites. The declaration chain3_pairResolve_breaks_unitStep proves that this rule does not always preserve the unit-step condition. Resolving the first edge of the chain sends the levels to 1/2, 1/2, and 2, so the second edge now has a gap of 3/2, which is greater than one. The invariant fails.

This is not a bug. It is the honest theorem layer. The framework proves a local preservation criterion: if every edge touching the resolved pair remains within one rung after the move, then the whole field stays unit-step. Edges that do not touch the pair are unchanged, so they carry over automatically. The three-site chain shows that this local condition is necessary, not cosmetic. A blind global lemma saying "mean-move preserves unit-step" would be false.

In Recognition Science, this means the live engine may use the Phase-56 cost law only after auditing or proving the local unit-step condition for the update being applied. The chain3 example is the counterexample that blocks an overconfident shortcut. It is a theorem, not a numerical observation, and it is proved with zero sorry and no new axioms beyond the standard classical ones.

/-- The initial levels `0, 1, 2`, written by cases over `Fin 3`. -/
def chain3Levels : Fin 3 → ℝ
  | ⟨0, _⟩ => 0
  | ⟨1, _⟩ => 1
  | ⟨2, _⟩ => 2

/-- The chain `0,1,2` is unit-step before any resolution. -/
theorem chain3_unitStep : UnitStepReal chain3Levels chain3Edges := by
  intro e he
  simp [chain3Edges] at he
  rcases he with rfl | he
  · norm_num
  · rcases he with rfl
    norm_num

/-- **Counterexample.** A unit-step field need not remain unit-step after a mean-move
resolution. The three-site chain `0 -- 1 -- 2` starts with gaps `1` and `1`; resolving
the first edge gives levels `1/2, 1/2, 2`, so the second edge has gap `3/2 > 1`.

This blocks the false global theorem "mean-move preserves UnitStep". The correct theorem
is the local criterion `pairResolve_unitStep_of_local` above. -/
theorem chain3_pairResolve_breaks_unitStep :
    ¬ UnitStepReal (pairResolve chain3Levels f0 f1) chain3Edges := by
  intro h
  have hedge : (f1, f2) ∈ chain3Edges := by
    simp [chain3Edges]
  have hstep := h (f1, f2) hedge
  rw [chain3_resolved_second_gap] at hstep
  norm_num at hstep

/-- **Local preservation criterion.** A `pairResolve` move preserves the unit-step
invariant on the whole edge list if every edge touching the resolved pair remains
unit-step after the move. Disjoint edges are unchanged by `pairResolve_other`, so the
old unit-step invariant carries them automatically.

This is the exact condition the runtime must audit, or a later theorem must prove, before
applying the Phase-56 cost law to an actively updated field. -/
theorem pairResolve_unitStep_of_local {n : ℕ} (x : Fin n → ℝ) (E : List (Fin n × Fin n))
    (i j : Fin n) (hunit : UnitStepReal x E)
    (hlocal : ∀ e ∈ E, EdgeTouches i j e →
      |pairResolve x i j e.1 - pairResolve x i j e.2| ≤ 1) :
    UnitStepReal (pairResolve x i j) E := by
  intro e he
  by_cases ht : EdgeTouches i j e
  · exact hlocal e he ht
  · have h1i : e.1 ≠ i := by
      intro h; exact ht (Or.inl h)
    have h1j : e.1 ≠ j := by
      intro h; exact ht (Or.inr (Or.inl h))
    have h2i : e.2 ≠ i := by
      intro h; exact ht (Or.inr (Or.inr (Or.inl h)))
    have h2j : e.2 ≠ j := by
      intro h; exact ht (Or.inr (Or.inr (Or.inr h)))
    rw [pairResolve_other x h1i h1j, pairResolve_other x h2i h2j]
    exact hunit e he

/-- Phase-58 headline: active mean-move dynamics does not preserve unit-step globally;
it preserves it exactly under the local post-move edge condition, and the 3-chain
counterexample shows that condition is necessary rather than cosmetic. -/
theorem t58_unitStep_preservation_honest :
    (∀ {n : ℕ} (x : Fin n → ℝ) (E : List (Fin n × Fin n)) (i j : Fin n),
        UnitStepReal x E →
        (∀ e ∈ E, EdgeTouches i j e →
          |pairResolve x i j e.1 - pairResolve x i j e.2| ≤ 1) →
        UnitStepReal (pairResolve x i j) E)
    ∧ ¬ UnitStepReal (pairResolve chain3Levels f0 f1) chain3Edges :=
  ⟨fun {n} x E i j hunit hlocal =>
    pairResolve_unitStep_of_local (n := n) x E i j hunit hlocal,
   chain3_pairResolve_breaks_unitStep⟩

What this page does not claim

This answer does not claim that the unit-step invariant is preserved by every possible update rule. This answer does not claim that the three-site chain represents a physical cosmology model. This answer does not claim that the pair resolution rule is the only update rule in the framework.

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/RecognitionUnitStepPreservation.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: