Cosmology Polarized Birth Interface Count Interface Length Eq

The exact interface count

In a discrete lattice model, a recognition event (a forced distinction between neighboring cells) happens only across an interface. The declaration interface_length_eq proves, in the framework's machine-checked library of formal theorems, that this interface has an exact size at every step. For the two-dimensional diamond lattice of radius t, the number of ordered boundary edges is 8t - 4. The proof counts each adjacency twice, once per direction, so the undirected perimeter is half that, 4t - 2.

The count is not merely a bound; it is an equality. The theorem states that the length of the filtered edge list equals 8t - 4 exactly, for every t at least 1. The proof works by establishing a bijection between each boundary edge and a triple: a spine coordinate y, a side choice, and an orientation. Every bichromatic edge has exactly one endpoint on the central spine and one neighbor to its left or right, so the edge is fully described by that triple. This bijection is the heart of the exact count.

The immediate consequence is a constant growth rate. The interface_increment_const theorem shows that increasing the radius from t to t + 1 adds exactly 8 new ordered edges, regardless of how large the world has become. The interface grows by a fixed amount per cycle, while the total number of cells grows as the square of the radius. In the framework's ledger, cost scales with recognition activity, not with volume; this constant increment is the literal statement of that principle in two dimensions.

The same count lifts to three dimensions, the dimension the forcing chain selects. There the interface is a two-dimensional surface, and the exact ordered count is 8t² - 8t + 4, proved in the Octahedron namespace. The per-cycle increment is then 16t, which grows linearly with the radius. This is the honest three-dimensional statement: recognition activity per cycle is Θ(t), sub-extensive against the Θ(t³) volume, but not constant. The total net distinctions over a full run from radius 1 to T is 8T(T - 1) in three dimensions, again strictly sub-extensive against the brute-force spacetime cost of Θ(T⁴).

What the declaration does not claim is equally precise. It does not assert that the interface count is the same in every dimension; the two-dimensional constant increment is a special case, not a general law. It does not claim that the physical universe is this lattice; the model is a definitional choice, not a proven cosmology. And it does not claim that cost is conserved, only that it tracks this counted activity. The exactness is real, but it is exactness about a model's internal structure.

/-- **The concrete interface edge-list length is `8t - 4`.** Bridging the exact `Finset` count
`interface_card_eq` through `interface_length_eq_card`, the actual bichromatic edge list the engine
filters out of `edges t` has length exactly `8t - 4`. This is the form the numeric layer sees. -/
theorem interface_length_eq (t : ℕ) (ht : 1 ≤ t) :
    ((edges t).filter (fun p => decide (polarized t p.1 ≠ polarized t p.2))).length = 8 * t - 4 := by
  rw [interface_length_eq_card, interface_card_eq t ht]

/-- **Constant per-cycle recognition activity (the compute-watch law, in Lean).** Advancing the
diamond birth field by one cadence cycle (`t → t + 1`) adds exactly `8` ordered interface edges,
*independent of `t`* and hence independent of the world volume (which grows as `Θ(t²)`). The forced
distinctions the engine must post per cycle are `O(1)`, so the simulation's cost scales with
recognition activity, never with volume. -/
theorem interface_increment_const (t : ℕ) (ht : 1 ≤ t) :
    (B (t + 1)).card - (B t).card = 8 := by
  rw [interface_card_eq (t + 1) (by omega), interface_card_eq t ht]
  omega

/-- **The concrete interface edge-list length is `8t - 4`.** Bridging the exact `Finset` count
`interface_card_eq` through `interface_length_eq_card`, the actual bichromatic edge list the engine
filters out of `edges t` has length exactly `8t - 4`. This is the form the numeric layer sees. -/
theorem interface_length_eq (t : ℕ) (ht : 1 ≤ t) :
    ((edges t).filter (fun p => decide (polarized t p.1 ≠ polarized t p.2))).length = 8 * t - 4 := by
  rw [interface_length_eq_card, interface_card_eq t ht]

/-- **Linear per-cycle recognition activity (3-D).** Advancing the octahedron birth field by one
cadence cycle (`t → t + 1`) adds exactly `16t` ordered interface edges. Unlike the 2-D case (where the
increment is the constant `8`), in three dimensions the forced recognition activity per cycle grows
`Θ(t)`: the interface is a 2-D surface whose area grows linearly per shell. This is the honest 3-D
form of the compute-watch law: cost per cycle still tracks recognition activity, but in D = 3 that
activity is `Θ(t)`, not `O(1)`, because the recognition-active interface is a growing codim-1 disk. -/
theorem interface_increment_linear (t : ℕ) (ht : 1 ≤ t) :
    (B (t + 1)).card - (B t).card = 16 * t := by
  rw [interface_card_eq (t + 1) (by omega), interface_card_eq t ht]
  have e : (t + 1) ^ 2 = t ^ 2 + 2 * t + 1 := by ring
  have hsq : t ≤ t ^ 2 := by nlinarith [ht]
  rw [e]
  omega

/-- **Total interface growth over a forward run (2-D).** The net number of interface edges the
polarized birth introduces over a full run from radius `1` to radius `T` is exactly `8T - 8 = 8(T-1)`,
the difference of the start and end interface sizes. This is `Θ(T)`, sub-extensive against the
brute-force spacetime cost `Θ(T³)` (volume `Θ(T²)` times `T` cycles): the compute-watch total. -/
theorem interface_total_growth (T : ℕ) (hT : 1 ≤ T) :
    (B T).card - (B 1).card = 8 * T - 8 := by
  rw [interface_card_eq T hT, interface_card_eq 1 (le_refl 1)]
  omega

What this page does not claim

The interface count is not claimed to be identical across dimensions; the constant increment is a two-dimensional special case. The lattice model is not claimed to be a literal description of physical spacetime. The declaration does not claim that recognition cost is conserved, only that it tracks the counted interface activity.

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/PolarizedBirthInterfaceCount.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: