Cosmology Recognition Work Bound Cycle Work Le

The work bound

In any system that keeps a discrete record of events, the cost of recording can grow with the size of the system. The theorem cycle_work_le in the Recognition Science framework's machine-checked library of formal theorems establishes a bound on that cost. It states that over a fixed cycle of T ticks, where each tick resolves at most one edge between two regions, the total recognition work is at most 2 * P * T. Here P is the maximum cost to expand any single region, and T is the number of ticks in the cycle. The bound is independent of the total number of regions in the system.

The key consequence is that the per-cycle cost does not grow with the world. The region-index type, which represents the population of regions, never appears in the bound. So if the world grows by a fixed number of regions each cycle, the recognition-work numerator stays capped while the volume denominator grows. The recognition-active fraction falls toward zero, and the cost localizes to a sub-extensive interface. This is the formal core of the claim that the engine never expands the locked interior.

The theorem is proved in Lean 4 with no sorry and no axioms beyond Mathlib's standard three: propext, Classical.choice, and Quot.sound. It builds on the forced cadence law that at most one edge is resolved per tick, and on the double-entry posting that each resolved edge activates its two endpoints. A specialization with unit cost gives that region-activations per cycle are at most 2 * T, again independent of population.

In Recognition Science, this theorem is the Phase-11 result behind the driven_forward.py script, which models open-system expanding dynamics. It sits beside two other results: the schedule-independence corollary that the engine stays literal under any schedule, and the conjugate-birth charge conservation that sigma equals zero through every birth. Together they say the driven engine is literal, conserves sigma through growth, and pays a per-cycle recognition cost bounded by the cadence regardless of how large reality grows.

What the theorem does not claim is that the world actually grows by a fixed number of regions per cycle, or that the per-region cost ceiling P is constant. Those are modeling choices in the companion scripts, not consequences of the theorem. The bound is conditional on the cadence law and the cost ceiling; it does not assert that such a cadence law holds in any particular physical system.

/-- **Recognition work per cycle is bounded by the cadence, independent of the population.** Over a
cycle of `T` ticks with at most one resolved edge per tick and per-region expansion cost at most `P`,
the engine's total recognition work in the cycle is at most `2 * P * T`. The bound mentions only the
tick count `T` and the per-region ceiling `P`; the region-index type `ι` (the population) does not
appear, so the per-cycle recognition cost does not grow with the world. -/
theorem cycle_work_le (T : ℕ) (res : Fin T → Option (ι × ι)) (P : ℕ)
    (cost : ι → ℕ) (hcost : ∀ i, cost i ≤ P) :
    (∑ t, tickWork (res t) cost) ≤ 2 * P * T := by
  have h : (∑ t : Fin T, tickWork (res t) cost) ≤ ∑ _t : Fin T, 2 * P :=
    Finset.sum_le_sum (fun t _ => tickWork_le (res t) P cost hcost)
  have hconst : (∑ _t : Fin T, 2 * P) = 2 * P * T := by
    rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul, Nat.mul_comm]
  exact h.trans (le_of_eq hconst)

/-- **Recognition work per cycle is bounded by the cadence, independent of the population.** Over a
cycle of `T` ticks with at most one resolved edge per tick and per-region expansion cost at most `P`,
the engine's total recognition work in the cycle is at most `2 * P * T`. The bound mentions only the
tick count `T` and the per-region ceiling `P`; the region-index type `ι` (the population) does not
appear, so the per-cycle recognition cost does not grow with the world. -/
theorem cycle_work_le (T : ℕ) (res : Fin T → Option (ι × ι)) (P : ℕ)
    (cost : ι → ℕ) (hcost : ∀ i, cost i ≤ P) :
    (∑ t, tickWork (res t) cost) ≤ 2 * P * T := by
  have h : (∑ t : Fin T, tickWork (res t) cost) ≤ ∑ _t : Fin T, 2 * P :=
    Finset.sum_le_sum (fun t _ => tickWork_le (res t) P cost hcost)
  have hconst : (∑ _t : Fin T, 2 * P) = 2 * P * T := by
    rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul, Nat.mul_comm]
  exact h.trans (le_of_eq hconst)

/-- **Region-activations per cycle are bounded by twice the cadence, independent of the population.**
A specialization of `cycle_work_le` with unit cost: at most `2 * T` region-activations occur in a
`T`-tick cycle, regardless of the number of regions. -/
theorem cycle_activations_le (T : ℕ) (res : Fin T → Option (ι × ι)) :
    (∑ t, tickActivations (res t)) ≤ 2 * T := by
  have := cycle_work_le T res 1 (fun _ => 1) (fun _ => le_rfl)
  simpa [tickActivations] using this

/-- **Phase-11 cost-localization headline.** In a `T`-tick cadence cycle with at most one forced
resolution per tick, the engine's recognition work is at most `2 * P * T` and the region-activations
are at most `2 * T`, both independent of the population `ι`. So when the world grows by a fixed number
of regions per cycle, the recognition-cost numerator is capped while the volume denominator grows: the
recognition-active fraction falls toward zero and the cost localizes to a sub-extensive interface. -/
theorem recognition_work_localizes (T : ℕ) (res : Fin T → Option (ι × ι)) (P : ℕ)
    (cost : ι → ℕ) (hcost : ∀ i, cost i ≤ P) :
    (∑ t, tickWork (res t) cost) ≤ 2 * P * T
    ∧ (∑ t, tickActivations (res t)) ≤ 2 * T :=
  ⟨cycle_work_le T res P cost hcost, cycle_activations_le T res⟩

What this page does not claim

The world grows by a fixed number of regions per cycle, which is a modeling choice in the companion scripts. The per-region cost ceiling P is constant across all regions or over time. The cadence law holds in any particular physical system without further assumptions.

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