Download data/lean/OAI/Algorithms/SubexponentialSAT/DensePolynomialPrograms.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 14.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/DensePolynomialPrograms.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/DensePolynomialPrograms.lean
-
curl -L -o DensePolynomialPrograms.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/DensePolynomialPrograms.lean
14.8 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.DensePolynomialLoop | |
| import OAI.Algorithms.SubexponentialSAT.SubexpFlatAdd | |
| import OAI.Algorithms.SubexponentialSAT.SubexpDensePolynomial | |
| import OAI.Algorithms.SubexponentialSAT.ProgramStateFrames | |
| namespace OAI.Algorithms | |
| /-! | |
| # A fixed streaming program for dense polynomial addition | |
| Quartic coefficients are four consecutive fixed-width base words. The loop | |
| uses the actual modular-word addition program and tests the input stacks. | |
| Its instruction table is independent of the array lengths and the width. | |
| -/ | |
| namespace SubexponentialSAT.DensePolynomialPrograms | |
| open BitProgram StructuredCalls DensePolynomialLoop | |
| open SubexpLiftRing SubexpQuarticRing | |
| /-- The fixed program calls the same fixed modular-word routine at each step. -/ | |
| abbrev addCmd : Cmd 8 20 := DensePolynomialLoop.addCmd SubexpFlatAdd.addOne | |
| abbrev program : Program 8 20 (StructuredCalls.size addCmd + 1) := | |
| StructuredCalls.compiled addCmd 8 8 | |
| variable (p μ : ℕ) [Fact p.Prime] (M : SubexpPreparedQuartic.Modulus p μ) | |
| /-- The generic loop premise is discharged by the existing actual scalar trace. -/ | |
| def wordStep : DensePolynomialLoop.WordStep (baseWidth p μ) where | |
| cmd := SubexpFlatAdd.addOne | |
| modulus := M.bits | |
| add x y := (SubexpPreparedQuartic.wordAdd p μ M x y).1 | |
| cost := SubexpFlatAdd.wordCost (baseWidth p μ) | |
| run := SubexpFlatAdd.addOne_eval p μ M | |
| def addWordsTotal := DensePolynomialLoop.addWordsTotal (wordStep p μ M) | |
| theorem addCmd_eval (hB : 0 < baseWidth p μ) (regs : Fin 8 → Bool) | |
| (xs ys : List (Word (baseWidth p μ))) (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) : | |
| ∃ n ≤ 7000 * (xs.length + ys.length + 1) * (baseWidth p μ + 1) ^ 2, ∃ regs', | |
| Eval addCmd n (ready regs M.bits (flatten xs) (flatten ys) width [] frame) | |
| (ready regs' M.bits (flatten (addWordsTotal p μ M xs ys)) [] width [] frame) := by | |
| obtain ⟨n, hn, rf, hr⟩ := DensePolynomialLoop.addCmd_eval (wordStep p μ M) | |
| hB regs xs ys width frame hwidth | |
| have hc : (wordStep p μ M).cost + 15 * baseWidth p μ + 20 ≤ | |
| 7000 * (baseWidth p μ + 1) ^ 2 := by | |
| change SubexpFlatAdd.wordCost (baseWidth p μ) + 15 * baseWidth p μ + 20 ≤ _ | |
| unfold SubexpFlatAdd.wordCost | |
| ring_nf | |
| omega | |
| refine ⟨n, hn.trans ?_, rf, hr⟩ | |
| calc | |
| _ ≤ (xs.length + ys.length + 1) * (7000 * (baseWidth p μ + 1) ^ 2) := | |
| Nat.mul_le_mul_left _ hc | |
| _ = _ := by ring | |
| /-- Equal-length word arrays represent coordinatewise modular addition. -/ | |
| theorem addWordsTotal_values (xs ys : List (Word (baseWidth p μ))) | |
| (hlen : xs.length = ys.length) : | |
| (addWordsTotal p μ M xs ys).map (wordValue p μ) = | |
| List.zipWith (fun x y => wordValue p μ x + wordValue p μ y) xs ys := by | |
| induction xs generalizing ys with | |
| | nil => | |
| cases ys with | |
| | nil => rfl | |
| | cons y ys => simp at hlen | |
| | cons x xs ih => | |
| cases ys with | |
| | nil => simp at hlen | |
| | cons y ys => | |
| change wordValue p μ (SubexpPreparedQuartic.wordAdd p μ M x y).1 :: | |
| (addWordsTotal p μ M xs ys).map (wordValue p μ) = | |
| (wordValue p μ x + wordValue p μ y) :: | |
| List.zipWith (fun x y => wordValue p μ x + wordValue p μ y) xs ys | |
| rw [SubexpPreparedQuartic.wordAdd_correct, ih ys (by simpa using hlen)] | |
| /-- The same fixed loop is a coordinatewise modular vector-addition machine. | |
| Taking μ=1 specializes it to vectors over the prime field. -/ | |
| theorem wordVectorAdd_eval (hB : 0 < baseWidth p μ) (regs : Fin 8 → Bool) | |
| (xs ys : List (Word (baseWidth p μ))) (hlen : xs.length = ys.length) | |
| (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) : | |
| ∃ n ≤ 7000 * (xs.length + ys.length + 1) * (baseWidth p μ + 1) ^ 2, | |
| ∃ (regs' : Fin 8 → Bool) (out : List (Word (baseWidth p μ))), | |
| out.map (wordValue p μ) = | |
| List.zipWith (fun x y => wordValue p μ x + wordValue p μ y) xs ys ∧ | |
| Eval addCmd n (ready regs M.bits (flatten xs) (flatten ys) width [] frame) | |
| (ready regs' M.bits (flatten out) [] width [] frame) := by | |
| obtain ⟨n, hn, regs', hrun⟩ := addCmd_eval p μ M hB regs xs ys width frame hwidth | |
| exact ⟨n, hn, regs', addWordsTotal p μ M xs ys, | |
| addWordsTotal_values p μ M xs ys hlen, hrun⟩ | |
| def polynomialWords {B : ℕ} (P : List (Quad (Word B))) : List (Word B) := | |
| P.flatMap SubexpFlatAdd.quadWords | |
| def encodePolynomial {B : ℕ} (P : List (Quad (Word B))) : List Bool := | |
| flatten (polynomialWords P) | |
| @[simp] theorem polynomialWords_length {B : ℕ} (P : List (Quad (Word B))) : | |
| (polynomialWords P).length = 4 * P.length := by | |
| induction P with | |
| | nil => simp [polynomialWords] | |
| | cons a P ih => | |
| simp only [polynomialWords, List.flatMap_cons, List.length_append] at ⊢ | |
| change 4 + (polynomialWords P).length = 4 * (P.length + 1) | |
| rw [ih] | |
| omega | |
| @[simp] theorem encodePolynomial_length {B : ℕ} (P : List (Quad (Word B))) : | |
| (encodePolynomial P).length = 4 * P.length * B := by | |
| simp only [encodePolynomial, flatten_length, polynomialWords_length] | |
| theorem addWordsTotal_quad (a b : Quad (Word (baseWidth p μ))) | |
| (xs ys : List (Word (baseWidth p μ))) : | |
| addWordsTotal p μ M (SubexpFlatAdd.quadWords a ++ xs) (SubexpFlatAdd.quadWords b ++ ys) = | |
| SubexpFlatAdd.quadWords (SubexpPreparedQuartic.binaryAdd p μ M a b).1 ++ addWordsTotal p μ M xs ys := rfl | |
| theorem polynomialWords_addProgram | |
| (ops : SubexpSymbolicCost.RingProgram (Quad (Word (baseWidth p μ)))) | |
| (hadd : ∀ a b, (ops.addRun a b).1 = (SubexpPreparedQuartic.binaryAdd p μ M a b).1) | |
| (P Q : List (Quad (Word (baseWidth p μ)))) : | |
| addWordsTotal p μ M (polynomialWords P) (polynomialWords Q) = | |
| polynomialWords (SubexpDensePolynomial.addProgram ops P Q).1 := by | |
| induction P generalizing Q with | |
| | nil => simp [polynomialWords, addWordsTotal, DensePolynomialLoop.addWordsTotal, SubexpDensePolynomial.addProgram] | |
| | cons a P ih => | |
| cases Q with | |
| | nil => simp [polynomialWords, addWordsTotal, DensePolynomialLoop.addWordsTotal, SubexpFlatAdd.quadWords, SubexpDensePolynomial.addProgram] | |
| | cons b Q => | |
| change addWordsTotal p μ M (SubexpFlatAdd.quadWords a ++ polynomialWords P) | |
| (SubexpFlatAdd.quadWords b ++ polynomialWords Q) = | |
| SubexpFlatAdd.quadWords (ops.addRun a b).1 ++ | |
| polynomialWords (SubexpDensePolynomial.addProgram ops P Q).1 | |
| rw [hadd, addWordsTotal_quad, ih] | |
| theorem polynomialAdd_eval (hB : 0 < baseWidth p μ) (regs : Fin 8 → Bool) | |
| (ops : SubexpSymbolicCost.RingProgram (Quad (Word (baseWidth p μ)))) | |
| (hadd : ∀ a b, (ops.addRun a b).1 = (SubexpPreparedQuartic.binaryAdd p μ M a b).1) | |
| (P Q : List (Quad (Word (baseWidth p μ)))) (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) : | |
| ∃ n ≤ 28000 * (P.length + Q.length + 1) * (baseWidth p μ + 1) ^ 2, ∃ regs', | |
| Eval addCmd n (ready regs M.bits (encodePolynomial P) (encodePolynomial Q) width [] frame) | |
| (ready regs' M.bits | |
| (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1) [] width [] frame) := by | |
| obtain ⟨n, hn, rf, hr⟩ := addCmd_eval p μ M hB regs (polynomialWords P) (polynomialWords Q) | |
| width frame hwidth | |
| rw [polynomialWords_addProgram p μ M ops hadd] at hr | |
| refine ⟨n, hn.trans ?_, rf, hr⟩ | |
| simp only [polynomialWords_length] | |
| apply Nat.mul_le_mul_right ((baseWidth p μ + 1) ^ 2) | |
| calc | |
| 7000 * (4 * P.length + 4 * Q.length + 1) ≤ 7000 * (4 * (P.length + Q.length + 1)) := | |
| Nat.mul_le_mul_left _ (by omega) | |
| _ = _ := by ring | |
| theorem polynomialAdd_runs (hB : 0 < baseWidth p μ) (regs : Fin 8 → Bool) | |
| (ops : SubexpSymbolicCost.RingProgram (Quad (Word (baseWidth p μ)))) | |
| (hadd : ∀ a b, (ops.addRun a b).1 = (SubexpPreparedQuartic.binaryAdd p μ M a b).1) | |
| (P Q : List (Quad (Word (baseWidth p μ)))) (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) : | |
| ∃ regs', RunsIn program (30000 * (P.length + Q.length + 1) * (baseWidth p μ + 1) ^ 2) | |
| ((ready regs M.bits (encodePolynomial P) (encodePolynomial Q) width [] frame).withPC | |
| (some program.entry)) | |
| ((ready regs' M.bits (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1) | |
| [] width [] frame).withPC none) := by | |
| obtain ⟨n, hn, rf, hr⟩ := polynomialAdd_eval p μ M hB regs ops hadd P Q width frame hwidth | |
| refine ⟨rf, n + 1, ?_, StructuredCalls.compiled_halt_trace hr 8 8⟩ | |
| let T := (P.length + Q.length + 1) * (baseWidth p μ + 1) ^ 2 | |
| have hT : 0 < T := Nat.mul_pos (by omega) (pow_pos (by omega) _) | |
| have hn' : n ≤ 28000 * T := by simpa [T, Nat.mul_assoc] using hn | |
| calc | |
| n + 1 ≤ 30000 * T := by omega | |
| _ = _ := by dsimp [T]; ring | |
| theorem polynomialAdd_primitive (hB : 0 < baseWidth p μ) (regs : Fin 8 → Bool) | |
| (ops : SubexpSymbolicCost.RingProgram (Quad (Word (baseWidth p μ)))) | |
| (hadd : ∀ a b, (ops.addRun a b).1 = (SubexpPreparedQuartic.binaryAdd p μ M a b).1) | |
| (P Q : List (Quad (Word (baseWidth p μ)))) (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) : | |
| ∃ regs', Computation.RunsIn (BitProgram.primitive program).step | |
| (BitProgram.primitiveOverhead program * | |
| (30000 * (P.length + Q.length + 1) * (baseWidth p μ + 1) ^ 2)) | |
| (BitProgram.primitiveCfg program | |
| ((ready regs M.bits (encodePolynomial P) (encodePolynomial Q) width [] frame).withPC | |
| (some program.entry))) | |
| (BitProgram.primitiveCfg program | |
| ((ready regs' M.bits (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1) | |
| [] width [] frame).withPC none)) := by | |
| obtain ⟨rf, hr⟩ := polynomialAdd_runs p μ M hB regs ops hadd P Q width frame hwidth | |
| exact ⟨rf, BitProgram.primitive_execution program hr⟩ | |
| /-- Concrete prepared-quartic instantiation, with no callback-refinement premise. -/ | |
| theorem preparedPolynomialAdd_primitive (p D : ℕ) [Fact p.Prime] | |
| (M : SubexpPreparedQuartic.Modulus p (D + 1)) | |
| (t z o : SubexpSymbolicCost.QuarticCode p D) (regs : Fin 8 → Bool) | |
| (P Q : List (SubexpSymbolicCost.QuarticCode p D)) | |
| (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p (D + 1)) : | |
| ∃ regs', Computation.RunsIn (BitProgram.primitive program).step | |
| (BitProgram.primitiveOverhead program * | |
| (30000 * (P.length + Q.length + 1) * (baseWidth p (D + 1) + 1) ^ 2)) | |
| (BitProgram.primitiveCfg program | |
| ((ready regs M.bits (encodePolynomial P) (encodePolynomial Q) width [] frame).withPC | |
| (some program.entry))) | |
| (BitProgram.primitiveCfg program | |
| ((ready regs' M.bits | |
| (encodePolynomial (SubexpDensePolynomial.addProgram | |
| (SubexpSymbolicCost.preparedProgram p D M t z o) P Q).1) | |
| [] width [] frame).withPC none)) := by | |
| exact polynomialAdd_primitive p (D + 1) M | |
| (Nat.mul_pos (Nat.zero_lt_succ D) (Nat.zero_lt_succ _)) regs | |
| (SubexpSymbolicCost.preparedProgram p D M t z o) (by intros; rfl) | |
| P Q width frame hwidth | |
| /-- Relocate the fixed addition program into a caller's physical workspace. -/ | |
| abbrev callAt {r s : ℕ} (registers : Fin 8 ↪ Fin r) (ports : Fin 20 ↪ Fin s) : Cmd r s := | |
| .call (ProgramLinking.liftProgram program registers ports) | |
| private theorem extend_agree {α β γ : Type*} (f : α ↪ β) (values : α → γ) | |
| (frame : β → γ) (h : ∀ i, frame (f i) = values i) : | |
| Function.extend f values frame = frame := by | |
| classical | |
| funext j | |
| by_cases hj : ∃ i, f i = j | |
| · obtain ⟨i, rfl⟩ := hj | |
| rw [f.injective.extend_apply, h] | |
| · exact Function.extend_apply' _ _ _ hj | |
| /-- The relocated call changes only its two input/output ports. The complete | |
| bit-level addition trace, including its return instruction, is retained. -/ | |
| theorem callAt_eval {r s : ℕ} (registers : Fin 8 ↪ Fin r) (ports : Fin 20 ↪ Fin s) | |
| (hB : 0 < baseWidth p μ) | |
| (ops : SubexpSymbolicCost.RingProgram (Quad (Word (baseWidth p μ)))) | |
| (hadd : ∀ a b, (ops.addRun a b).1 = (SubexpPreparedQuartic.binaryAdd p μ M a b).1) | |
| (P Q : List (Quad (Word (baseWidth p μ)))) (width : List Bool) (frame : Fin 6 → List Bool) | |
| (hwidth : width.length = baseWidth p μ) (d : State r s) | |
| (hstore : ∀ i, d.stacks (ports i) = | |
| (ready (fun _ => false) M.bits (encodePolynomial P) (encodePolynomial Q) width [] frame).stacks i) : | |
| ∃ (n : ℕ) (rf : Fin 8 → Bool), | |
| n ≤ 30000 * (P.length + Q.length + 1) * (baseWidth p μ + 1)^2 ∧ | |
| Eval (callAt registers ports) n d | |
| ⟨Function.extend registers rf d.regs, | |
| Function.update (Function.update d.stacks (ports 8) | |
| (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1)) (ports 9) []⟩ := by | |
| let start := ready (fun i => d.regs (registers i)) M.bits | |
| (encodePolynomial P) (encodePolynomial Q) width [] frame | |
| obtain ⟨rf, n, hn, ht⟩ := polynomialAdd_runs p μ M hB (fun i => d.regs (registers i)) | |
| ops hadd P Q width frame hwidth | |
| have hp : projectState registers ports d = start := by | |
| apply SubexpScanPrimitives.state_ext | |
| · rfl | |
| · funext i | |
| exact hstore i | |
| have hc := eval_call_from_state program registers ports d registers.injective ports.injective | |
| (by simpa only [hp] using ht) | |
| have hout : | |
| (ready rf M.bits (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1) | |
| [] width [] frame).stacks = | |
| Function.update (Function.update start.stacks 8 | |
| (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1)) 9 [] := by | |
| funext i | |
| fin_cases i <;> simp [ready, DensePolynomialLoop.state, stackArray, start, | |
| Fin.addCases, Fin.coe_ofNat_eq_mod] | |
| have hi : Function.extend ports start.stacks d.stacks = d.stacks := | |
| extend_agree ports start.stacks d.stacks hstore | |
| have he : embedState registers ports d | |
| (ready rf M.bits (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1) | |
| [] width [] frame) = | |
| (⟨Function.extend registers rf d.regs, | |
| Function.update (Function.update d.stacks (ports 8) | |
| (encodePolynomial (SubexpDensePolynomial.addProgram ops P Q).1)) (ports 9) []⟩ : State r s) := by | |
| apply SubexpScanPrimitives.state_ext | |
| · rfl | |
| · change Function.extend ports _ d.stacks = _ | |
| rw [hout, ProgramLinking.extend_update ports.injective, | |
| ProgramLinking.extend_update ports.injective, hi] | |
| exact ⟨n, rf, hn, by simpa only [he, callAt] using hc⟩ | |
| end SubexponentialSAT.DensePolynomialPrograms | |
| end OAI.Algorithms | |