Foundation Recognition Ledger Floor Unit Cost Is Generator Count

The unit cost floor

In the Recognition Science framework, a ledger is a discrete record of events, and each event carries a cost. The theorem unit_cost_is_generator_count settles what happens when every kind of event costs exactly one unit: the cost of a record that contains n copies of the same event is simply n. Two copies cost 2, three cost 3, and so on. This is the free additive floor, the cheapest possible accounting rule that still tells copies apart.

The statement is a special case of a more general formula. For any ledger with a strictly positive weight assigned to each event kind, the cost of n copies of one kind is n times that weight. Setting every weight to 1 gives the unit-cost theorem directly. The proof is a one-line calculation from the definition of the cost function, and it is machine-checked in the framework's library of formal theorems.

The theorem matters because it closes a gap in the framework's foundations. Earlier versions of the cost floor treated a defect as merely present or absent, so two copies of the same defect cost the same as one. That collapsed the distinction between one failure and a repeated one. The unit-cost theorem restores multiplicity: independent copies genuinely accumulate. The two-state Boolean floor of the earlier theory survives as a truncation of this richer object, preserving only the distinction between zero and nonzero cost.

What the theorem does not claim is just as important. It does not say that unit cost is the only possible cost, nor that the ledger is the only way to model recognition. It establishes a floor, not a ceiling. The theorem also does not assert that any physical system actually uses this accounting; it proves a property of a mathematical construction. The framework's later results, such as the forcing of the golden ratio and the eight-tick cycle, build on this floor, but this theorem alone does not reach them.

In Recognition Science, this result is the load-bearing base for the claim that costs are forced rather than chosen. If the simplest possible ledger already forces additive multiplicity, then any richer cost structure must at least respect that. The theorem turns a design choice into a proved fact, and that fact is what later derivations stand on.

/-- Under unit weight, the ledger cost of `n` copies of one primitive
distinction is exactly the natural-number generator count. -/
theorem unit_cost_is_generator_count (i : I) (n : ℕ) :
    ledgerCost (fun _ => (1 : ℝ)) (Finsupp.single i n) = (n : ℝ) :=
  boolean_floor_is_truncation i n

/-- The cost of a single defect of multiplicity `n` is `n · w i`. -/
theorem ledgerCost_single (w : I → ℝ) (i : I) (n : ℕ) :
    ledgerCost w (Finsupp.single i n) = (n : ℝ) * w i := by
  unfold ledgerCost
  rw [Finsupp.sum_single_index (by simp)]

/-- **The cokernel fix.** Two independent copies of the same defect cost `2 w i`,
not `w i`. Multiplicity is genuinely represented, so the free ledger needs no
restriction of independence to avoid `1 = 2`: on this carrier, `1 + 1 = 2`. -/
theorem two_independent_same_defects (w : I → ℝ) (i : I) :
    ledgerCost w (Finsupp.single i 1 + Finsupp.single i 1) = 2 * w i := by
  rw [ledgerCost_add, ledgerCost_single]
  push_cast
  ring

/-- The Boolean two-state floor of T0 is the unit-weight truncation of the
ledger: cost equals multiplicity, and the Boolean floor is the clamp to
`{0, 1}`. -/
theorem boolean_floor_is_truncation (i : I) (n : ℕ) :
    ledgerCost (fun _ => (1 : ℝ)) (Finsupp.single i n) = (n : ℝ) := by
  rw [ledgerCost_single]; ring

What this page does not claim

Unit cost is the only possible cost structure. Any physical system actually uses this accounting. The theorem by itself forces the golden ratio or the eight-tick cycle.

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/Foundation/RecognitionLedgerFloor.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: