Encyclopedia Cosmology Cosmology Lattice Ball Edges Interface Cube Le Total Sq

ARTICLE 4 claims 4 theorems

Cosmology Lattice Ball Edges Interface Cube Le Total Sq

In a growing three-dimensional lattice, the number of boundary edges never outgrows the total edge count raised to the two-thirds power, a bound that keeps the surface cheap relative to the bulk.

Verify this page

The interface bound

A cube-shaped cluster of points on a three-dimensional grid, grown to a radius t. The cluster has two kinds of neighboring pairs, or edges: internal edges that connect two points both inside the cluster, and interface edges that cross from an inside point to an outside one. The declaration interface_cube_le_total_sq states a size relationship between these two counts: the number of interface edges, cubed, is at most eight times the number of total edges, squared. In symbols, if B is the interface count and E the total count, then B³ ≤ 8E².

This is not a vague tendency but an exact theorem, proved in the framework's machine-checked library of formal theorems. The proof works by counting edges directly. For a fixed direction, say the positive x direction, the edges leaving the ball form a boundary layer one cell thick. In three dimensions that layer has 2t² + 2t + 1 cells, a count that follows from the area law for the transverse diamond. Summing over all six directions and subtracting the boundary from the bulk gives the total edge count 8t³ + 4t. The interface count, which the framework calls the forced-distinction edges, comes to 8t² - 8t + 4. Substituting these closed forms into the inequality B³ ≤ 8E² reduces it to an algebraic identity that holds for every t ≥ 1.

The inequality matters because it sharpens the coarsening picture. The framework models a ledger, a discrete record of events, where the engine pays only for the interface edges and carries the internal ones for free. The theorem shows that the paid fraction, interface over total, shrinks as the cluster grows: it is proportional to 1/t, vanishing as t increases. The carried fraction approaches 1, meaning almost every adjacency is free. The cube-versus-square bound is the exact statement that the expensive surface never dominates the cheap bulk.

What the declaration does not claim is just as important. It does not say anything about two dimensions, where the analogous bound is B² ≤ 8E, a separate theorem. It does not assert that the interface count is small in absolute terms, only that it is bounded relative to the total. And it does not derive the physical claim that space has three dimensions; that conclusion comes from a different part of the framework, and the bridge from recognition to physical linking remains open.

THEOREM interface_cube_le_total_sq · IndisputableMonolith/Cosmology/LatticeBallEdges.lean
interface_cube_le_total_sq · IndisputableMonolith/Cosmology/LatticeBallEdges.lean:577 
/-- **Discrete isoperimetric / surface law (3-D).** The forced interface satisfies
`(interface)³ ≤ 8 · (total adjacency)²`, the codimension-1 scaling in three dimensions: the interface
is `Θ(t²)` while the total adjacency is `Θ(t³)`, so the interface grows only as the `2/3` power of the
bulk. It is a surface, not a volume. THEOREM over `ℕ`. -/
theorem interface_cube_le_total_sq (t : ℕ) (ht : 1 ≤ t) :
    (B t).card ^ 3 ≤ 8 * (E t).card ^ 2 := by
  rw [PolarizedBirthInterface.Octahedron.interface_card_eq t ht, total_edge_card t]
  obtain ⟨n, rfl⟩ : ∃ n, t = n + 1 := ⟨t - 1, by omega⟩
  have hL : 8 * (n + 1) ^ 2 - 8 * (n + 1) + 4 = 8 * n ^ 2 + 8 * n + 4 := by
    have e1 : 8 * (n + 1) ^ 2 = 8 * n ^ 2 + 16 * n + 8 := by ring
    omega
  rw [hL]
  have hB : 8 * n ^ 2 + 8 * n + 4 ≤ 8 * (n + 1) ^ 2 := by nlinarith [Nat.zero_le n]
  have hE : 8 * (n + 1) ^ 3 ≤ 8 * (n + 1) ^ 3 + 4 * (n + 1) := Nat.le_add_right _ _
  calc (8 * n ^ 2 + 8 * n + 4) ^ 3
      ≤ (8 * (n + 1) ^ 2) ^ 3 := Nat.pow_le_pow_left hB 3
    _ = 8 * (8 * (n + 1) ^ 3) ^ 2 := by ring
    _ ≤ 8 * (8 * (n + 1) ^ 3 + 4 * (n + 1)) ^ 2 :=
        Nat.mul_le_mul_left 8 (Nat.pow_le_pow_left hE 2)
THEOREM total_edge_card · IndisputableMonolith/Cosmology/LatticeBallEdges.lean
total_edge_card · IndisputableMonolith/Cosmology/LatticeBallEdges.lean:179 
/-- **The 2-D total adjacency law.** The diamond `|x| + |y| ≤ t` has exactly `8t²` ordered
4-neighbour adjacencies (each undirected edge counted in both orientations). THEOREM over `ℕ`. The
ordered edges biject onto `(cell, direction)` steps that stay in the ball. -/
theorem total_edge_card (t : ℕ) : (E t).card = 8 * t ^ 2 := by
  rw [← Dset_card t]
  refine Finset.card_bij'
    (fun p _ => (p.1.val, (p.2.val.1 - p.1.val.1, p.2.val.2 - p.1.val.2)))
    (fun cd hcd => (⟨cd.1, ?_⟩, ⟨(cd.1.1 + cd.2.1, cd.1.2 + cd.2.2), ?_⟩)) ?_ ?_ ?_ ?_
  · -- cd.1 ∈ ball (for the inverse's first vertex)
    simp only [Dset, Finset.mem_filter, Finset.mem_product] at hcd
    exact hcd.1.1
  · -- cd.1 + cd.2 ∈ ball (for the inverse's second vertex)
    simp only [Dset, Finset.mem_filter, Finset.mem_product] at hcd
    exact hcd.2
  · -- hi : forward maps E into Dset
    rintro ⟨a, b⟩ hp
    simp only [E, Finset.mem_filter, Finset.mem_univ, true_and] at hp
    simp only [Dset, Finset.mem_filter, Finset.mem_product]
    refine ⟨⟨a.property, ?_⟩, ?_⟩
    · -- the difference is a unit direction
      unfold adj at hp
      simp only [dirs, Finset.mem_insert, Finset.mem_singleton, Prod.mk.injEq]
      omega
    · -- stepping by the difference lands on b ∈ ball
      have hb : (a.val.1 + (b.val.1 - a.val.1), a.val.2 + (b.val.2 - a.val.2)) = b.val := by
        rw [Prod.ext_iff]; refine ⟨?_, ?_⟩ <;> · dsimp only; ring
      rw [hb]; exact b.property
  · -- hj : inverse maps Dset into E
    rintro ⟨c, d⟩ hcd
    simp only [Dset, Finset.mem_filter, Finset.mem_product] at hcd
    simp only [E, Finset.mem_filter, Finset.mem_univ, true_and]
    unfold adj
    have hdir : d ∈ dirs := hcd.1.2
    simp only [dirs, Finset.mem_insert, Finset.mem_singleton] at hdir
    rcases hdir with rfl | rfl | rfl | rfl <;> · dsimp only; omega
  · -- left inverse
    rintro ⟨a, b⟩ hp
    dsimp only
    rw [Prod.ext_iff]
    refine ⟨?_, ?_⟩
    · apply Subtype.ext; rfl
    · apply Subtype.ext
      rw [Prod.ext_iff]
      refine ⟨?_, ?_⟩ <;> · dsimp only; ring
  · -- right inverse
    rintro ⟨c, d⟩ hcd
    dsimp only
    rw [Prod.ext_iff]
    refine ⟨rfl, ?_⟩
    rw [Prod.ext_iff]
    refine ⟨?_, ?_⟩ <;> · dsimp only; ring
THEOREM carried_edge_card · IndisputableMonolith/Cosmology/LatticeBallEdges.lean
carried_edge_card · IndisputableMonolith/Cosmology/LatticeBallEdges.lean:244 
/-- **The exact carried (monochromatic) edge count.** Every adjacency is either a forced bichromatic
interface edge (`B`, counted as `8t - 4`) or a carried monochromatic edge. Since the total is `8t²`,
the carried edges number exactly `8t² - (8t - 4) = 8t² - 8t + 4`: the bulk the engine carries for
free, complementing the `8t - 4` it must post. THEOREM over `ℕ` (`t ≥ 1`). -/
theorem carried_edge_card (t : ℕ) (ht : 1 ≤ t) :
    (carried t).card = 8 * t ^ 2 - 8 * t + 4 := by
  have hsplit := Finset.filter_card_add_filter_neg_card_eq_card
    (s := E t) (p := fun p : Vtx t × Vtx t => polarized t p.1 ≠ polarized t p.2)
  have hBeq : (E t).filter (fun p => polarized t p.1 ≠ polarized t p.2) = B t := by
    rw [E, B, Finset.filter_filter]
  have hMeq : (E t).filter (fun p => ¬ (polarized t p.1 ≠ polarized t p.2)) = carried t := by
    rw [carried]
    apply Finset.filter_congr
    intro p _
    simp
  rw [hBeq, hMeq] at hsplit
  have hB : (B t).card = 8 * t - 4 := PolarizedBirthInterface.Diamond.interface_card_eq t ht
  have hE : (E t).card = 8 * t ^ 2 := total_edge_card t
  rw [hB, hE] at hsplit
  have hge : 8 * t ≤ 8 * t ^ 2 := by nlinarith [ht]
  omega
THEOREM carried_ge_interface · IndisputableMonolith/Cosmology/LatticeBallEdges.lean
carried_ge_interface · IndisputableMonolith/Cosmology/LatticeBallEdges.lean:278 
/-- **Carried dominates interface.** For a world of radius `t ≥ 1`, the engine carries at least as
many edges coarse as it posts (`8t² - 8t + 4 ≥ 8t - 4`, with equality only at `t = 1`): the carried
bulk overtakes the interface as soon as the world is larger than a single shell. -/
theorem carried_ge_interface (t : ℕ) (ht : 1 ≤ t) :
    (B t).card ≤ (carried t).card := by
  rw [PolarizedBirthInterface.Diamond.interface_card_eq t ht, carried_edge_card t ht]
  obtain ⟨n, rfl⟩ : ∃ n, t = n + 1 := ⟨t - 1, by omega⟩
  have hsq : (n + 1) ^ 2 = n ^ 2 + 2 * n + 1 := by ring
  rw [hsq]
  omega

What this page does not claim

The declaration does not apply to two dimensions, which has its own separate bound. It does not assert the interface count is small in absolute terms, only relative to the total. It does not derive the physical claim that space has three dimensions.

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/Cosmology/LatticeBallEdges.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