Foundation Pair Kernel Posting Boundary Record

The posting boundary record

In Recognition Science, a posting is the atomic event of a ledger: one account debited, one account credited, nothing else. The module under discussion, PairKernelPostingBoundaryRecord, defines a way to read that event as a number. It takes the posting's debit region, the singleton set containing the source account, and measures the flow of the posting across that region's boundary. The result is the posting boundary record, a real number attached to the event.

The central theorem is almost disarmingly simple: for any posting from a source to a distinct sink, the boundary record equals 1. The proof runs through a chain of definitions: the boundary flux is shown equal to a divergence term, which for the elementary posting evaluates to 1. This is not a convention; it is forced by the definitions of the ledger and the flux. The same theorem also shows the reverse flow, from sink to source, yields -1, so the record carries the orientation of the posting.

Why does this matter? Because the record is supposed to identify the posting. The module proves that two oriented postings are the same if and only if they share the same source and sink. But the scalar record alone cannot do that job. A separate theorem shows that for any dimension at least 3, there exist two distinct oriented postings with the same flux value. The number 1 does not tell you which pair of accounts moved; it only tells you that some posting occurred. Identity lives in the pair of poles, not in the scalar.

The module then asks whether a moving cut, a bookkeeping device that shifts a boundary, could recover the posting's identity from the bare bit. The answer is no. The framework proves that any cut bit that recovers the posting boundary record must be constant, always 1, and therefore carries no information about which posting occurred. The bridge statement that a posting record is a moving cut record is left as an open target, because the bare bit is forced into a free constant channel, which is refused as occurrence identity.

In Recognition Science, the posting boundary record establishes a precise sense in which a ledger event leaves a trace: a forced scalar signature of 1, with orientation, but no identity. The framework's library, a machine-checked collection of formal theorems, proves these results with no axioms beyond the standard three and no free parameters. The practical lesson is that a scalar trace is enough to certify that an event happened, but not which event; identity requires the full oriented pair.

/-- Forward orientation: debit-region boundary record is `+1`. -/
theorem postingBoundaryRecord_forward
    {n : ℕ} (source sink : Fin n) (h : source ≠ sink) :
    postingBoundaryRecord source sink = 1 := by
  rw [postingBoundaryRecord_eq_div_source]
  exact elementaryPosting_div_source source sink h

/-- Reverse-flow orientation: the reversed elementary flow across the *same*
debit region has boundary record `-1`. -/
theorem postingBoundaryRecord_reversed_flow
    {n : ℕ} (source sink : Fin n) (h : source ≠ sink) :
    boundaryFluxAcrossDebit (elementaryPosting sink source) source = -1 := by
  rw [boundaryFluxAcrossDebit_eq_div (elementaryPosting_antisym sink source)]
  exact elementaryPosting_div_sink sink source (Ne.symm h)

theorem same_posting_iff_same_oriented_poles
    {n : ℕ} (r₁ r₂ : OrientedPostingBoundaryRecord n) :
    r₁ = r₂ ↔ r₁.source = r₂.source ∧ r₁.sink = r₂.sink :=
  orientedPostingBoundaryRecord_eq_iff_same_poles r₁ r₂

/-- Scalar-coincidence decoy: equal unit fluxes do not identify poles. -/
theorem scalar_flux_eq_does_not_force_same_poles
    {n : ℕ} (hn : 3 ≤ n) :
    ∃ r₁ r₂ : OrientedPostingBoundaryRecord n,
      r₁.flux = r₂.flux ∧ r₁ ≠ r₂ := by
  have hpos : 0 < n := lt_of_lt_of_le (by decide : (0 : ℕ) < 3) hn
  have h1 : 1 < n := lt_of_lt_of_le (by decide : (1 : ℕ) < 3) hn
  have h2 : 2 < n := lt_of_lt_of_le (by decide : (2 : ℕ) < 3) hn
  let a : Fin n := ⟨0, hpos⟩
  let b : Fin n := ⟨1, h1⟩
  let c : Fin n := ⟨2, h2⟩
  have hab : a ≠ b := by
    intro h; exact (by decide : (0 : ℕ) ≠ 1) (congrArg Fin.val h)
  have hac : a ≠ c := by
    intro h; exact (by decide : (0 : ℕ) ≠ 2) (congrArg Fin.val h)
  refine ⟨⟨a, b, hab⟩, ⟨a, c, hac⟩, ?_, ?_⟩
  · simp [OrientedPostingBoundaryRecord.flux,
      postingBoundaryRecord_forward a b hab,
      postingBoundaryRecord_forward a c hac]
  · intro hEq
    have hsink :=
      (orientedPostingBoundaryRecord_eq_iff_same_poles
        ⟨a, b, hab⟩ ⟨a, c, hac⟩).mp hEq
    exact (by decide : (1 : ℕ) ≠ 2) (congrArg Fin.val hsink.2)

theorem recovers_implies_constant
    (attach : CutBitOfOrientedPosting)
    (hrec : RecoversPostingBoundaryRecord attach) :
    IsConstantCutBit attach :=
  ⟨(1 : ZMod 2), fun _ _ _ => recovers_forces_posted_one attach hrec _ _ _⟩

What this page does not claim

The posting boundary record identifies which posting occurred; it only certifies that one did. The moving cut bridge is proved; it is stated as an open target. The module derives any physical constant such as hbar or G.

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