Foundation Pair Kernel Posting Boundary Record Posted Zero Flow Not Realized Bou

The zero-flow boundary record

A boundary record is a number attached to the edge of a region, summarizing the flow across that edge. In the Recognition Science framework, a posting is the basic act of moving a unit of value from one account, the source, to another, the sink. The framework's library of machine-checked theorems defines a posting's boundary record as the flux, or net flow, across the boundary of the source's region. The declaration posted_zero_flow_not_realized_boundaryRecord proves that a zero boundary record does not mean no posting happened. It shows that a region with no flow at all has boundary record 0, while any actual posting from a source to a distinct sink has boundary record 1.

The theorem's content is a contrast between two cases. The first case defines a zero flow, where every entry in the flow matrix is 0, and proves its boundary record is 0. The second case takes any posting between distinct accounts and proves its boundary record is 1, not 0. These two results together establish that the boundary record alone cannot distinguish "no posting" from "a posting whose record happens to read zero." The record is a scalar, a single number, and that number is the same for the empty flow and for the unit posting. The framework's library proves this distinction is real: the zero-flow boundary record equals 0, and the posting boundary record equals 1, so they are different values, but the record itself does not carry enough information to say which situation produced it.

This result matters because it draws a line around what a boundary record can certify. The record certifies that flux crossed the boundary, but it does not certify which posting produced that flux. The library proves this limitation directly: two different oriented postings can have the same flux value. The framework models a posting as an oriented pair of source and sink, and the record of that posting is its flux. Two distinct oriented pairs can share the same flux, so the scalar record cannot be used to recover the specific posting. The framework states this as an open problem: recovering the posting's identity from the record alone is not achieved, because the recovery would require a free choice of which bit to assign, and that free choice is refused as a genuine occurrence identity.

What the declaration does not claim is just as important. It does not claim that a zero boundary record is impossible for a real posting; it proves the opposite, that the record of a real posting is 1. It does not claim that the boundary record identifies the posting; the library proves it cannot, because distinct postings share the same flux. It does not claim anything about the physical constants of the framework, such as the Planck endpoints or the gravitational constant, which appear nowhere in this theorem. The declaration is a precise, narrow statement about the information content of a boundary record, and its value is in showing exactly what that record can and cannot certify.

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

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

A zero boundary record is impossible for a real posting. The boundary record identifies which posting occurred. The theorem involves physical constants like the Planck endpoints or the gravitational constant.

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: