Foundation Pair Kernel Posting Boundary Record Oriented Posting Boundary Record

The boundary record and its poles

A posting, in the Recognition Science framework, is a primitive move: a unit of flow from one pole, the source, to a different pole, the sink. The framework models this with a structure called an oriented posting boundary record, which stores the source, the sink, and the fact that they are distinct. The boundary record itself is a real number computed from this structure: it reads the posting's flow as a flux across the boundary of the source's region. The theorem orientedPostingBoundaryRecord_eq_iff_same_poles states that two such records are equal if and only if they have the same source and the same sink. In plain terms, the record is a perfect fingerprint of the oriented pair of poles: no two different postings produce the same boundary record.

The result is proved in the framework's machine-checked library of formal theorems. The proof is short: if the records are equal, then their sources and sinks must match, and conversely, if the sources and sinks match, the records are identical by definition. This is a structural fact about how the record is defined, not an empirical observation. The theorem also gives a clean statement of what a posting is: a posting is exactly its oriented pair of poles. The framework uses this to show that a legal atomic tick, a single allowed step in a ledger state, has a unique account and side that produced it. This uniqueness is what lets the framework treat a posting as a discrete, identifiable event.

What the theorem does not claim is that the boundary record's numerical value, the flux, is itself a unique identifier. The framework proves the opposite: for any system with at least three poles, there exist two different oriented posting boundary records with the same flux. The flux is always 1 for any posting, so the number 1 cannot tell you which posting occurred. The identity of a posting lives in the oriented pair of poles, not in the scalar flux. This distinction matters for a separate question, the moving-cut occurrence bridge, which the framework states as OPEN: whether a bare bit can recover the identity of a posting from a moving cut. The theorem here shows that the bit, which carries only the flux value, cannot do so; the identity requires the full oriented structure.

theorem orientedPostingBoundaryRecord_eq_iff_same_poles
    {n : ℕ} (r₁ r₂ : OrientedPostingBoundaryRecord n) :
    r₁ = r₂ ↔ r₁.source = r₂.source ∧ r₁.sink = r₂.sink := by
  constructor
  · intro h; subst h; exact ⟨rfl, rfl⟩
  · intro h
    cases r₁; cases r₂
    cases h with
    | intro hs ht =>
      subst hs ht
      rfl

/-- 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 legalAtomicTick_existsUnique_account_side
    {d : Nat} {L L' : LedgerPostingAdjacency.LedgerState d}
    (h : LegalAtomicTick L L') :
    ∃! p : Fin d × Side, L' = post L p.1 p.2 :=
  postingStep_existsUnique_account_side
    (legalAtomicTick_implies_PostingStep h)

What this page does not claim

The scalar flux value alone does not identify a posting; the theorem does not claim it does. The theorem does not claim that the moving-cut occurrence bridge is closed; it is stated as OPEN. The theorem does not involve physical constants like the fine-structure constant or Planck's 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: