Encyclopedia Gravity Gravity Analysis Regge Ttbloch Assembly Raw Cell Stencil Eq Raw Cosine Bloch Fol

ARTICLE 2 claims 2 theorems

Gravity Analysis Regge Ttbloch Assembly Raw Cell Stencil Eq Raw Cosine Bloch Fol

A machine-checked theorem shows that a complex gravitational cell sum equals a simpler cosine-based fold, under one precise condition.

Verify this page

The finite-cell assembly theorem

The theorem rawCellStencil_eq_rawCosineBlochFold is a formal statement in the framework's machine-checked library of formal theorems. It concerns a finite-cell assembly stage in a gravity analysis, where a three-dimensional grid of cells is used to approximate a continuous problem. The theorem establishes that two different ways of computing a certain quantity produce the same result.

The first way is the raw cell stencil, a discrete record of weighted contributions from neighboring cells. The second way is the raw cosine Bloch fold, a sum over cosine values weighted by bucket amplitudes. The theorem proves these are equal for every side length and integer wave vector, provided the doubled frequency is non-aliased in at least one coordinate. This condition means the wave is sampled finely enough to avoid ambiguity.

The proof relies on a phase decomposition that handles periodic wrapping explicitly. It shows that the cosine of an edge midpoint phase equals the cosine of a cell-relative phase plus a slot phase, up to an integer multiple of 2π. Since cosine is periodic, the wrapping terms cancel. The result is that the raw cell stencil, which is expensive to compute directly, can be replaced by the simpler cosine fold without changing the value.

In Recognition Science, this theorem is part of a chain that forces physical structure from recognition costs. The framework models the universe as maintaining a ledger of recognition events, where the cost of recognition is forced by five plain conditions. This particular theorem is a technical step in that program, showing that a finite approximation scheme is consistent with a more elegant cosine representation.

The theorem does not claim that the raw cell stencil equals the cosine fold for all wave vectors. It requires the non-aliasing condition. It also does not claim that the cosine fold is the true physical value; it only establishes an equality between two computational definitions. The theorem says nothing about the continuum limit or about the physical interpretation of the quantities involved.

THEOREM rawCellStencil_eq_rawCosineBlochFold · IndisputableMonolith/Gravity/Analysis/ReggeTTBlochAssembly.lean
rawCellStencil_eq_rawCosineBlochFold · IndisputableMonolith/Gravity/Analysis/ReggeTTBlochAssembly.lean:298 
/-- FINITE ASSEMBLY HEADLINE: under exact doubled-frequency non-aliasing,
the Schlaefli-reduced raw stencil equals the raw bucket cosine fold. -/
theorem rawCellStencil_eq_rawCosineBlochFold (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (halias : ∃ i : Fin 3, ¬ (N : ℤ) ∣ 2 * m i) :
    rawCellStencil N E m =
      reggeTTBlochFold rawCosineSupport (rawCosineEvaluator N m)
        (rawBucketAmplitude E) := by
  unfold rawCellStencil
  have hregroup :
      -(∑ τ : PeriodicTet N N N, ∑ f : Fin 6, ∑ g : Fin 6,
          rawCellStencilTerm N E m τ f g) =
        ∑ p : Fin 6 × Fin 6 × Fin 6, ∑ cell : Vertex N N N,
          rawTripleWeight E p *
            Real.cos (BlochCellSum.theta N m cell + slotPhase N m p.1 p.2.1) *
            Real.cos (BlochCellSum.theta N m cell + slotPhase N m p.1 p.2.2) := by
    calc
      -(∑ τ : PeriodicTet N N N, ∑ f : Fin 6, ∑ g : Fin 6,
          rawCellStencilTerm N E m τ f g)
          = ∑ cell : Vertex N N N, ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6,
              -rawCellStencilTerm N E m (cell, t) f g := by
            rw [Fintype.sum_prod_type, ← Finset.sum_neg_distrib]
            refine Finset.sum_congr rfl fun cell _ => ?_
            rw [← Finset.sum_neg_distrib]
            refine Finset.sum_congr rfl fun t _ => ?_
            rw [← Finset.sum_neg_distrib]
            refine Finset.sum_congr rfl fun f _ => ?_
            rw [← Finset.sum_neg_distrib]
      _ = ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6, ∑ cell : Vertex N N N,
              -rawCellStencilTerm N E m (cell, t) f g := by
            rw [Finset.sum_comm]
            refine Finset.sum_congr rfl fun t _ => ?_
            rw [Finset.sum_comm]
            refine Finset.sum_congr rfl fun f _ => ?_
            rw [Finset.sum_comm]
      _ = ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6, ∑ cell : Vertex N N N,
              rawTripleWeight E (t, f, g) *
                Real.cos (BlochCellSum.theta N m cell + slotPhase N m t f) *
                Real.cos
                  (BlochCellSum.theta N m cell + slotPhase N m t g) := by
            refine Finset.sum_congr rfl fun t _ => ?_
            refine Finset.sum_congr rfl fun f _ => ?_
            refine Finset.sum_congr rfl fun g _ => ?_
            exact Finset.sum_congr rfl fun cell _ =>
              neg_rawCellStencilTerm_eq N E m cell t f g
      _ = ∑ p : Fin 6 × Fin 6 × Fin 6, ∑ cell : Vertex N N N,
              rawTripleWeight E p *
                Real.cos
                  (BlochCellSum.theta N m cell + slotPhase N m p.1 p.2.1) *
                Real.cos
                  (BlochCellSum.theta N m cell + slotPhase N m p.1 p.2.2) := by
            rw [Fintype.sum_prod_type]
            refine Finset.sum_congr rfl fun t _ => ?_
            rw [Fintype.sum_prod_type]
  rw [hregroup]
  rw [Finset.sum_congr rfl fun p _ => rawTriple_cellSum N E m p halias]
  have hNcast : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (NeZero.ne N)
  have hN : (N : ℝ) ^ (3 : ℕ) ≠ 0 := by
    positivity
  have hcancel :
      (2 / (N : ℝ) ^ (3 : ℕ)) * ((N : ℝ) ^ (3 : ℕ) / 2) = 1 := by
    field_simp [hNcast]
  calc
    (2 / (N : ℝ) ^ (3 : ℕ)) *
        ∑ p : Fin 6 × Fin 6 × Fin 6,
          rawTripleWeight E p * ((N : ℝ) ^ 3 / 2) *
            rawCosineEvaluator N m (bucketKeyOf p)
        = ∑ p : Fin 6 × Fin 6 × Fin 6,
            rawCosineEvaluator N m (bucketKeyOf p) * rawTripleWeight E p := by
          rw [Finset.mul_sum]
          refine Finset.sum_congr rfl fun p _ => ?_
          calc
            (2 / (N : ℝ) ^ (3 : ℕ)) *
                (rawTripleWeight E p * ((N : ℝ) ^ 3 / 2) *
                  rawCosineEvaluator N m (bucketKeyOf p))
                = ((2 / (N : ℝ) ^ (3 : ℕ)) *
                    ((N : ℝ) ^ (3 : ℕ) / 2)) *
                    (rawTripleWeight E p *
                      rawCosineEvaluator N m (bucketKeyOf p)) := by ring
            _ = rawCosineEvaluator N m (bucketKeyOf p) *
                  rawTripleWeight E p := by
                  rw [hcancel, one_mul]
                  ring
    _ = reggeTTBlochFold rawCosineSupport (rawCosineEvaluator N m)
          (rawBucketAmplitude E) :=
      (rawCosineFold_eq_rawTripleSum N E m).symm
THEOREM localEdge_phase_decomposition · IndisputableMonolith/Gravity/Analysis/ReggeTTBlochAssembly.lean
localEdge_phase_decomposition · IndisputableMonolith/Gravity/Analysis/ReggeTTBlochAssembly.lean:158 
/-- Exact phase decomposition for every cell, including periodic seams.
The wrapped representative differs from the unwrapped cell-relative phase
by an integral number of full turns. -/
theorem localEdge_phase_decomposition (N : ℕ) [NeZero N]
    (m : Fin 3 → ℤ) (cell : Vertex N N N) (t f : Fin 6) :
    edgeMidpointPhase N (commensurateMomentum N m) (localEdgeOf cell t f) =
      BlochCellSum.theta N m cell + slotPhase N m t f -
        2 * Real.pi * (slotWrapTurns N m cell t f : ℝ) := by
  have hwrap :
      (slotWrapTurns N m cell t f : ℝ) =
        ∑ i : Fin 3, (m i : ℝ) * (slotWrapCount N cell t f i : ℝ) := by
    unfold slotWrapTurns
    rw [Int.cast_sum]
    refine Finset.sum_congr rfl fun i _ => ?_
    norm_cast
  unfold edgeMidpointPhase slotPhase
  simp only [Fin.sum_univ_three]
  rw [show (localEdgeOf cell t f).base =
      addVertexBits cell
        (cubeEdgeBase
          (Geometry.FreudenthalCubeTriangulation.localEdgeOf t f)) from rfl]
  rw [vertCoord_addVertexBits N cell _ 0,
    vertCoord_addVertexBits N cell _ 1,
    vertCoord_addVertexBits N cell _ 2]
  rw [slotMidTwice_eq_geometry N cell t f 0,
    slotMidTwice_eq_geometry N cell t f 1,
    slotMidTwice_eq_geometry N cell t f 2]
  rw [hwrap]
  unfold BlochCellSum.theta commensurateMomentum slotWrapCount
  simp only [Fin.sum_univ_three]
  unfold slotBaseBit vertexNatCoord
  push_cast
  have hN : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (NeZero.ne N)
  field_simp [hN]
  ring

What this page does not claim

The theorem does not claim equality for aliased wave vectors. The theorem does not establish any physical meaning for the quantities it equates. The theorem does not address the continuum limit or the convergence of the finite scheme.

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/Gravity/Analysis/ReggeTTBlochAssembly.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