Cosmology Recognition Unit Step Preservation

The local rule that saves a global law

In Recognition Science, a recognition event is a discrete record of something being noticed, and the cost of that recognition is forced by a proved theorem. A related invariant, called the unit-step condition, says that on any listed edge of a network, the levels of two connected sites differ by at most one. This is a real-valued version of an earlier integer-rung law, and it is the natural thing to expect of a smoothly updating system.

The module under discussion asks whether a specific update rule, called pairResolve, automatically preserves this unit-step condition. PairResolve is a mean-move: when two sites are resolved, each takes the average of the two levels. The tempting global claim would be that any unit-step field stays unit-step after any such move. That claim is false. The module proves a counterexample on a three-site chain with levels 0, 1, 2. Resolving the first edge sends the levels to 1/2, 1/2, 2, so the second edge now has a gap of 3/2, which violates the condition.

The correct theorem is local. If, after a pairResolve move, every edge touching the resolved pair still has gap at most one, then the whole field remains unit-step. Edges that do not touch the resolved pair are unchanged, so they carry the old invariant for free. This is the exact condition a runtime engine must audit before applying the Phase-56 cost law to an actively updated field. The framework's machine-checked library of formal theorems records both the local preservation theorem and the counterexample as proved statements, with no unproved assumptions beyond standard classical logic.

The upshot is a precise engineering rule: a blind global preservation lemma is false, but a local check is sufficient. This matters because the cost law from Phase 56 is only valid on fields that satisfy the unit-step invariant. The module does not claim the invariant holds everywhere; it says exactly when an update keeps it true. That distinction is the difference between a usable runtime and a broken one.

/-- **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 unit-step invariant holds globally for all active recognition dynamics. PairResolve preserves the invariant without any local condition. The module derives the Phase-56 cost law itself.

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: