Foundation Pair Kernel Production Action Construction S8 Recognition Constructio

The production graph

A ledger, a discrete record of recognition events, can be viewed as a network: sites are accounts, and a posting between two accounts is a directed connection. The Recognition Science framework builds such a network from primitive events, the smallest possible double-entry postings that keep the ledger's cost at its minimum. The question is whether the resulting graph, called the production graph, has the right support: does it connect exactly the pairs that actually post, and does every posting leave a trace in the graph's structure?

The declaration recognitionConstruction_derives_both_support_directions answers both halves at once. It proves, as a theorem in the framework's machine-checked library of formal theorems, that on a finite three-dimensional torus the production graph satisfies two properties. First, the graph's action, its total cost, is nonzero only on realized postings: absent events contribute zero. Second, every primitive posting is active: each realized event contributes a strictly positive coefficient to the graph. Together these say the graph's support exactly matches the set of events that actually occur, with no phantom connections and no silent postings.

The proof works by construction, not by assumption. The framework defines the event batch as the finite set of ordered site pairs that carry a witnessed minimum-J posting, where J is the forced cost function. It then folds that batch into a weighted graph, giving weight one to present events and zero to absent ones. The theorem recognitionConstruction_productionActionIdentity shows this graph's exact action equals the sum of the primitive posting event contributions. From that identity, a prior result derives both support directions, and the declaration assembles the two into a single conjunction. The graph is also loopless, meaning no site posts to itself, and the representation is unique: no other loopless graph carries the same exact action.

The declaration does not claim that this construction explains why three spatial dimensions exist, nor that it derives the value of any physical constant. It operates on a finite torus with a fixed dimension parameter, and the proof requires the torus size to be at least two. It also does not claim that the production graph is the only possible graph, only that it is the unique loopless one with its exact action. The construction is a bridge from primitive posting events to a full production graph, and the theorem certifies that the bridge preserves the support structure exactly.

What this changes is the status of the production graph. Before this declaration, the graph's support properties were an open obligation. Now they are a proved consequence of the event constructor, and the graph can be used as a foundation for further results, such as the global Green consumer and D=3 locality, without re-checking the support conditions. The reader can now treat the production graph as a fully certified object, not a provisional one.

theorem recognitionConstruction_derives_both_support_directions
    {N : ℕ} [NeZero N] (hN : 2 ≤ N) :
    ActionOnlyOnRealizedPostings3 (recognitionProductionGraph3 N) ∧
      EveryPrimitivePostingActive3 (recognitionProductionGraph3 N) :=
  positiveRealizedProductionActionIdentity_derives_both_of_two_le
    hN
    (recognitionProductionGraph3_loopless hN)
    (recognitionConstruction_productionActionIdentity hN)

/-- The complete finite event batch generated by witnessed minimum-J
postings. This is an event constructor, not a support predicate on an
externally supplied graph. -/
noncomputable def realizedPrimitivePostingPairs3
    (N : ℕ) [NeZero N] : Finset (PostingPair3 N) := by
  classical
  exact
    ((Finset.univ : Finset (Fin (TorusCard3 N))).product
      (Finset.univ : Finset (Fin (TorusCard3 N)))).filter
        (fun e => (@encodedMinimumJRelation3 N _) e.1 e.2)

/-- The graph action is exactly the sum of the constructed primitive posting
event contributions. -/
theorem recognitionProductionGraph3_exactJCostAction_eq_eventBatch
    {N : ℕ} [NeZero N]
    (ε : Fin (TorusCard3 N) → ℝ) :
    exactJCostAction (recognitionProductionGraph3 N) ε =
      postingBatchExactJCostAction3
        (realizedPrimitivePostingPairs3 N) ε := by
  classical
  unfold exactJCostAction postingBatchExactJCostAction3
  rw [← Finset.sum_product']
  unfold realizedPrimitivePostingPairs3
  rw [Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro e he
  by_cases hrel : (@encodedMinimumJRelation3 N _) e.1 e.2
  · simp [recognitionProductionGraph3,
      realizedPrimitivePostingPairs3, hrel,
      primitivePostingPairExactJCost3]
  · simp [recognitionProductionGraph3,
      realizedPrimitivePostingPairs3, hrel]

theorem recognitionProductionGraph3_loopless
    {N : ℕ} [NeZero N] (hN : 2 ≤ N) :
    LooplessGraph (recognitionProductionGraph3 N) := by
  intro i
  have hnot :
      ¬ (@encodedMinimumJRelation3 N _) i i := by
    intro h
    unfold encodedMinimumJRelation3 at h
    exact
      noSelfPrimitivePostings3_of_two_le hN
        ((torusSiteEquivFin N).symm i) h
  have hmem :
      (i, i) ∉ realizedPrimitivePostingPairs3 N := by
    simpa using hnot
  exact recognitionProductionGraph3_weight_of_not_mem hmem

/-- Independent uniqueness consequence: the event-fold graph is the unique
loopless graph carrying its exact action. -/
theorem recognitionProductionGraph3_unique_loopless_action_representation
    {N : ℕ} [NeZero N] (hN : 2 ≤ N)
    (G : WeightedLedgerGraph (TorusCard3 N))
    (hloop : LooplessGraph G)
    (haction :
      ∀ ε : Fin (TorusCard3 N) → ℝ,
        exactJCostAction G ε =
          exactJCostAction (recognitionProductionGraph3 N) ε) :
    G = recognitionProductionGraph3 N :=
  exactJCostAction_determines_loopless_graph
    G (recognitionProductionGraph3 N)
    hloop (recognitionProductionGraph3_loopless hN) haction

What this page does not claim

The declaration does not claim that three spatial dimensions are derived from the construction; the dimension is a fixed parameter. The declaration does not claim the production graph is the only possible graph, only the unique loopless one with its exact action. The declaration does not claim any physical constant is derived from the construction.

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