mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
150 lines
8.6 KiB
Text
150 lines
8.6 KiB
Text
/-!
|
||
# Q0_64 Experimental — Ultra-Precision Dimensionless Scalars
|
||
|
||
**Status:** TEST BRANCH — Experimental, do not commit to main.
|
||
**Purpose:** Explore 64-bit pure fraction for dimensionless quantities
|
||
where Q0_16 (≈ 0.00003 resolution) is insufficient.
|
||
|
||
**Q0_16 resolution:** 1/32767 ≈ 3.05×10⁻⁵
|
||
**Q0_64 resolution:** 1/2⁶³ ≈ 1.08×10⁻¹⁹
|
||
|
||
**Trade-off:** Q0_64 is 4× larger than Q0_16 (8 bytes vs 2 bytes).
|
||
Per AGENTS.md §1.4 default: Q0_16. Q0_64 is for contexts where
|
||
confidence thresholds demand sub-ppm precision (e.g., 6.5σ tail events).
|
||
|
||
This file is standalone: zero imports.
|
||
-/
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §0 Q0_64 Structure
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/-- Q0.64 pure fraction: 64-bit unsigned interpreted as signed fixed-point.
|
||
Range: [-1.0, 1.0 - 2⁻⁶⁴] ≈ [-1.0, 0.99999999999999999989]
|
||
Resolution: 2⁻⁶³ ≈ 1.08 × 10⁻¹⁹
|
||
0x8000_0000_0000_0000 = 1.0 (max positive)
|
||
0x0000_0000_0000_0000 = 0.0 -/
|
||
structure Q0_64 where
|
||
val : UInt64
|
||
deriving Repr, BEq, Inhabited
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §1 Constants
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
def Q0_64.zero : Q0_64 := ⟨0x0000_0000_0000_0000⟩
|
||
def Q0_64.one : Q0_64 := ⟨0x8000_0000_0000_0000⟩ -- ~1.0
|
||
def Q0_64.half : Q0_64 := ⟨0x4000_0000_0000_0000⟩ -- 0.5
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §2 Basic Arithmetic
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
def Q0_64.neg (x : Q0_64) : Q0_64 := ⟨-x.val⟩
|
||
|
||
def Q0_64.add (a b : Q0_64) : Q0_64 := ⟨a.val + b.val⟩
|
||
|
||
def Q0_64.sub (a b : Q0_64) : Q0_64 := ⟨a.val - b.val⟩
|
||
|
||
/-- Multiplication: (a/2⁶³) × (b/2⁶³) × 2⁶³ = (a×b)/2⁶³.
|
||
Uses unbounded Nat intermediate to avoid 64-bit overflow. -/
|
||
def Q0_64.mul (a b : Q0_64) : Q0_64 :=
|
||
let prod : Nat := a.val.toNat * b.val.toNat
|
||
⟨(prod >>> 63).toUInt64⟩
|
||
|
||
/-- Division: a/b = (a × 2⁶³) / b. Saturate on div-by-zero. -/
|
||
def Q0_64.div (a b : Q0_64) : Q0_64 :=
|
||
if b.val = 0 then ⟨0x8000_0000_0000_0000⟩
|
||
else
|
||
let num : Nat := a.val.toNat <<< 63
|
||
⟨(num / b.val.toNat).toUInt64⟩
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §3 Precision Comparison (Q0_16 vs Q0_64)
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/-- Smallest representable positive value in Q0_16: 1/32767 ≈ 3.05×10⁻⁵ -/
|
||
def q0_16Epsilon : Nat := 1
|
||
-- Q0_16.val = 1 corresponds to ≈ 3.05×10⁻⁵ in float space
|
||
|
||
/-- Smallest representable positive value in Q0_64: 1/2⁶³ ≈ 1.08×10⁻¹⁹ -/
|
||
def q0_64Epsilon : Nat := 1
|
||
-- Q0_64.val = 1 corresponds to ≈ 1.08×10⁻¹⁹ in float space
|
||
|
||
/-- Ratio of precisions: Q0_64 is 2⁴⁸× finer than Q0_16.
|
||
2⁶³ / 2¹⁵ = 2⁴⁸ ≈ 2.8 × 10¹⁴ -/
|
||
def precisionRatio : Nat :=
|
||
let q16Max : Nat := 0x8000 -- 32768
|
||
let q64Max : Nat := 0x8000_0000_0000_0000 -- 2^63
|
||
q64Max / q16Max
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §4 6.5σ Tail Probability in Q0_64
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/-- Standard normal CDF at 6.5σ: Φ(6.5) ≈ 4.02 × 10⁻¹¹.
|
||
In Q0_16: this rounds to 0 (below epsilon).
|
||
In Q0_64: representable as val ≈ 346 (6.5σ in Q0_64 units, approximate). -/
|
||
def sigma65TailProbabilityQ0_16Representable : Bool := false
|
||
-- 4.02×10⁻¹¹ << Q0_16 epsilon (3.05×10⁻⁵). Rounds to zero.
|
||
|
||
def sigma65TailProbabilityQ0_64Representable : Bool := true
|
||
-- 4.02×10⁻¹¹ >> Q0_64 epsilon (1.08×10⁻¹⁹). Easily representable.
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §5 Witness Values
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
#eval Q0_64.zero -- { val := 0 }
|
||
#eval Q0_64.one -- { val := 9223372036854775808 }
|
||
#eval Q0_64.half -- { val := 4611686018427387904 }
|
||
|
||
#eval Q0_64.add Q0_64.half Q0_64.half -- { val := 9223372036854775808 } = one
|
||
#eval Q0_64.sub Q0_64.one Q0_64.half -- { val := 4611686018427387904 } = half
|
||
#eval Q0_64.mul Q0_64.half Q0_64.half -- 0.25: { val := 2305843009213693952 }
|
||
#eval Q0_64.div Q0_64.one Q0_64.half -- 2.0: { val := 0 } -- wraps (2.0 exceeds [-1,1) range)
|
||
|
||
#eval precisionRatio -- 281474976710656 (2^48)
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §6 Size Impact on Neural Compression (Back-of-Envelope)
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/-- Q0_16 neural state: 1 PB = 10¹⁵ bytes.
|
||
Q0_64 neural state: 4 PB = 4×10¹⁵ bytes (4× larger). -/
|
||
def q0_16StateBytes : Nat := 1000000000000000
|
||
def q0_64StateBytes : Nat := q0_16StateBytes * 4
|
||
|
||
/-- At 1,250× compression:
|
||
Q0_16 compressed: 800 GB
|
||
Q0_64 compressed: 3,200 GB (exceeds 800 GB target) -/
|
||
def q0_16CompressedGb : Nat := q0_16StateBytes / 1250 / 1000000000
|
||
def q0_64CompressedGb : Nat := q0_64StateBytes / 1250 / 1000000000
|
||
|
||
/-- To hit 800 GB with Q0_64 raw state, compression ratio must be:
|
||
C = 4×10¹⁵ / 8×10¹¹ = 5,000× -/
|
||
def requiredRatioForQ0_64 : Nat := q0_64StateBytes / 800000000000
|
||
|
||
#eval q0_16CompressedGb -- 800
|
||
#eval q0_64CompressedGb -- 3200 (fails 800 GB target)
|
||
#eval requiredRatioForQ0_64 -- 5000 (need 4× higher compression)
|
||
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
-- §7 Verdict
|
||
-- ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/-- Q0_64 buys 2^48× precision at a 4× size cost.
|
||
For 6.5σ tail probabilities (4×10⁻¹¹), Q0_16 rounds to zero.
|
||
Q0_64 captures it with ~37 bits of headroom.
|
||
|
||
Trade-off: if the neural state is stored as Q0_64, the compression
|
||
pipeline must achieve 5,000× instead of 1,250× to hit the same
|
||
storage target. This is feasible with deeper quantization-aware
|
||
training but must be proven in the pipeline. -/
|
||
def testBranchVerdict : String :=
|
||
"Q0_64: 2^48 precision gain, 4x size cost. " ++
|
||
"6.5σ tails representable. " ++
|
||
"Compression target increases 1,250x -> 5,000x. " ++
|
||
"Test branch only — do not merge without pipeline proof."
|
||
|
||
#eval testBranchVerdict
|