Encyclopedia Foundation Foundation Pair Kernel Posting Boundary Record Posting Boundary Record Swapped P

ARTICLE 4 claims 4 theorems

Foundation Pair Kernel Posting Boundary Record Posting Boundary Record Swapped P

A single, forced number appears when a posting is read as a flux across its own boundary, and swapping the two poles changes only its sign.

Verify this page

The boundary record

A posting is a discrete transfer between two accounts, a source and a sink. The framework's ledger, a discrete record of such events, assigns to each posting a boundary record: the posting's credit leg measured as a flow across the boundary of the debit region. That record is not a free parameter. The declaration postingBoundaryRecord_swapped_poles_forward states the forward record is always exactly 1, and its companion theorem shows the reversed flow is exactly -1. The magnitude is forced, not chosen.

The classical picture is Gauss's law. For any antisymmetric flow field, the total flux across a region's boundary equals the divergence inside the region. The framework applies this to a single source pole, so the boundary record of a posting is just the divergence of the elementary posting at its source. The theorem postingBoundaryRecord_forward proves this divergence is 1 whenever source and sink differ, and the swapped-poles theorem extends the same result to the reversed orientation.

This forced unit value has a sharp consequence for recovery. A separate definition asks whether a bit attached to a posting can recover the posting's identity. The theorem recovers_forces_posted_one proves that if such a recovery succeeds, the bit must be 1. But the boundary record cannot distinguish two different postings that share the same flux, because the scalar flux equality does not force the same poles. The framework states this explicitly: the moving-cut occurrence bridge is OPEN, and the bare bit recovery is forced to a free constant channel.

What the declaration does not claim is as important as what it proves. It does not assert that the boundary record identifies the posting. It does not prove that a recovered bit carries occurrence identity. It does not derive any physical constant such as hbar or G. It only fixes the numerical value of a geometric quantity under a specific definition, and that value is 1.

THEOREM postingBoundaryRecord_swapped_poles_forward · postingBoundaryRecord_reversed_flow · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean
postingBoundaryRecord_swapped_poles_forward · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean:87 
/-- The reversed posting (swap poles) has its own forward record `+1` at its
own debit pole; reverse occurrence is distinct, not a negated scalar of the
same poles-as-data. -/
theorem postingBoundaryRecord_swapped_poles_forward
    {n : ℕ} (source sink : Fin n) (h : source ≠ sink) :
    postingBoundaryRecord sink source = 1 :=
  postingBoundaryRecord_forward sink source (Ne.symm h)
postingBoundaryRecord_reversed_flow · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean:70 
/-- 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 postingBoundaryRecord_forward · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean
postingBoundaryRecord_forward · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean:63 
/-- 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
THEOREM recovers_forces_posted_one · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean
recovers_forces_posted_one · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean:307 
theorem recovers_forces_posted_one
    (attach : CutBitOfOrientedPosting)
    (hrec : RecoversPostingBoundaryRecord attach)
    {n : ℕ} (source sink : Fin n) (h : source ≠ sink) :
    attach source sink h = 1 := by
  have hval := hrec source sink h
  rw [postingBoundaryRecord_forward source sink h] at hval
  have hbit : bitReadout (attach source sink h) = true := by
    by_cases hb : bitReadout (attach source sink h)
    · exact hb
    · have hz : postedBitValue (attach source sink h) = 0 := by
        simp [postedBitValue, hb]
      have : (0 : ℝ) = 1 := by
        rw [hz] at hval
        exact_mod_cast hval
      exact absurd this (by norm_num)
  -- `bitReadout x = true` means `x = 1` on `ZMod 2`.
  revert hbit
  generalize attach source sink h = x
  intro hbit
  fin_cases x
  · simp [bitReadout] at hbit
  · rfl
THEOREM scalar_flux_eq_does_not_force_same_poles · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean
scalar_flux_eq_does_not_force_same_poles · IndisputableMonolith/Foundation/PairKernelPostingBoundaryRecord.lean:180 
/-- 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)

What this page does not claim

The declaration does not prove that the boundary record identifies the posting. It does not establish that a recovered bit carries occurrence identity. It does not derive 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:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND