Foundation Pair Kernel Posting Boundary Record Posted Zero Cut Heat Ne Forward B

The posting boundary record

In the Recognition Science framework, the basic act of an accounting system is a posting: one account is debited and another is credited, a discrete transfer between two named poles. The framework's library, a machine-checked collection of formal theorems, defines the boundary record of such a posting. It is the flux, the net flow, of the posting's credit leg measured across the boundary of the debit region, the region containing only the source account. The central result is that for any realized posting between two distinct accounts, this boundary flux is exactly 1. Reversing the direction of the posting, crediting the first account and debiting the second, gives a flux of exactly -1. The framework proves this in its library with no unproved assumptions and no added axioms.

The same library proves that this scalar flux, the single number 1, does not carry enough information to identify which two accounts were involved. Two different postings between different pairs of accounts can have the same flux. The posting's identity lives in its oriented poles, the ordered pair of source and sink, not in the number 1. A separate theorem establishes that a legal tick, one realized step of the ledger, corresponds to a unique posting on a unique account side. The framework also shows that a completely empty cut, a boundary with no flow at all, has a flux of zero, which is never equal to the flux of a realized posting.

In Recognition Science, the framework proves that any attempt to recover the posting's identity from a single recovered bit, a bare 1, forces that bit to be constant across all possible postings. This constant channel cannot distinguish one posting from another, so it is refused as occurrence identity. The bridge that would identify a posting record with a moving cut record is therefore stated as an open target, not a theorem. The framework proves the negative result: no such non-constant recovery exists on the bit carrier. What the framework does not claim is that the number 1 itself is the posting. The flux is a boundary trace, a necessary consequence of the posting, but the posting is the ordered pair of accounts, and the flux alone cannot tell you which pair it was.

/-- 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)

/-- 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 posted_zero_flow_not_realized_boundaryRecord
    {n : ℕ} (source sink : Fin n) (h : source ≠ sink) :
    zeroFlowBoundaryRecord source = 0 ∧
      postingBoundaryRecord source sink ≠ 0 := by
  refine ⟨zeroFlowBoundaryRecord_eq_zero source, ?_⟩
  rw [postingBoundaryRecord_forward source sink h]
  norm_num

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 scalar flux of a posting is sufficient to identify which two accounts were involved. The framework proves that a posting record is identical to a moving cut record. The number 1 is the posting itself, rather than a boundary trace of it.

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: