Encyclopedia Foundation Foundation Pair Kernel Lattice3

ARTICLE 5 claims 4 theorems 1 model

Foundation Pair Kernel Lattice3

A machine-checked library builds a three-dimensional lattice and proves that its two-body cost no longer fades with distance, a stark contrast to one dimension.

Verify this page

The three-dimensional box

In Recognition Science, a ledger is a discrete record of events, and the cost of recognition is the price the framework assigns to moving between two entries. The module called foundation pair kernel lattice3 constructs the first genuinely three-dimensional carrier for this cost: an L by L by L box of sites, where each site connects to its six nearest neighbors. The distance between two sites is the taxicab metric, the sum of coordinate differences, so that two sites are coupled exactly when they differ by one step along a single axis.

The central theorem is a dimension dichotomy. In one dimension, the minimum cost between two pinned sites decays as 1/d, vanishing as the distance grows. In three dimensions, the same minimum cost is bounded below by a positive constant independent of distance. The reason is the recurrence and transience of the lattice random walk: a one-dimensional walk returns to its start almost surely, while a three-dimensional walk escapes to infinity. The effective resistance between two sites grows without bound in one dimension but converges to a finite limit in three, so the cost saturates rather than decaying.

This corrects a naive plan. The Coulomb interaction 1/(4πr) is not the asymptotics of the pinned-pair cost; it is the lattice Green's function, the response to a unit charge. The module proves the cost on the box is non-vacuous: an adjacent pair costs at least 1, and a pair separated by r steps along an axis costs at least 1/r, with a two-route bound of 2/(r+1). These are lower bounds, not the full asymptotics, which remain open targets.

In Recognition Science, the framework models the box's energy as a sum over coupled pairs, with the quadratic action as a leading-order premise. The three axes appear as three independent directions from any interior site, the carrier reading off dimension three. The proofs are machine-checked, with no axioms beyond the standard three, and the quadratic action is a stated modeling choice, not a derived law.

THEOREM boxWeight · IndisputableMonolith/Foundation/PairKernelLattice3.lean
boxWeight · IndisputableMonolith/Foundation/PairKernelLattice3.lean:84 
/-- **The D=3 nearest-neighbor lattice graph.** Weight `1` inside the ℓ¹ unit ball (the 6-neighbor
    coupling of the cubic lattice), `0` outside, transported onto `Fin (L*L*L)` via `enc3`. -/
def boxWeight (L : ℕ) : WeightedLedgerGraph (L * L * L) where
  weight i j := if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then 1 else 0
  weight_nonneg i j := by split <;> norm_num
  weight_symm i j := by rw [dist3_comm ((enc3 L).symm i) ((enc3 L).symm j)]
THEOREM pairMin_box_dist2_ge_one · IndisputableMonolith/Foundation/PairKernelLattice3.lean
pairMin_box_dist2_ge_one · IndisputableMonolith/Foundation/PairKernelLattice3.lean:1055 
/-- **The strict D=3 dichotomy witness on the box.** The endpoints `a = (0,0,0)` and
    `b = (1,1,0)` sit at ℓ¹-distance `2` on the cubic lattice, yet `pairMin (boxWeight L) 0 b ≥ 1`,
    routed through the two intermediate sites `u = (1,0,0)`, `v = (0,1,0)` (each ℓ¹-adjacent to
    both endpoints). The 1D chain forbids this: at distance `2` it has `pairMin ≤ 1/2`
    (`pairMin_band_le_inv_dist`). The extra parallel path is exactly the second spatial dimension.
    This is the smallest concrete instance of the transience half of the dimension dichotomy;
    the general `r`-independent radial shell flow is the next step. -/
theorem pairMin_box_dist2_ge_one {L : ℕ} (hL : 2 ≤ L) :
    (1:ℝ) ≤ pairMin (boxWeight L)
      (enc3 L ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩))
      (enc3 L ((⟨1, by omega⟩, ⟨1, by omega⟩), ⟨0, by omega⟩)) := by
  set o : Site3 L := ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) with ho
  set d : Site3 L := ((⟨1, by omega⟩, ⟨1, by omega⟩), ⟨0, by omega⟩) with hd
  set ex : Site3 L := ((⟨1, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) with hex
  set ey : Site3 L := ((⟨0, by omega⟩, ⟨1, by omega⟩), ⟨0, by omega⟩) with hey
  have hw01 : ∀ i j, (boxWeight L).weight i j = 0 ∨ (boxWeight L).weight i j = 1 := by
    intro i j
    show (if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then (1:ℝ) else 0) = 0
        ∨ (if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then (1:ℝ) else 0) = 1
    split_ifs
    · exact Or.inr rfl
    · exact Or.inl rfl
  have hau : enc3 L o ≠ enc3 L ex := by
    intro h; have h2 := (enc3 L).injective h; rw [ho, hex] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have hav : enc3 L o ≠ enc3 L ey := by
    intro h; have h2 := (enc3 L).injective h; rw [ho, hey] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have hab : enc3 L o ≠ enc3 L d := by
    intro h; have h2 := (enc3 L).injective h; rw [ho, hd] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have hub : enc3 L ex ≠ enc3 L d := by
    intro h; have h2 := (enc3 L).injective h; rw [hex, hd] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have hvb : enc3 L ey ≠ enc3 L d := by
    intro h; have h2 := (enc3 L).injective h; rw [hey, hd] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have huv : enc3 L ex ≠ enc3 L ey := by
    intro h; have h2 := (enc3 L).injective h; rw [hex, hey] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2; omega
  have wau : (boxWeight L).weight (enc3 L o) (enc3 L ex) = 1 := by
    rw [boxWeight_enc, if_pos]; rw [ho, hex]; simp only [dist3, Nat.dist]; decide
  have wub : (boxWeight L).weight (enc3 L ex) (enc3 L d) = 1 := by
    rw [boxWeight_enc, if_pos]; rw [hex, hd]; simp only [dist3, Nat.dist]; decide
  have wav : (boxWeight L).weight (enc3 L o) (enc3 L ey) = 1 := by
    rw [boxWeight_enc, if_pos]; rw [ho, hey]; simp only [dist3, Nat.dist]; decide
  have wvb : (boxWeight L).weight (enc3 L ey) (enc3 L d) = 1 := by
    rw [boxWeight_enc, if_pos]; rw [hey, hd]; simp only [dist3, Nat.dist]; decide
  exact pairMin_ge_one_via_two_paths (boxWeight L) hw01 hau hav hab hub hvb huv wau wub wav wvb
THEOREM pairMin_box_axial_ge_inv · IndisputableMonolith/Foundation/PairKernelLattice3.lean
pairMin_box_axial_ge_inv · IndisputableMonolith/Foundation/PairKernelLattice3.lean:1333 
/-- **Axial single-path bound on the D=3 box.** For `0 < r < L`, the straight axial walk of length
    `r` gives `pairMin (boxWeight L) 0 (r·e₁) ≥ 1/r`. This is the flow-side lower bound on the box
    (reproducing the 1D rate); the parallel-tube flow beats it. -/
theorem pairMin_box_axial_ge_inv {L r : ℕ} (hr : r < L) (hr0 : 0 < r) :
    (1:ℝ) / r ≤ pairMin (boxWeight L)
      (enc3 L ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩))
      (enc3 L ((⟨r, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩)) := by
  have hL : 0 < L := by omega
  set v : ℕ → Fin (L * L * L) :=
    fun k => enc3 L ((⟨k % L, Nat.mod_lt k hL⟩, ⟨0, hL⟩), ⟨0, hL⟩) with hv
  have hw01 : ∀ i j, (boxWeight L).weight i j = 0 ∨ (boxWeight L).weight i j = 1 := by
    intro i j
    show (if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then (1:ℝ) else 0) = 0
        ∨ (if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then (1:ℝ) else 0) = 1
    split_ifs
    · exact Or.inr rfl
    · exact Or.inl rfl
  have hinj : ∀ i ≤ r, ∀ j ≤ r, v i = v j → i = j := by
    intro i hi j hj h
    have h2 := (enc3 L).injective h
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2
    have := h2.1.1
    rw [Nat.mod_eq_of_lt (by omega), Nat.mod_eq_of_lt (by omega)] at this
    exact this
  have hedge : ∀ k, k < r → (boxWeight L).weight (v k) (v (k + 1)) = 1 := by
    intro k hk
    simp only [hv]
    rw [boxWeight_enc, if_pos]
    show dist3 ((⟨k % L, Nat.mod_lt k hL⟩, (⟨0, hL⟩ : Fin L)), (⟨0, hL⟩ : Fin L))
        ((⟨(k + 1) % L, Nat.mod_lt (k + 1) hL⟩, (⟨0, hL⟩ : Fin L)), (⟨0, hL⟩ : Fin L)) ≤ 1
    show Nat.dist (k % L) ((k + 1) % L) + Nat.dist 0 0 + Nat.dist 0 0 ≤ 1
    rw [Nat.mod_eq_of_lt (by omega : k < L), Nat.mod_eq_of_lt (by omega : k + 1 < L)]
    simp only [Nat.dist_self, Nat.add_zero]
    show Nat.dist k (k + 1) ≤ 1
    unfold Nat.dist; omega
  have h0 : v 0 = enc3 L ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) := by
    simp only [hv]
    apply congrArg
    simp only [Prod.mk.injEq, Fin.mk.injEq]
    exact ⟨⟨Nat.zero_mod L, trivial⟩, trivial⟩
  have hrr : v r = enc3 L ((⟨r, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) := by
    simp only [hv]
    apply congrArg
    simp only [Prod.mk.injEq, Fin.mk.injEq]
    exact ⟨⟨Nat.mod_eq_of_lt hr, trivial⟩, trivial⟩
  rw [← h0, ← hrr]
  exact pairMin_ge_inv_pathLength (boxWeight L) hw01 v r hr0 hinj hedge
THEOREM Wpair_box_adjacent_ge_one · IndisputableMonolith/Foundation/PairKernelLattice3.lean
Wpair_box_adjacent_ge_one · IndisputableMonolith/Foundation/PairKernelLattice3.lean:111 
/-- **The pinned-pair kernel is non-vacuous on the D=3 box.** An ℓ¹-adjacent pair costs `≥ 1`. This
    transports for free from L3's graph-generic `pairMin_ge_weight`, and is the concrete link from
    the D=3 carrier back to the Door 2 two-body cost `Wpair`. -/
theorem Wpair_box_adjacent_ge_one {L : ℕ} (hL : 2 ≤ L) :
    (1:ℝ) ≤ Wpair (boxWeight L)
      (enc3 L ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩))
      (enc3 L ((⟨1, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩)) := by
  rw [Wpair_eq_pairMin]
  set o : Site3 L := ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) with ho
  set e : Site3 L := ((⟨1, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩) with he
  have hne : enc3 L o ≠ enc3 L e := by
    intro h
    have h2 := (enc3 L).injective h
    rw [ho, he] at h2
    simp only [Prod.mk.injEq, Fin.mk.injEq] at h2
    omega
  have hw : (boxWeight L).weight (enc3 L o) (enc3 L e) = 1 := by
    rw [boxWeight_enc, if_pos]
    rw [ho, he]
    simp only [dist3, Nat.dist]
    decide
  calc (1:ℝ) = (boxWeight L).weight (enc3 L o) (enc3 L e) := hw.symm
    _ ≤ pairMin (boxWeight L) (enc3 L o) (enc3 L e) := pairMin_ge_weight (boxWeight L) hne
MODEL flowEnergy · IndisputableMonolith/Foundation/PairKernelLattice3.lean
flowEnergy · IndisputableMonolith/Foundation/PairKernelLattice3.lean:514 
/-- The dissipation energy of a discrete edge current: `E(θ) = ½ Σ_{ij} θ_ij²` (the `½` compensates
    the antisymmetric double count, so each undirected link is charged once). -/
def flowEnergy {n : ℕ} (θ : Fin n → Fin n → ℝ) : ℝ :=
  (1 / 2) * ∑ i : Fin n, ∑ j : Fin n, θ i j ^ 2

What this page does not claim

The module does not prove the full asymptotics of the Green's function; that remains open. The quadratic action is not derived from the forcing chain; it is a modeling premise. The dimension dichotomy is proved for the box carrier, not for the physical recognition-to-linking bridge.

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