Cosmology Recognition Unit Step Preservation T58 Unit Step Preservation Honest

The honest limit of a local rule

The declaration t58_unitStep_preservation_honest records two proved facts about a simple dynamical rule. The rule, called pairResolve, takes two neighboring sites in a network and replaces their levels with their average. The invariant in question, unit-step, says that along every edge of the network, the two levels differ by at most 1. The first fact is a local preservation theorem: if, after averaging a pair, every edge touching either of the two averaged sites still has a gap of at most 1, then the whole network still satisfies the unit-step condition. Edges far from the averaged pair are untouched, so they keep their old gaps automatically. The second fact is a counterexample: a three-site chain with levels 0, 1, 2 satisfies the invariant before any averaging, but averaging the first edge sends the levels to 1/2, 1/2, 2, and the second edge then has a gap of 3/2, breaking the invariant.

The two facts together make a precise statement about what the framework's live engine may and may not assume. A blind global claim, that averaging always preserves the unit-step invariant, is false, and the three-site chain is the proof. The honest theorem instead gives an exact local condition that must be checked, or proved, before the invariant is used after an update. This is not a numerical observation; it is a theorem in the machine-checked library of formal theorems, with no unfinished proofs and no extra axioms beyond the standard classical ones.

In plain terms, the declaration establishes a boundary. It says that a local rule has a local guarantee: you can trust the invariant after an update only if you have checked the edges that the update touches. It also says that the guarantee is not free. The counterexample is not a corner case; it is the simplest possible chain that shows why the global claim fails. The practical consequence for the framework's cosmology is that the cost law from an earlier phase can be applied to actively updated fields only after auditing this local condition, not as a blanket rule.

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

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

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

It does not claim that the unit-step invariant is preserved by every averaging move. It does not claim that the three-site counterexample is the only way the invariant fails. It does not claim that the local condition is easy to verify in every network.

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: