Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/FieldParameters/Contractions.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 16.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/FieldParameters/Contractions.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/FieldParameters/Contractions.lean
-
curl -L -o Contractions.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/FieldParameters/Contractions.lean
16.1 kB
| import OAI.LinearAlgebra.MatrixMultiplication.FieldParameters.Basic | |
| import OAI.LinearAlgebra.MatrixMultiplication.Numerical.AllFieldCertificatesReplay | |
| import Std.Data.TreeMap.Basic | |
| namespace OAI | |
| /-! Fixed rational distributions and their entropy and capacity formulas. -/ | |
| namespace MatrixMultiplication.AllFieldParameters.Contractions | |
| open MatrixMultiplication.AllFieldCertificates.Replay | |
| abbrev Ref := Nat | |
| abbrev Law (Ξ± : Type) := List (Ξ± Γ Ref) | |
| variable {Ξ± : Type} | |
| structure BuildState where | |
| reversed : List Op := [] | |
| count : Nat := 0 | |
| memo : Std.TreeMap (Nat Γ Int Γ Nat) Nat | |
| (cmp := (@lexOrd Nat (Int Γ Nat) inferInstance lexOrd).compare) := {} | |
| def BuildState.program (s : BuildState) : Program := s.reversed.reverse.toArray | |
| def opKey : Op β Nat Γ Int Γ Nat | |
| | .constant q => (0,q.num,q.den) | |
| | .add i j => (1,i,j) | |
| | .neg i => (2,i,0) | |
| | .mul i j => (3,i,j) | |
| | .inv i => (4,i,0) | |
| | .log i => (5,i,0) | |
| abbrev Build := StateM BuildState | |
| def emit (op : Op) : Build Ref := do | |
| let s β get | |
| match s.memo[opKey op]? with | |
| | some i => pure i | |
| | none => | |
| let i := s.count | |
| set ({ | |
| reversed := op :: s.reversed | |
| count := i + 1 | |
| memo := s.memo.insert (opKey op) i } : BuildState) | |
| pure i | |
| def lit (q : β) : Build Ref := emit (.constant q) | |
| def add (a b : Ref) : Build Ref := | |
| if a = 0 then pure b else if b = 0 then pure a else emit (.add a b) | |
| def neg (a : Ref) : Build Ref := if a = 0 then pure a else emit (.neg a) | |
| def sub (a b : Ref) : Build Ref := do add a (β neg b) | |
| def mul (a b : Ref) : Build Ref := | |
| if a = 0 then pure a else if b = 0 then pure b else | |
| if a = 1 then pure b else if b = 1 then pure a else emit (.mul a b) | |
| def inv (a : Ref) : Build Ref := if a = 1 then pure a else emit (.inv a) | |
| def divide (a b : Ref) : Build Ref := do mul a (β inv b) | |
| def log (a : Ref) : Build Ref := | |
| if a = 0 β¨ a = 1 then pure 0 else emit (.log a) | |
| def powerAux (a : Ref) : Nat β Nat β Build Ref | |
| | 0, _ => pure 1 | |
| | fuel + 1, n => | |
| if n = 0 then pure 1 else if n = 1 then pure a else do | |
| let h β powerAux a fuel (n / 2) | |
| let s β mul h h | |
| if n % 2 = 1 then mul s a else pure s | |
| def power (a : Ref) (n : Nat) : Build Ref := powerAux a n n | |
| def sumRefs (xs : List Ref) : Build Ref := xs.foldlM add 0 | |
| def getLaw [BEq Ξ±] (xs : Law Ξ±) (key : Ξ±) : Ref := | |
| ((xs.find? (fun x => x.1 == key)).map Prod.snd).getD 0 | |
| def addMass [BEq Ξ±] (xs : Law Ξ±) (key : Ξ±) (mass : Ref) : Build (Law Ξ±) := do | |
| match xs with | |
| | [] => pure [(key, mass)] | |
| | (k, v) :: rest => | |
| if k == key then pure ((k, β add v mass) :: rest) | |
| else pure ((k, v) :: (β addMass rest key mass)) | |
| def normalize (xs : Law Ξ±) : Build (Law Ξ±) := do | |
| let total β sumRefs (xs.map Prod.snd) | |
| xs.mapM fun (key, mass) => do pure (key, β divide mass total) | |
| def entropy (xs : List Ref) : Build Ref := do | |
| let xs := xs.filter (Β· != 0) | |
| let total β sumRefs xs | |
| sub (β mul total (β log total)) | |
| (β sumRefs (β xs.mapM fun x => do mul x (β log x))) | |
| def buildWeight (n : β€) : Build Ref := do | |
| let y β divide (β lit n) (β lit 640000) | |
| let terms β (List.range 17).mapM fun j => do | |
| divide (β power y j) (β lit (Nat.factorial j)) | |
| power (β sumRefs terms) 64 | |
| def insertInteger (n : β€) : List β€ β List β€ | |
| | [] => [n] | |
| | m :: ms => if n β€ m then n :: m :: ms else m :: insertInteger n ms | |
| def sortIntegers : List β€ β List β€ | |
| | [] => [] | |
| | n :: ns => insertInteger n (sortIntegers ns) | |
| def weightArguments : List β€ := | |
| (sortIntegers (0 :: (tablea ++ tableP ++ tablep ++ tablez))).eraseDups | |
| def buildWeights : Build (Law β€) := | |
| weightArguments.mapM fun n => do pure (n, β buildWeight n) | |
| def initialMultiplicity (g : Shape) : Nat := | |
| if g 0 = g 2 then 1 else if g 0 = g 1 β¨ g 1 = g 2 then 3 else 6 | |
| def buildInitial (weights : Law β€) : Build (Law Shape) := do | |
| let unnormalized β sortedInitial.mapM fun g => do | |
| let a := getLaw weights (tablea[g 0]?.getD 0) | |
| let b := getLaw weights (tablea[g 1]?.getD 0) | |
| let c := getLaw weights (tablea[g 2]?.getD 0) | |
| let x β mul a (β lit (initialMultiplicity g)) | |
| pure (g, β mul (β mul x b) c) | |
| normalize unnormalized | |
| def buildSplit (weights : Law β€) (parents : List Shape) (data : List β€) : | |
| Build (List (Shape Γ Law Shape)) := | |
| parents.mapM fun s => do | |
| let unnormalized β (below s).mapM fun u => do | |
| let signature := splitSignature parents data s u | |
| let x β mul (getLaw weights (signature 0)) (getLaw weights (signature 1)) | |
| pure (u, β mul x (getLaw weights (signature 2))) | |
| pure (s, β normalize unnormalized) | |
| def getSplit (laws : List (Shape Γ Law Shape)) (s : Shape) : Law Shape := | |
| ((laws.find? (fun x => x.1 == s)).map Prod.snd).getD [] | |
| def buildBinary : Build (Law (Shape Γ Shape)) := | |
| binaryKeys.mapM fun (t, u) => do | |
| pure ((t, u), β divide (β lit (binaryInteger t u)) (β lit 1000000)) | |
| def buildZeroPairs (weights : Law β€) : Build (List (Shape Γ Law PairSlot)) := | |
| zeroSecond.mapM fun t => do | |
| let slots := ((unorderedPairs t).flatMap fun (i,j) => [(i,j),(j,i)]).eraseDups | |
| let law := slots.map fun (i,j) => ((i,j), getLaw weights (orderedPairInteger t i j)) | |
| pure (t, β normalize law) | |
| def getPairs (laws : List (Shape Γ Law PairSlot)) (s : Shape) : Law PairSlot := | |
| ((laws.find? (fun x => x.1 == s)).map Prod.snd).getD [] | |
| def littleLaw (binary : Law (Shape Γ Shape)) (t u : Shape) (w : Fin 3) : | |
| Build (Law (Fin 6)) := do | |
| if u w = 2 then | |
| let d := getLaw binary (t,u) | |
| let c β sub 1 d | |
| pure ([(2,c),(3,d)].filter (fun e => e.2 != 0)) | |
| else | |
| pure [((([0,1,2,3,4,5] : List (Fin 6)).find? | |
| (fun i => statisticWeight i == u w)).getD 0, 1)] | |
| def pair [BEq Ξ±] (p : Law Shape) (s : Shape) (q : List (Shape Γ Law Ξ±)) : | |
| Build (Law (Ξ± Γ Ξ±)) := do | |
| let mut result := [] | |
| for (u, mass) in p do | |
| let left := ((q.find? (fun e => e.1 == u)).map Prod.snd).getD [] | |
| let right := ((q.find? (fun e => e.1 == complement s u)).map Prod.snd).getD [] | |
| for (i, vi) in left do | |
| for (j, vj) in right do | |
| let product β mul (β mul mass vi) vj | |
| result β addMass result (i,j) product | |
| pure result | |
| def maxAxis (s : Shape) : Fin 3 := | |
| (([0,1,2] : List (Fin 3)).find? (fun w => s w == shapeMax s)).getD 0 | |
| def buildHalfLaws (splits : List (Shape Γ Law Shape)) | |
| (binary : Law (Shape Γ Shape)) (pairs : List (Shape Γ Law PairSlot)) : | |
| Build (List ((Shape Γ Fin 3) Γ Law PairSlot)) := do | |
| let mut result := [] | |
| for t in shapes 8 do | |
| for w in ([0,1,2] : List (Fin 3)) do | |
| let law β if positive t then do | |
| let p := getSplit splits t | |
| let q β p.mapM fun (u,_) => do pure (u, β littleLaw binary t u w) | |
| pair p t q | |
| else if t w = 0 then pure [((0,0),1)] | |
| else if w = maxAxis t then pure (getPairs pairs t) | |
| else pure ((getPairs pairs t).map fun ((i,j),mass) => ((kappa i,kappa j),mass)) | |
| result := result ++ [((t,w),law)] | |
| pure result | |
| def getHalf (laws : List ((Shape Γ Fin 3) Γ Law PairSlot)) (t : Shape) (w : Fin 3) : | |
| Law PairSlot := | |
| ((laws.find? (fun e => e.1 == (t,w))).map Prod.snd).getD [] | |
| def orders : List (Fin 3 Γ Fin 3 Γ Fin 3) := | |
| [(0,1,2),(0,2,1),(1,0,2),(1,2,0),(2,0,1),(2,1,0)] | |
| def priority (t : Shape) : Fin 3 Γ Fin 3 Γ Fin 3 := | |
| (orders.find? fun (x,y,z) => | |
| ([shape 1 1 6, shape 1 2 5, shape 1 3 4, shape 2 2 4, shape 3 2 3]).contains | |
| (shape (t x) (t y) (t z))).getD (0,1,2) | |
| def capacity [BEq Ξ±] (s : Shape) (p : Law Shape) | |
| (order : Fin 3 Γ Fin 3 Γ Fin 3) (laws : Shape β Fin 3 β Build (Law Ξ±)) : | |
| Build (List Ref) := do | |
| let (x,y,z) := order | |
| let mut marginal := [] | |
| for (u,mass) in p do | |
| marginal β addMass marginal (u x) mass | |
| let first β entropy (marginal.map Prod.snd) | |
| let mut result := [first] | |
| for w in [y,z] do | |
| let q β p.mapM fun (u,_) => do pure (u, β laws u w) | |
| let mut groups : List (Nat Γ Law Ξ±) := [] | |
| let mut singleton := 0 | |
| for (u,mass) in p do | |
| let law := ((q.find? (fun e => e.1 == u)).map Prod.snd).getD [] | |
| let single := if w = y then u z = 0 else u x = 0 β¨ u y = 0 | |
| if single then | |
| singleton β add singleton (β mul mass (β entropy (law.map Prod.snd))) | |
| else | |
| let key := u w | |
| let mut group := ((groups.find? (fun e => e.1 == key)).map Prod.snd).getD [] | |
| for (i,val) in law do | |
| group β addMass group i (β mul mass val) | |
| if groups.any (fun e => e.1 == key) then | |
| groups := groups.map fun e => if e.1 == key then (key,group) else e | |
| else groups := groups ++ [(key,group)] | |
| let groupEntropies β groups.mapM fun e => entropy (e.2.map Prod.snd) | |
| let j β add singleton (β sumRefs groupEntropies) | |
| let joint β pair p s q | |
| let cap β sub (β entropy (joint.map Prod.snd)) (β mul j (β lit 2)) | |
| result := result ++ [cap] | |
| pure result | |
| def sortShape (t : Shape) : Shape := | |
| let a := min (t 0) (min (t 1) (t 2)) | |
| let c := max (t 0) (max (t 1) (t 2)) | |
| shape a (t 0 + t 1 + t 2 - a - c) c | |
| def secondTypes : List Shape := | |
| [shape 1 1 6, shape 1 2 5, shape 1 3 4, shape 2 2 4, shape 2 3 3] | |
| def buildMasses (a : Law Shape) (splits : List (Shape Γ Law Shape)) : Build (Law Shape) := | |
| (shapes 8).mapM fun t => do | |
| let terms β positiveInitial.mapM fun g => do | |
| mul (getLaw a g) (getLaw (getSplit splits g) t) | |
| let mass β sumRefs terms | |
| pure (t, β mul mass (β lit 2)) | |
| def buildLittleMasses (m : Law Shape) (splits : List (Shape Γ Law Shape)) : | |
| Build (Law (Shape Γ Shape)) := do | |
| let mut result := [] | |
| for t in positiveSecond do | |
| for (u,mass) in getSplit splits t do | |
| let v β mul (getLaw m t) (β lit 2) | |
| result := result ++ [((t,u), β mul v mass)] | |
| pure result | |
| def addRow [BEq Ξ±] (rows : List (Ξ± Γ List Ref)) (key : Ξ±) (mass : Ref) | |
| (caps : List Ref) : Build (List (Ξ± Γ List Ref)) := do | |
| rows.mapM fun (k,row) => do | |
| if k == key then | |
| pure (k, β (List.range 3).mapM fun i => do | |
| add (row[i]?.getD 0) (β mul mass (caps[i]?.getD 0))) | |
| else pure (k,row) | |
| def rowTotals (rows : List (Ξ± Γ List Ref)) : Build (List Ref) := | |
| (List.range 3).mapM fun i => sumRefs (rows.map fun row => row.2[i]?.getD 0) | |
| def binaryEntropy (d : Ref) : Build Ref := do | |
| add (β entropy [β sub 1 d,d]) (β mul d (β log (β lit 2))) | |
| def coefficientStep (xs : List Nat) : List Nat := | |
| (List.range (xs.length + 2)).map fun i => | |
| (xs[i]?.getD 0) + (if i > 0 then 5 * xs[i-1]?.getD 0 else 0) + | |
| (if i > 1 then xs[i-2]?.getD 0 else 0) | |
| def coefficients : List Nat := (List.range 8).foldl (fun xs _ => coefficientStep xs) [1] | |
| structure Roots where | |
| weights : Law β€ | |
| initial : Law Shape | |
| stageA : List (Shape Γ Law Shape) | |
| stageB : List (Shape Γ Law Shape) | |
| binary : Law (Shape Γ Shape) | |
| zeroPairs : List (Shape Γ Law PairSlot) | |
| halfLaws : List ((Shape Γ Fin 3) Γ Law PairSlot) | |
| masses : Law Shape | |
| littleMasses : Law (Shape Γ Shape) | |
| rowsA : List (Nat Γ List Ref) | |
| rowsB : List (Shape Γ List Ref) | |
| LA : List Ref | |
| LB : List Ref | |
| LAB : List Ref | |
| LC : List Ref | |
| lambda : List Ref | |
| LCdirect : List Ref | |
| H0 : Ref | |
| B : Ref | |
| T : Ref | |
| C : Ref | |
| S0 : Ref | |
| S1 : Ref | |
| S2 : Ref | |
| S : Ref | |
| rhs : Ref | |
| exponent : Ref | |
| denominatorSlack : Ref | |
| balanceSlacks : List Ref | |
| thresholdGap : Ref | |
| deriving DecidableEq | |
| def buildAll : Build Roots := do | |
| let _ β lit 0 | |
| let _ β lit 1 | |
| let weights β buildWeights | |
| let a β buildInitial weights | |
| let pa β buildSplit weights positiveInitial tableP | |
| let pb β buildSplit weights positiveSecond tablep | |
| let binary β buildBinary | |
| let zpairs β buildZeroPairs weights | |
| let half β buildHalfLaws pb binary zpairs | |
| let m β buildMasses a pa | |
| let mu β buildLittleMasses m pb | |
| let mut rowsA := (List.range 5).map fun i => (i+1,[0,0,0]) | |
| let mut rowsB := secondTypes.map fun t => (t,[0,0,0]) | |
| for t in positiveSecond do | |
| let caps β capacity t (getSplit pb t) (priority t) (littleLaw binary t) | |
| rowsB β addRow rowsB (sortShape t) (getLaw m t) caps | |
| for g in positiveInitial do | |
| let caps β capacity g (getSplit pa g) (0,1,2) (fun t w => pure (getHalf half t w)) | |
| rowsA β addRow rowsA (g 0) (getLaw a g) caps | |
| let la β rowTotals rowsA | |
| let lb β rowTotals rowsB | |
| let lab β (List.range 3).mapM fun i => add (la[i]?.getD 0) (lb[i]?.getD 0) | |
| let interior := mu.filter fun e => positive e.1.2 | |
| let total β sumRefs (interior.map Prod.snd) | |
| let bterms β interior.mapM fun ((t,u),mass) => do | |
| let rate β add (β mul (β log (β lit 2)) (β lit 2)) | |
| (β binaryEntropy (getLaw binary (t,u))) | |
| divide (β mul mass rate) (β lit 3) | |
| let b β sumRefs bterms | |
| let c β add b (β divide (β sumRefs lab) (β lit 3)) | |
| let lc β lab.mapM (sub c) | |
| let lambda β (List.range 3).mapM fun i => do | |
| let numerator β sub (β mul total (β log (β lit 2))) (lc[i]?.getD 0) | |
| let denominator β sub (β mul total (β log (β lit 2))) b | |
| divide numerator (β mul denominator (β lit 3)) | |
| let direct β (List.range 3).mapM fun i => do | |
| let terms β interior.mapM fun ((t,u),mass) => do | |
| let left β mul (β sub 1 (lambda[i]?.getD 0)) (β log (β lit 2)) | |
| let right β mul (lambda[i]?.getD 0) (β binaryEntropy (getLaw binary (t,u))) | |
| mul mass (β add left right) | |
| sumRefs terms | |
| let mut marginal := [] | |
| for (g,mass) in a do | |
| for w in ([0,1,2] : List (Fin 3)) do | |
| marginal β addMass marginal (g w) (β divide mass (β lit 3)) | |
| let h0 β entropy (marginal.map Prod.snd) | |
| let s0terms β (a.filter fun e => !positive e.1).mapM fun (g,mass) => do | |
| mul mass (β log (β lit (coefficients[shapeMax g]?.getD 0))) | |
| let s0 β sumRefs s0terms | |
| let s1terms β zeroSecond.mapM fun t => do | |
| let law := getPairs zpairs t | |
| let ent β entropy (law.map Prod.snd) | |
| let terms β law.mapM fun ((i,j),mass) => do | |
| mul mass (β log (β lit (multiplicity i * multiplicity j))) | |
| mul (getLaw m t) (β add ent (β sumRefs terms)) | |
| let s1 β sumRefs s1terms | |
| let mut s2 := 0 | |
| for ((t,u),mass) in mu do | |
| let d := getLaw binary (t,u) | |
| let rate β if shapeMax u = 4 then pure 0 | |
| else if shapeMax u = 3 then log (β lit 10) | |
| else if !positive u then do | |
| let first β binaryEntropy d | |
| let second β mul (β mul (β sub 1 d) (β lit 2)) (β log (β lit 5)) | |
| add first second | |
| else mul (β sub (β lit 2) d) (β log (β lit 5)) | |
| s2 β add s2 (β mul mass rate) | |
| let volume β add (β add s0 s1) s2 | |
| let rhs β mul (β log (β lit 7)) (β lit 8) | |
| let exponent β divide (β mul (β sub (β sub rhs h0) c) (β lit 3)) volume | |
| let denominatorSlack β sub (β mul total (β log (β lit 2))) b | |
| let balanceSlacks β lc.mapM fun v => do sub (β mul total (β log (β lit 2))) v | |
| let thresholdGap β sub (β lit ((2371054887 : β) / 10^9)) exponent | |
| pure { | |
| weights := weights | |
| initial := a | |
| stageA := pa | |
| stageB := pb | |
| binary := binary | |
| zeroPairs := zpairs | |
| halfLaws := half | |
| masses := m | |
| littleMasses := mu | |
| rowsA := rowsA | |
| rowsB := rowsB | |
| LA := la | |
| LB := lb | |
| LAB := lab | |
| LC := lc | |
| lambda := lambda | |
| LCdirect := direct | |
| H0 := h0 | |
| B := b | |
| T := total | |
| C := c | |
| S0 := s0 | |
| S1 := s1 | |
| S2 := s2 | |
| S := volume | |
| rhs := rhs | |
| exponent := exponent | |
| denominatorSlack := denominatorSlack | |
| balanceSlacks := balanceSlacks | |
| thresholdGap := thresholdGap } | |
| def built := buildAll.run {} | |
| def program : Program := built.2.program | |
| def roots : Roots := built.1 | |
| noncomputable def exponent : β := program.eval[roots.exponent]?.getD 0 | |
| noncomputable def scalar (root : Ref) : β := program.eval[root]?.getD 0 | |
| noncomputable def Y : β := scalar roots.H0 + scalar roots.C | |
| noncomputable def S : β := scalar roots.S | |
| noncomputable def R : β := 8 * Real.log 7 | |
| noncomputable def ratio : β := 3 * (R - Y) / S | |
| end MatrixMultiplication.AllFieldParameters.Contractions | |
| end OAI | |