mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
209 lines
7.5 KiB
Text
209 lines
7.5 KiB
Text
import Semantics.FAMM
|
|
import Semantics.HCMMR.Core
|
|
import Semantics.FixedPoint
|
|
|
|
open Semantics
|
|
open Semantics.FixedPoint (Q16_16)
|
|
|
|
namespace Semantics.MMRFAMMUnification
|
|
|
|
/-! # MMR-FAMM Unification
|
|
|
|
FAMM cells are MMR leaves — live, high-resolution delay lines.
|
|
Merge operations coarsen delay (losing temporal resolution but gaining
|
|
causal depth). `delayMass` is the MMR depth proxy.
|
|
|
|
## Energy Invariant (proof target)
|
|
|
|
merge preserves total causal cost:
|
|
a.delayMass + b.delayMass = merge(a,b).delayMass
|
|
|
|
This gives a formally verified garbage-collection-by-physics model:
|
|
old delay lines coarsen into higher MMR levels, thermal budget relieved
|
|
by merging.
|
|
-/
|
|
|
|
/-- MMR depth classifier mapped from delayMass. -/
|
|
inductive MMRDepth where
|
|
| leaf : MMRDepth
|
|
| midLevel : MMRDepth
|
|
| root : MMRDepth
|
|
deriving Repr, BEq, DecidableEq
|
|
|
|
/-- An MMR level wraps a contiguous FAMM bank with a depth tag. -/
|
|
structure MMRLevel where
|
|
depth : Nat
|
|
delayCapacity : Q16_16
|
|
cells : Array FAMMCell
|
|
deriving Repr, Inhabited
|
|
|
|
/-- Custom equality for MMRLevel: structural on depth/capacity, length-based on cells. -/
|
|
def mmrLevelEq (a b : MMRLevel) : Bool :=
|
|
a.depth = b.depth ∧ a.delayCapacity.val = b.delayCapacity.val ∧ a.cells.size = b.cells.size
|
|
|
|
/-- Classify an MMRLevel by its delay capacity relative to the base leaf capacity. -/
|
|
def classifyDepth (level : MMRLevel) (leafCapacity : Q16_16) : MMRDepth :=
|
|
if level.delayCapacity.val < (Q16_16.mul (Q16_16.ofInt 2) leafCapacity).val then
|
|
.leaf
|
|
else if level.delayCapacity.val < (Q16_16.mul (Q16_16.ofInt 8) leafCapacity).val then
|
|
.midLevel
|
|
else
|
|
.root
|
|
|
|
/-- Merge two FAMM cells into one coarsened cell.
|
|
Energy invariant: a.delayMass + b.delayMass = result.delayMass
|
|
-/
|
|
def fammCellMerge (a b : FAMMCell) : FAMMCell :=
|
|
{ data := a.data
|
|
, delay := if a.delay.val ≥ b.delay.val then a.delay else b.delay
|
|
, delayMass := Q16_16.add a.delayMass b.delayMass
|
|
, delayWeight := Q16_16.add a.delayWeight b.delayWeight
|
|
}
|
|
|
|
/-- Total causal cost of an MMR level (sum of delayMass of all cells). -/
|
|
def totalCausalCost (level : MMRLevel) : Q16_16 :=
|
|
level.cells.foldl (λ acc c => Q16_16.add acc c.delayMass) Q16_16.zero
|
|
|
|
/-- Merge two MMR levels pairwise using List.range (no recursion needed). -/
|
|
def mmrLevelMerge (a b : MMRLevel) : MMRLevel :=
|
|
let newDepth := max a.depth b.depth + 1
|
|
let newCapacity := if a.delayCapacity.val ≥ b.delayCapacity.val
|
|
then a.delayCapacity else b.delayCapacity
|
|
let mergeCount := min a.cells.size b.cells.size
|
|
let mergedCells : Array FAMMCell :=
|
|
(List.range mergeCount).foldl (λ (acc : Array FAMMCell) (i : Nat) =>
|
|
acc.push (fammCellMerge a.cells[i]! b.cells[i]!)) #[]
|
|
let residualCells := if a.cells.size > b.cells.size then
|
|
a.cells.extract mergeCount a.cells.size
|
|
else
|
|
b.cells.extract mergeCount b.cells.size
|
|
let coarsenedResiduals := residualCells.map (λ c =>
|
|
{ c with
|
|
delay := Q16_16.mul c.delay (Q16_16.ofInt 2)
|
|
, delayMass := Q16_16.mul c.delayMass (Q16_16.ofInt 2)
|
|
})
|
|
{ depth := newDepth
|
|
, delayCapacity := newCapacity
|
|
, cells := mergedCells ++ coarsenedResiduals
|
|
}
|
|
|
|
/-- Total causal cost of an array of MMR levels. -/
|
|
def totalSystemCost (levels : Array MMRLevel) : Q16_16 :=
|
|
levels.foldl (λ acc l => Q16_16.add acc (totalCausalCost l)) Q16_16.zero
|
|
|
|
/-- Promote a FAMMBank to an MMR leaf level. -/
|
|
def bankToLeaf (bank : FAMMBank) : MMRLevel :=
|
|
{ depth := 0
|
|
, delayCapacity := bank.maxDelay
|
|
, cells := bank.cells
|
|
}
|
|
|
|
/-- Check if an MMRLevel is in an array (structural equality by depth and size). -/
|
|
def mmrLevelInArray (l : MMRLevel) (arr : Array MMRLevel) : Bool :=
|
|
arr.any (λ x => x.depth = l.depth ∧ x.cells.size = l.cells.size)
|
|
|
|
/-- Merge over-budget levels pairwise using List.range. -/
|
|
def mmrThermalDefrag (levels : Array MMRLevel) (budget : Q16_16) (maxPasses : Nat) : Array MMRLevel :=
|
|
if maxPasses = 0 then levels
|
|
else
|
|
let overBudget := levels.filter (λ l => Q16_16.lt budget (totalCausalCost l))
|
|
if overBudget.isEmpty then levels
|
|
else
|
|
let n := overBudget.size
|
|
let merged : Array MMRLevel :=
|
|
(List.range (n / 2)).foldl (λ (acc : Array MMRLevel) (k : Nat) =>
|
|
let i := k * 2
|
|
acc.push (mmrLevelMerge overBudget[i]! overBudget[i+1]!)) #[]
|
|
let kept := levels.filter (λ l => !mmrLevelInArray l overBudget)
|
|
mmrThermalDefrag (kept ++ merged) budget (maxPasses - 1)
|
|
|
|
-- ════════════════════════════════════════════════════
|
|
-- Fixtures and #eval witnesses
|
|
-- ════════════════════════════════════════════════════
|
|
|
|
def leafCellA : FAMMCell :=
|
|
{ data := Q16_16.one
|
|
, delay := Q16_16.ofInt 1
|
|
, delayMass := Q16_16.ofInt 5
|
|
, delayWeight := Q16_16.one
|
|
}
|
|
|
|
def leafCellB : FAMMCell :=
|
|
{ data := Q16_16.ofInt 2
|
|
, delay := Q16_16.ofInt 3
|
|
, delayMass := Q16_16.ofInt 7
|
|
, delayWeight := Q16_16.one
|
|
}
|
|
|
|
def mergedCell : FAMMCell := fammCellMerge leafCellA leafCellB
|
|
|
|
#eval leafCellA
|
|
#eval leafCellB
|
|
#eval mergedCell
|
|
|
|
-- Verify the energy invariant numerically
|
|
#eval leafCellA.delayMass.val + leafCellB.delayMass.val
|
|
#eval mergedCell.delayMass.val
|
|
|
|
def leafLevel : MMRLevel :=
|
|
{ depth := 0
|
|
, delayCapacity := Q16_16.ofInt 10
|
|
, cells := #[leafCellA, leafCellB]
|
|
}
|
|
|
|
def midLevel : MMRLevel :=
|
|
{ depth := 1
|
|
, delayCapacity := Q16_16.ofInt 5
|
|
, cells := #[leafCellA, leafCellB]
|
|
}
|
|
|
|
def mergedLevel : MMRLevel := mmrLevelMerge leafLevel midLevel
|
|
|
|
#eval leafLevel.depth
|
|
#eval midLevel.depth
|
|
#eval mergedLevel.depth
|
|
|
|
-- Total cost witnesses
|
|
#eval totalCausalCost leafLevel
|
|
#eval totalCausalCost midLevel
|
|
#eval totalCausalCost mergedLevel
|
|
|
|
-- Classify depths
|
|
#eval classifyDepth leafLevel (Q16_16.ofInt 1)
|
|
#eval classifyDepth mergedLevel (Q16_16.ofInt 1)
|
|
|
|
-- Thermal defrag witnesses
|
|
def hotLevel : MMRLevel :=
|
|
{ depth := 2
|
|
, delayCapacity := Q16_16.ofInt 100
|
|
, cells := Array.replicate 8 { leafCellA with delayMass := Q16_16.ofInt 100 }
|
|
}
|
|
|
|
#eval totalCausalCost hotLevel
|
|
#eval Q16_16.lt (Q16_16.ofInt 200) (totalCausalCost hotLevel)
|
|
|
|
-- ════════════════════════════════════════════════════
|
|
-- Theorems (kept below #eval to avoid eval-abort from `sorry`)
|
|
-- ════════════════════════════════════════════════════
|
|
|
|
/-- Energy invariant: merging two cells preserves total delayMass.
|
|
Proof follows directly from the definition of fammCellMerge. -/
|
|
theorem famm_merge_preserves_cost (a b : FAMMCell) :
|
|
Q16_16.add a.delayMass b.delayMass = (fammCellMerge a b).delayMass := by
|
|
simp [fammCellMerge]
|
|
|
|
/-- Total causal cost is preserved by level merge for equal-size levels.
|
|
Computational witness for leafLevel and midLevel (both have 2 cells).
|
|
The general proof requires Array.foldl induction and Q16_16 sat-add
|
|
distributivity, which is blocked on lemmas not yet in Mathlib 4.30. -/
|
|
theorem total_causal_cost_invariant_test :
|
|
Q16_16.add (totalCausalCost leafLevel) (totalCausalCost midLevel) =
|
|
totalCausalCost (mmrLevelMerge leafLevel midLevel) := by
|
|
native_decide
|
|
|
|
/-- The merge operation never decreases the depth (monotonic). -/
|
|
theorem merge_depth_monotone (a b : MMRLevel) :
|
|
(mmrLevelMerge a b).depth ≥ max a.depth b.depth := by
|
|
simpa [mmrLevelMerge] using Nat.le_succ (max a.depth b.depth)
|
|
|
|
end Semantics.MMRFAMMUnification
|