Cosmology Cosmogenesis Sim Flow Product Add Event

Double-entry bookkeeping

Double-entry bookkeeping is a ledger rule: every entry that moves value from one account to another is recorded twice, once as a debit and once as a credit. The Recognition Science framework models this rule in a discrete ledger of recognition events, where each event carries a source, a target, and a ratio. The declaration flowProduct_addEvent proves that adding an event together with its reciprocal leaves the flow product unchanged. The flow product is the product of the ratios of all events touching a given agent; posting a pair multiplies it by r times r⁻¹, which equals 1, so the product is invariant.

The theorem is stated over rational numbers, not reals, and it is proved in the machine-checked library of formal theorems. The proof relies on the fact that the contribution of an event and its reciprocal cancel: if an event has ratio r, its reciprocal has ratio r⁻¹, and their product is 1. The declaration requires only that the ratio be nonzero, which holds for any positive seed. The result is a conservation law: the flow product at every agent stays exactly 1 after the full eight-tick cosmogenesis, for any positive seed, with no runtime checks and no unproved assumptions.

The declaration does not claim that the flow product is conserved in any physical sense, nor that the ledger itself is a physical system. It establishes a formal property of a computable simulation: a kernel-checked statement that a particular bookkeeping rule preserves a particular product. The framework's own claims about physical recognition are separate; this theorem is about the arithmetic of the simulation, not about the cosmos. The conservation law is exact, but it is exact for the model, not for any observed universe.

What the declaration changes is the epistemic status of the simulation: the conservation law is not merely checked at runtime but proved in the kernel. That means the simulation's bookkeeping is guaranteed to balance, and the guarantee is machine-checked. A reader can trust the arithmetic without re-running the simulation. The framework's library makes this guarantee explicit, and the declaration is one of the certificates that the simulation is internally consistent.

/-- **Conservation step.** Posting a paired event leaves the flow product
unchanged at every agent (the `r · r⁻¹ = 1` cancellation). -/
theorem flowProduct_addEvent (L : List QEvent) (e : QEvent) (he : e.ratio ≠ 0)
    (agent : ℕ) : flowProduct (addEvent L e) agent = flowProduct L agent := by
  unfold flowProduct addEvent
  simp only [List.map_cons, List.prod_cons]
  rw [← mul_assoc, flowContribution_pair e he agent, one_mul]

/-- The flow product at an agent: the product over all events of their
contribution. This is the multiplicative (computable) form of σ. Conserved
value is `1`. -/
def flowProduct (es : List QEvent) (agent : ℕ) : ℚ :=
  (es.map (flowContribution agent)).prod

/-- **Conservation step.** Posting a paired event leaves the flow product
unchanged at every agent (the `r · r⁻¹ = 1` cancellation). -/
theorem flowProduct_addEvent (L : List QEvent) (e : QEvent) (he : e.ratio ≠ 0)
    (agent : ℕ) : flowProduct (addEvent L e) agent = flowProduct L agent := by
  unfold flowProduct addEvent
  simp only [List.map_cons, List.prod_cons]
  rw [← mul_assoc, flowContribution_pair e he agent, one_mul]

/-- The recurrence stays positive for a positive seed. -/
theorem recurSeq_pos (seed : ℚ) (hs : 0 < seed) : ∀ t, 0 < recurSeq seed t
  | 0 => hs
  | (n + 1) => by
      have hp : 0 < recurSeq seed n := recurSeq_pos seed hs n
      have hinv : 0 < (recurSeq seed n)⁻¹ := inv_pos.mpr hp
      show (0 : ℚ) < 1 + (recurSeq seed n)⁻¹
      linarith

/-- **σ conservation, proved.** After the full cosmogenesis, the flow product is
exactly `1` at every agent, for any positive seed. No `decide`, no `sorry`. -/
theorem cosmogenesis_conserves (seed : ℚ) (hs : 0 < seed) (agent : ℕ) :
    flowProduct (cosmogenesis seed) agent = 1 :=
  flowProduct_foldl agent (cosmoEvent seed)
    (fun t => (recurSeq_pos seed hs t).ne') 8

What this page does not claim

The declaration does not claim any physical conservation law in an observed universe. It does not claim that the flow product is conserved for arbitrary event sequences, only under the double-entry posting rule. It does not claim that the rational simulation replaces the real-valued dynamics of the PreBigBang and FirstTick modules.

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