Foundation Pair Kernel Coherence Event Constructor S15 Null Energy Preserves Pos

The null-energy countermodel

In Recognition Science, a recognition event is a discrete record of a comparison: the framework's ledger, a record of events, logs one posting when two sites in a three-dimensional torus are compared. The theorem named nullEnergy_preserves_postingParents_but_not_coherence establishes a precise boundary: an event can satisfy every structural condition of a legal posting while carrying zero energy, and that zero energy means it does not qualify as a coherence event, one that realizes the framework's fundamental energy quantum.

The theorem, proved in the framework's machine-checked library of formal theorems, constructs a concrete event in a three-site system. That event has three properties simultaneously. First, its posting multiplicity, the number of times the pair appears in the event batch, is exactly one. Second, the event is a legal atomic tick: there exist ledger states A and B such that the posting step from A to B is valid and the tick is legal. Third, the event spans exactly one tick on the recognition clock, the framework's discrete time counter. Yet the energy assigned to this event by the null energy function is zero, and the theorem proves this zero-energy assignment fails the condition that every realized primitive posting carries the coherence energy E_coh.

The result is a countermodel, not a derivation. It shows that the structural conditions of posting legality do not by themselves force the energy condition. The framework's own documentation names this as one of several countermodels, alongside cycle-distributed energy, octave duration, and orientation variants, that delimit what the missing semantics must exclude. The theorem closes three discrete layers of the constructor: event identity as a subtype of one oriented pair, relation-set multiplicity of one, and a clock advance of one successor. It does not turn that successor into a physical duration, and it does not price configuration degrees by phi to the minus one.

The consequence is a sharper picture of what the framework claims. Legality of a posting, in the sense of being a recognized event with correct multiplicity and tick span, is one thing. Carrying the coherence energy is another. The theorem proves these are independent, and it does so with no unproved assumptions, no sorry, and no new axioms. What remains open is the physical bridge: the framework has not yet proved that a legal posting's successor tick corresponds to a real duration, nor that configuration degrees are priced by phi to the minus one. Those are separate target predicates, and the null-energy countermodel exists precisely to show what those missing predicates must exclude.

For the reader, the practical lesson is that the framework's structural machinery is not a shortcut to its energy claims. A machine-checked proof of posting legality does not imply a machine-checked proof of coherence energy. The two layers are deliberately separated, and the null-energy theorem is the evidence that the separation is real, not a formality.

/-- Null-event countermodel: all posting, multiplicity, cadence, and
conservation parents remain available while zero energy fails the coherence
price. -/
theorem nullEnergy_preserves_postingParents_but_not_coherence :
    ∃ event : RealizedPostingEvent3 3,
      postingPairMultiplicity3 3 event.1.1 event.1.2 = 1 ∧
        (∃ A B : LedgerPostingAdjacency.LedgerState 3,
          PostingStep A B ∧ LegalAtomicTick A B) ∧
        postingEventTickSpan3 event = 1 ∧
        ¬ RealizedPostingEnergyEqualsCoherence3
          (@nullPostingEnergy3 3 _) := by
  obtain ⟨pair, hpair⟩ :=
    realizedPrimitivePostingPair3_exists
  let event : RealizedPostingEvent3 3 :=
    ⟨pair, hpair⟩
  obtain ⟨A, B, hpost, hlegal, _⟩ :=
    realizedPostingEvent_has_ledger_tick event
  refine
    ⟨event,
      realizedPostingEvent_pairMultiplicity_one event,
      ⟨A, B, hpost, hlegal⟩,
      postingEventTickSpan3_eq_one event, ?_⟩
  intro henergy
  have hzero := henergy event.1 event.2
  change 0 = Constants.E_coh at hzero
  exact (ne_of_lt Constants.E_coh_pos) hzero

/-- Null-event countermodel: all posting, multiplicity, cadence, and
conservation parents remain available while zero energy fails the coherence
price. -/
theorem nullEnergy_preserves_postingParents_but_not_coherence :
    ∃ event : RealizedPostingEvent3 3,
      postingPairMultiplicity3 3 event.1.1 event.1.2 = 1 ∧
        (∃ A B : LedgerPostingAdjacency.LedgerState 3,
          PostingStep A B ∧ LegalAtomicTick A B) ∧
        postingEventTickSpan3 event = 1 ∧
        ¬ RealizedPostingEnergyEqualsCoherence3
          (@nullPostingEnergy3 3 _) := by
  obtain ⟨pair, hpair⟩ :=
    realizedPrimitivePostingPair3_exists
  let event : RealizedPostingEvent3 3 :=
    ⟨pair, hpair⟩
  obtain ⟨A, B, hpost, hlegal, _⟩ :=
    realizedPostingEvent_has_ledger_tick event
  refine
    ⟨event,
      realizedPostingEvent_pairMultiplicity_one event,
      ⟨A, B, hpost, hlegal⟩,
      postingEventTickSpan3_eq_one event, ?_⟩
  intro henergy
  have hzero := henergy event.1 event.2
  change 0 = Constants.E_coh at hzero
  exact (ne_of_lt Constants.E_coh_pos) hzero

/-- One oriented S8 event has relation-set multiplicity exactly one. -/
theorem realizedPostingEvent_pairMultiplicity_one
    {N : ℕ} [NeZero N]
    (event : RealizedPostingEvent3 N) :
    postingPairMultiplicity3 N event.1.1 event.1.2 = 1 :=
  realizedPostingPair_multiplicity_one event.2

/-- Every constructed event has the complete S14 posting ancestry. -/
theorem realizedPostingEvent_has_ledger_tick
    {N : ℕ} [NeZero N]
    (event : RealizedPostingEvent3 N) :
    ∃ A B : LedgerPostingAdjacency.LedgerState 3,
      PostingStep A B ∧
        LegalAtomicTick A B ∧
        JMinimalPostingStep A B ∧
        ledgerL1Cost A B = 1 ∧
        ledgerJlogCost A B = Cost.Jlog 1 ∧
        (∑ k : Fin (TorusCard3 N),
          divF (elementaryPosting event.1.1 event.1.2) k) = 0 :=
  realizedPrimitivePostingPair_has_legalAtomicTick_and_cost
    event.1 event.2

theorem postingEventTickSpan3_eq_one
    {N : ℕ} [NeZero N]
    (event : RealizedPostingEvent3 N) :
    postingEventTickSpan3 event = 1 := by
  simp [postingEventTickSpan3, postingEventEndTick3,
    postingEventStartTick3, ledgerTick, LedgerTime.writeHead,
    LedgerTime.commit]

What this page does not claim

The theorem does not claim that a legal posting can never carry coherence energy, only that legality does not force it. The theorem does not claim that the null energy function is a physically realizable energy assignment. The theorem does not claim that the recognition clock successor corresponds to any physical duration.

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