Cosmology Recognition Unit Step Preservation Chain3 Pair Resolve Breaks Unit Ste

A counterexample that guards the cost law

In Recognition Science, the framework's ledger, a discrete record of recognition events, tracks levels assigned to sites. A useful invariant, called the unit-step property, says adjacent sites in a chain differ by at most one level. Phase 56 established this invariant for a graded cost law. The tempting next step would be to assume that the framework's active mean-move dynamics, which resolves pairs of sites by averaging their levels, automatically preserves this property. That assumption is false.

The machine-checked library of formal theorems records the failure with a concrete example. Consider a three-site chain with levels 0, 1, and 2. Before any move, the gaps are 1 and 1, so the unit-step property holds. Resolving the first edge, between sites 0 and 1, replaces both levels with their average, 1/2. The levels become 1/2, 1/2, and 2. The gap between the second and third sites is now 3/2, which exceeds 1. The invariant is broken. This counterexample is a theorem, not a numerical observation.

The correct statement is narrower. The framework establishes that resolving a pair preserves the unit-step property provided every edge touching one of the two resolved endpoints remains within one rung after the move. Edges disjoint from the resolved pair are preserved automatically. This local condition is the exact audit the runtime must perform before applying the Phase-56 cost law to an actively updated field. The counterexample shows the condition is necessary, not cosmetic.

What the declaration does not claim is equally important. It does not claim that the unit-step property is never preserved, only that it is not preserved globally without the local condition. It does not claim the mean-move dynamics is invalid; rather, it precisely delimits when the cost law may be applied. The framework's honesty here is structural: a blind global lemma would be false, and the library records that falsehood as a theorem to prevent it from being assumed.

/-- **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

What this page does not claim

The mean-move dynamics never preserves the unit-step property. The unit-step property is always preserved when the local condition holds. The counterexample applies to dynamics other than pairResolve.

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: