Foundation Pair Kernel Gap2a Noether Momentum Map Carrier Pairs Generator Of Lin

The pairing condition

A posting is the atomic event in a recognition ledger, a discrete record of events in which each step carries a cost. The framework models a minimal, legal posting as a unit step along an action line, and it asks a precise question: which linear rule for assigning a real number to such a step is consistent with the ledger's own structure? The answer, proved in the machine-checked library of formal theorems, is that a linear rule qualifies exactly when it sends the primitive action generator to the number 1. That single condition, written μ(action generator) = 1, is both necessary and sufficient.

The theorem named pairs_generator_of_linear_implies_extends states the sufficiency direction: if a linear functional pairs the action generator with 1, then it extends the primitive character along the action orbit. The necessity direction is also proved, so the two properties are equivalent. This equivalence forces the carrier to be unique: any linear functional satisfying the pairing condition must equal the canonical real character extension, which is the unique real-linear functional that recovers the primitive positive character on every orbit displacement. The uniqueness theorem noetherMomentumMapCovector_unique proves this, and the existence theorem legalAtomicTickMomentumMap_exists_unique shows that for every legal atomic tick, exactly one such covector exists.

The numerical value of this carrier is not arbitrary. It coincides with the already-derived unique action-lattice cotangent coordinate, and it is the reciprocal of the native action quantum. The framework proves this coincidence as a theorem, not as a definitional choice. The construction is motivated by the generator-plus-character pairing inside the Noether and symplectic package, not by renaming an existing cotangent residual. The carrier is also independent of the particular tick: every legal atomic tick yields the same covector, a fact proved by noetherMomentumMapCovector_independent_of_tick.

What the theorem does not claim is just as important as what it proves. The carrier is not identified with the physical pair-kernel source. The declaration CarrierDoesNotIdentifyPhysicalSource is a definition that holds trivially, and the docstring explicitly states that the module does not assume source · action = unit, NativeActionDualSourceLaw, Green-sum continuum, or endpoint data. The equality of this carrier to an independently constructed pair-kernel physical source covector, recorded as MomentumMapLedgerPostingAdjacency.LegalAtomicTick_eq_PairKernelSourceCovector, remains open. The schema for that equality lane is recorded but not proved. The framework also rejects the naive unpriced primitive covector, the identity linear map, because it fails the pairing condition: the action generator is strictly less than 1, so the identity map cannot send it to 1.

The practical upshot is that the ledger's internal consistency fixes the form of the momentum-map covector before any physical interpretation is attached. A reader can now see that the pairing condition is a structural constraint, not a free choice, and that the framework has deliberately left the bridge to physical pair-kernel sources as an open target for future work.

theorem pairs_generator_of_linear_implies_extends
    (μ : PostingDual) (hμ : PairsGeneratorToPrimitiveCharacter μ) :
    ExtendsPrimitiveCharacterAlongAction μ := by
  intro n
  have hgen := atomicTickActionGenerator_eq_nativeActionQuantum
  have hpair : μ nativeActionQuantum = 1 := by
    simpa [PairsGeneratorToPrimitiveCharacter, hgen] using hμ
  have hsmul :
      μ ((n : ℝ) • nativeActionQuantum) = (n : ℝ) • μ nativeActionQuantum :=
    map_smul μ (n : ℝ) nativeActionQuantum
  calc
    μ (actionLatticeEmbed n)
        = μ ((n : ℝ) * nativeActionQuantum) := by simp [actionLatticeEmbed]
    _ = μ ((n : ℝ) • nativeActionQuantum) := by simp [smul_eq_mul]
    _ = (n : ℝ) • μ nativeActionQuantum := hsmul
    _ = (n : ℝ) * 1 := by simp [hpair, smul_eq_mul]
    _ = primitiveCharacterReal n := by simp [primitiveCharacterReal]

theorem extends_implies_pairs_generator
    (μ : PostingDual) (hμ : ExtendsPrimitiveCharacterAlongAction μ) :
    PairsGeneratorToPrimitiveCharacter μ := by
  have h := hμ primitivePosting
  simpa [PairsGeneratorToPrimitiveCharacter, atomicTickActionGenerator,
    actionLatticeEmbed, primitivePosting, primitiveCharacterReal] using h

/-- Uniqueness: any operational momentum-map covector equals the constructed
carrier. -/
theorem noetherMomentumMapCovector_unique
    (μ : PostingDual) (hμ : IsNoetherMomentumMapCovector μ) :
    μ = noetherMomentumMapCovectorLinear := by
  have hExt : ExtendsPrimitiveCharacterAlongAction μ := hμ.2
  have hCanon : μ = canonicalRealCharacterExtension :=
    uniqueRealCharacterExtension μ hExt
  exact hCanon.trans noetherMomentumMapCovectorLinear_eq_canonical.symm

theorem legalAtomicTickMomentumMap_exists_unique
    {d : Nat} {L L' : LedgerPostingAdjacency.LedgerState d}
    (tick : LedgerPostingAdjacency.LegalAtomicTick (d := d) L L') :
    ∃! μ : PostingDual, IsNoetherMomentumMapCovector μ := by
  refine ⟨noetherMomentumMapCovector tick,
    noetherMomentumMapCovector_isOperational tick, ?_⟩
  intro μ hμ
  exact (legalAtomicTickMomentumMap_unique tick μ).1 hμ

theorem noetherMomentumMapCoordinate_eq_uniqueCotangent :
    noetherMomentumMapCoordinate = uniqueCotangentCoordinate := by
  simp [noetherMomentumMapCoordinate, uniqueCotangentCoordinate,
    atomicTickActionGenerator_eq_nativeActionQuantum]

/-- All realized LedgerPostingAdjacency.LegalAtomicTicks share the same momentum-map covector. -/
theorem noetherMomentumMapCovector_independent_of_tick
    {d₁ d₂ : Nat}
    {L₁ L₁' : LedgerPostingAdjacency.LedgerState d₁} {L₂ L₂' : LedgerPostingAdjacency.LedgerState d₂}
    (tick₁ : LedgerPostingAdjacency.LegalAtomicTick (d := d₁) L₁ L₁')
    (tick₂ : LedgerPostingAdjacency.LegalAtomicTick (d := d₂) L₂ L₂') :
    noetherMomentumMapCovector tick₁ = noetherMomentumMapCovector tick₂ :=
  rfl

What this page does not claim

The carrier is not identified with the physical pair-kernel source. The theorem does not assume source · action = unit, NativeActionDualSourceLaw, Green-sum continuum, or endpoint data. The equality to an independently constructed pair-kernel source covector is not proved here.

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