math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /SparseBudgetProgram.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudgetProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 40.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudgetProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudgetProgram.lean
-
curl -L -o SparseBudgetProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudgetProgram.lean
40.5 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseBudget | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.ParameterBank | |
| import OAI.Algorithms.SubexponentialSAT.ModularArithmetic | |
| import OAI.Algorithms.SubexponentialSAT.BitProgramSpace | |
| /-! | |
| Concrete finite-control construction of the Appendix A dyadic search. | |
| The input budget is `1 / s`; the search uses only exact binary arithmetic. | |
| This file separates command construction from theorems about its execution. | |
| -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseBudgetProgram | |
| open BitProgram StructuredCalls BinaryArithmetic | |
| open ParametersProgram | |
| open scoped BigOperators | |
| @[simp] theorem bits_three_length : (3 : ℕ).bits.length = 2 := by | |
| rw [Nat.bit1_bits 1, Nat.one_bits] | |
| rfl | |
| @[simp] theorem bits_four_length : (4 : ℕ).bits.length = 3 := by | |
| rw [Nat.bit0_bits 2 (by decide), Nat.bit0_bits 1 (by decide), Nat.one_bits] | |
| rfl | |
| @[simp] theorem bits_sixteen_length : (16 : ℕ).bits.length = 5 := by | |
| rw [Nat.bit0_bits 8 (by decide), Nat.bit0_bits 4 (by decide), | |
| Nat.bit0_bits 2 (by decide), Nat.bit0_bits 1 (by decide), Nat.one_bits] | |
| rfl | |
| inductive Arithmetic where | |
| | add | |
| | multiply | |
| def Arithmetic.value : Arithmetic → ℕ → ℕ → ℕ | |
| | .add => (· + ·) | |
| | .multiply => (· * ·) | |
| def Arithmetic.command (op : Arithmetic) (a b o : Fin 19) | |
| (hoa : o ≠ a) (hob : o ≠ b) : Cmd 8 32 := | |
| match op with | |
| | .add => addCmd a b o hoa hob | |
| | .multiply => multiplyCmd a b o hoa hob | |
| theorem Arithmetic.eval (op : Arithmetic) (r : Regs) (w : Words) | |
| (a b o : Fin 19) (hoa : o ≠ a) (hob : o ≠ b) (ho : w o = []) : | |
| ∃ t rf word, Eval (op.command a b o hoa hob) t (state r w) | |
| (state rf (Function.update w o word)) ∧ | |
| toNat word = op.value (toNat (w a)) (toNat (w b)) ∧ | |
| word.length ≤ (w a).length + (w b).length + 1 ∧ | |
| t ≤ 100 * ((w a).length + (w b).length + 1) ^ 2 := by | |
| cases op with | |
| | add => exact add_eval r w a b o hoa hob ho | |
| | multiply => exact multiply_eval r w a b o hoa hob ho | |
| /-- The temporary is emptied before returning; the destination may be an operand. -/ | |
| def replaceCmd (op : Arithmetic) (a b o tmp : Fin 19) | |
| (hta : tmp ≠ a) (htb : tmp ≠ b) : Cmd 8 32 := | |
| .seq (op.command a b tmp hta htb) | |
| (.seq (clearCmd o) (.seq (copyCmd tmp o) (clearCmd tmp))) | |
| theorem replace_eval (op : Arithmetic) (r : Regs) (w : Words) | |
| (a b o tmp : Fin 19) (hta : tmp ≠ a) (htb : tmp ≠ b) | |
| (hto : tmp ≠ o) (ht : w tmp = []) : | |
| ∃ t rf word, Eval (replaceCmd op a b o tmp hta htb) t (state r w) | |
| (state rf (Function.update w o word)) ∧ | |
| toNat word = op.value (toNat (w a)) (toNat (w b)) ∧ | |
| word.length ≤ (w a).length + (w b).length + 1 ∧ | |
| t ≤ 150 * ((w a).length + (w b).length + (w o).length + 2) ^ 2 := by | |
| obtain ⟨t, r₁, word, he, hv, hl, htime⟩ := op.eval r w a b tmp hta htb ht | |
| obtain ⟨r₂, hc⟩ := clear_eval r₁ (Function.update w tmp word) o | |
| obtain ⟨r₃, hp⟩ := copy_eval r₂ (Function.update (Function.update w tmp word) o []) | |
| tmp o hto.symm (by simp) | |
| obtain ⟨r₄, hz⟩ := clear_eval r₃ | |
| (Function.update (Function.update (Function.update w tmp word) o []) o word) tmp | |
| have hframe : Function.update | |
| (Function.update (Function.update (Function.update w tmp word) o []) o word) tmp [] = | |
| Function.update w o word := by | |
| funext i | |
| by_cases hi : i = tmp | |
| · subst i | |
| simp [hto, ht] | |
| · by_cases hio : i = o | |
| · subst i | |
| simp [Ne.symm hto] | |
| · simp [hi, hio] | |
| refine ⟨t + (2 * (w o).length + 3 + | |
| (7 * word.length + 5 + (2 * word.length + 3))), r₄, word, ?_, hv, hl, ?_⟩ | |
| · have hp' := hp | |
| simp only [Function.update_of_ne hto, Function.update_self] at hp' | |
| have hc' := hc | |
| simp only [Function.update_of_ne hto.symm] at hc' | |
| have hz' := hz | |
| simp only [Function.update_of_ne hto, Function.update_self] at hz' | |
| simpa only [replaceCmd, hframe] using he.seq (hc'.seq (hp'.seq hz')) | |
| · nlinarith | |
| /-- One Horner step for `sum (3*M)^j`, using data 12 for `3*M` and data 5 for one. -/ | |
| def hornerStep : Cmd 8 32 := | |
| .seq (replaceCmd .multiply 2 12 2 3 (by decide) (by decide)) | |
| (replaceCmd .add 2 5 2 3 (by decide) (by decide)) | |
| def horner : ℕ → Cmd 8 32 | |
| | 0 => .base .skip | |
| | j + 1 => .seq (horner j) hornerStep | |
| theorem hornerStep_eval (r : Regs) (w : Words) (ht : w 3 = []) : | |
| ∃ t rf word, Eval hornerStep t (state r w) | |
| (state rf (Function.update w 2 word)) ∧ | |
| toNat word = toNat (w 2) * toNat (w 12) + toNat (w 5) ∧ | |
| word.length ≤ (w 2).length + (w 12).length + (w 5).length + 2 ∧ | |
| t ≤ 1200 * ((w 2).length + (w 12).length + (w 5).length + 2) ^ 2 := by | |
| obtain ⟨t₁, r₁, word₁, he₁, hv₁, hl₁, ht₁⟩ := | |
| replace_eval .multiply r w 2 12 2 3 (by decide) (by decide) (by decide) ht | |
| obtain ⟨t₂, r₂, word₂, he₂, hv₂, hl₂, ht₂⟩ := | |
| replace_eval .add r₁ (Function.update w 2 word₁) 2 5 2 3 | |
| (by decide) (by decide) (by decide) (by simpa using ht) | |
| simp only [Function.update_self, Function.update_of_ne (by decide : (5 : Fin 19) ≠ 2), | |
| Arithmetic.value] at hv₂ hl₂ ht₂ | |
| refine ⟨t₁ + t₂, r₂, word₂, ?_, ?_, by omega, ?_⟩ | |
| · simpa only [hornerStep, Function.update_idem] using he₁.seq he₂ | |
| · simpa only [Arithmetic.value, hv₁] using hv₂ | |
| · let L := (w 2).length + (w 12).length + (w 5).length + 2 | |
| have h₁ : 2 * (w 2).length + (w 12).length + 2 ≤ 2 * L := by dsimp [L]; omega | |
| have h₂ : 2 * word₁.length + (w 5).length + 2 ≤ 2 * L := by dsimp [L]; omega | |
| have hs₁ := Nat.pow_le_pow_left h₁ 2 | |
| have hs₂ := Nat.pow_le_pow_left h₂ 2 | |
| dsimp [L] at hs₁ hs₂ | |
| nlinarith | |
| /-- Horner's recurrence is unrolled in the finite control. The summation below | |
| counts its actual arithmetic traces, with no unit-cost natural multiplication. -/ | |
| theorem horner_eval (j : ℕ) (r : Regs) (w : Words) (ht : w 3 = []) | |
| (hu : toNat (w 5) = 1) : | |
| ∃ t rf word, Eval (horner j) t (state r w) | |
| (state rf (Function.update w 2 word)) ∧ | |
| toNat word = toNat (w 12) ^ j * toNat (w 2) + | |
| ∑ i ∈ Finset.range j, toNat (w 12) ^ i ∧ | |
| word.length ≤ (w 2).length + j * ((w 12).length + (w 5).length + 2) ∧ | |
| t ≤ 1200 * ∑ i ∈ Finset.range j, | |
| ((w 2).length + (i + 1) * ((w 12).length + (w 5).length + 2) + 2) ^ 2 := by | |
| induction j with | |
| | zero => | |
| refine ⟨0, r, w 2, ?_, ?_, ?_, ?_⟩ | |
| · simpa only [horner, Function.update_eq_self] using | |
| Eval.base (StructuredProgram.Eval.skip (state r w)) | |
| · simp | |
| · simp | |
| · simp | |
| | succ j ih => | |
| obtain ⟨t₁, r₁, word₁, he₁, hv₁, hl₁, ht₁⟩ := ih | |
| obtain ⟨t₂, r₂, word₂, he₂, hv₂, hl₂, ht₂⟩ := | |
| hornerStep_eval r₁ (Function.update w 2 word₁) (by simpa using ht) | |
| simp only [Function.update_self, | |
| Function.update_of_ne (by decide : (12 : Fin 19) ≠ 2), | |
| Function.update_of_ne (by decide : (5 : Fin 19) ≠ 2)] at hv₂ hl₂ ht₂ | |
| refine ⟨t₁ + t₂, r₂, word₂, ?_, ?_, ?_, ?_⟩ | |
| · simpa only [horner, Function.update_idem] using he₁.seq he₂ | |
| · rw [hv₂, hu, hv₁, geom_sum_succ, pow_succ] | |
| ring | |
| · simp only [Nat.add_mul, Nat.one_mul] | |
| omega | |
| · have harg : word₁.length + (w 12).length + (w 5).length + 2 ≤ | |
| (w 2).length + (j + 1) * ((w 12).length + (w 5).length + 2) + 2 := by | |
| simp only [Nat.add_mul, Nat.one_mul] | |
| omega | |
| have hs := Nat.pow_le_pow_left harg 2 | |
| rw [Finset.sum_range_succ, Nat.mul_add] | |
| omega | |
| /-- Computes `clog 2 (4*C*M)`, multiplies by Gamma and s, and tests `M < Gamma*h*s`. | |
| Horner evaluation and all arithmetic are finite binary programs. -/ | |
| def budgetTest (k : ℕ) : Cmd 8 32 := | |
| .seq (multiplyCmd 1 4 12 (by decide) (by decide)) | |
| (.seq (horner (k - 1)) | |
| (.seq (replaceCmd .multiply 2 6 2 3 (by decide) (by decide)) | |
| (.seq (replaceCmd .multiply 2 1 2 3 (by decide) (by decide)) | |
| (.seq (clogCmd 2 10) | |
| (.seq (multiplyCmd 10 7 11 (by decide) (by decide)) | |
| (.seq (multiplyCmd 11 0 9 (by decide) (by decide)) | |
| (.seq (copyCmd 1 8) | |
| (.seq (clearCmd 2) | |
| (.seq (clearCmd 10) | |
| (.seq (clearCmd 11) | |
| (.seq (clearCmd 12) (compareCmd 8 9)))))))))))) | |
| def prepared (k : ℕ) (s M : List Bool) : Words := | |
| fun i => if i = 0 then s else if i = 1 then M else if i = 4 then (3 : ℕ).bits | |
| else if i = 5 then [true] else if i = 6 then (16 : ℕ).bits | |
| else if i = 7 then (SparseCharging.rightConstant k).bits else [] | |
| def candidateWidth (k : ℕ) (s M : List Bool) : ℕ := | |
| (k - 1) * (M.length + 6) + M.length + s.length + | |
| (SparseCharging.rightConstant k).bits.length + 20 | |
| /-- Exact execution of the expensive test, including its arithmetic costs and cleanup. -/ | |
| theorem budgetTest_eval (k : ℕ) (hk : 2 ≤ k) (r : Regs) (s M : List Bool) | |
| (hM : 0 < toNat M) : | |
| ∃ t rf, Eval (budgetTest k) t (state r (prepared k s M)) | |
| (state rf (prepared k s M)) ∧ | |
| (rf 0 = true ↔ toNat M < SparseCharging.rightConstant k * | |
| Nat.clog 2 (4 * SparseCharging.depthConstant k (toNat M) * toNat M) * toNat s) ∧ | |
| t ≤ 10000 * (k + 1) * candidateWidth k s M ^ 2 := by | |
| let w := prepared k s M | |
| obtain ⟨t₁, r₁, base, he₁, hv₁, hl₁, ht₁⟩ := | |
| multiply_eval r w 1 4 12 (by decide) (by decide) (by simp [w, prepared]) | |
| let w₁ := Function.update w 12 base | |
| obtain ⟨t₂, r₂, sum, he₂, hv₂, hl₂, ht₂⟩ := horner_eval (k - 1) r₁ w₁ | |
| (by simp [w₁, w, prepared]) | |
| (by simp [w₁, w, prepared, BinaryArithmetic.toNat, BinaryArithmetic.bitVal]) | |
| let w₂ := Function.update w₁ 2 sum | |
| obtain ⟨t₃, r₃, scaled, he₃, hv₃, hl₃, ht₃⟩ := | |
| replace_eval .multiply r₂ w₂ 2 6 2 3 (by decide) (by decide) (by decide) | |
| (by simp [w₂, w₁, w, prepared]) | |
| let w₃ := Function.update w₂ 2 scaled | |
| obtain ⟨t₄, r₄, arg, he₄, hv₄, hl₄, ht₄⟩ := | |
| replace_eval .multiply r₃ w₃ 2 1 2 3 (by decide) (by decide) (by decide) | |
| (by simp [w₃, w₂, w₁, w, prepared]) | |
| have hbase : toNat base = toNat M * 3 := by | |
| simpa [w, prepared, ArithmeticExpressionSupport.bits_value] using hv₁ | |
| have hsum : toNat sum = ∑ i ∈ Finset.range (k - 1), (3 * toNat M) ^ i := by | |
| simpa [w₁, w, prepared, hbase, Nat.mul_comm] using hv₂ | |
| have hscaled : toNat scaled = toNat sum * 16 := by | |
| simpa [w₂, w₁, w, prepared, Arithmetic.value, ArithmeticExpressionSupport.bits_value] using hv₃ | |
| have harg : toNat arg = 4 * SparseCharging.depthConstant k (toNat M) * toNat M := by | |
| have hv : toNat arg = toNat scaled * toNat M := by | |
| simpa [Arithmetic.value, w₃, w₂, w₁, w, prepared] using hv₄ | |
| rw [hv, hscaled, hsum, SparseCharging.depthConstant] | |
| ring | |
| have hargpos : 0 < toNat arg := by | |
| rw [harg] | |
| have hC : 0 < SparseCharging.depthConstant k (toNat M) := by | |
| have := SparseBudget.four_le_depthConstant k (toNat M) hk | |
| omega | |
| exact Nat.mul_pos (Nat.mul_pos (by decide) hC) hM | |
| let w₄ := Function.update w₃ 2 arg | |
| obtain ⟨t₅, r₅, logarithm, he₅, hv₅, hl₅, ht₅⟩ := clog_eval r₄ w₄ 2 10 (by decide) | |
| (by simp [w₄, w₃, w₂, w₁, w, prepared]) (by simpa [w₄] using hargpos) | |
| let w₅ := Function.update w₄ 10 logarithm | |
| obtain ⟨t₆, r₆, product, he₆, hv₆, hl₆, ht₆⟩ := | |
| multiply_eval r₅ w₅ 10 7 11 (by decide) (by decide) | |
| (by simp [w₅, w₄, w₃, w₂, w₁, w, prepared]) | |
| let w₆ := Function.update w₅ 11 product | |
| obtain ⟨t₇, r₇, threshold, he₇, hv₇, hl₇, ht₇⟩ := | |
| multiply_eval r₆ w₆ 11 0 9 (by decide) (by decide) | |
| (by simp [w₆, w₅, w₄, w₃, w₂, w₁, w, prepared]) | |
| let w₇ := Function.update w₆ 9 threshold | |
| obtain ⟨r₈, he₈⟩ := copy_eval r₇ w₇ 1 8 (by decide) | |
| (by simp [w₇, w₆, w₅, w₄, w₃, w₂, w₁, w, prepared]) | |
| let w₈ := Function.update w₇ 8 (w₇ 1) | |
| obtain ⟨r₉, he₉⟩ := clear_eval r₈ w₈ 2 | |
| let w₉ := Function.update w₈ 2 [] | |
| obtain ⟨r₁₀, he₁₀⟩ := clear_eval r₉ w₉ 10 | |
| let w₁₀ := Function.update w₉ 10 [] | |
| obtain ⟨r₁₁, he₁₁⟩ := clear_eval r₁₀ w₁₀ 11 | |
| let w₁₁ := Function.update w₁₀ 11 [] | |
| obtain ⟨r₁₂, he₁₂⟩ := clear_eval r₁₁ w₁₁ 12 | |
| let w₁₂ := Function.update w₁₁ 12 [] | |
| obtain ⟨rf, he₁₃, hflag⟩ := compare_eval r₁₂ w₁₂ 8 9 (by decide) | |
| have hframe : Function.update (Function.update w₁₂ 8 []) 9 [] = w := by | |
| funext i | |
| fin_cases i <;> simp [w₁₂, w₁₁, w₁₀, w₉, w₈, w₇, w₆, w₅, w₄, w₃, w₂, w₁, w, prepared] | |
| have hrun := he₁.seq (he₂.seq (he₃.seq (he₄.seq | |
| (he₅.seq (he₆.seq (he₇.seq (he₈.seq (he₉.seq (he₁₀.seq (he₁₁.seq | |
| (he₁₂.seq he₁₃))))))))))) | |
| refine ⟨_, rf, by simpa only [budgetTest, hframe] using hrun, ?_, ?_⟩ | |
| · have hlog : toNat logarithm = Nat.clog 2 | |
| (4 * SparseCharging.depthConstant k (toNat M) * toNat M) := by | |
| simpa [w₄, harg] using hv₅ | |
| have hprod : toNat product = toNat logarithm * SparseCharging.rightConstant k := by | |
| simpa [w₅, w₄, w₃, w₂, w₁, w, prepared, ArithmeticExpressionSupport.bits_value] using hv₆ | |
| have hthresh : toNat threshold = SparseCharging.rightConstant k * | |
| Nat.clog 2 (4 * SparseCharging.depthConstant k (toNat M) * toNat M) * toNat s := by | |
| simpa [w₆, w₅, w₄, w₃, w₂, w₁, w, prepared, hprod, hlog, Nat.mul_comm] using hv₇ | |
| simpa [w₁₂, w₁₁, w₁₀, w₉, w₈, w₇, w₆, w₅, w₄, w₃, w₂, w₁, w, prepared, hthresh] | |
| using hflag | |
| · let L := candidateWidth k s M | |
| have hL : 20 ≤ L := by dsimp [L, candidateWidth]; omega | |
| simp [w₆, w₅, w₄, w₃, w₂, w₁, w, prepared] at hl₁ hl₂ hl₃ hl₄ hl₅ hl₆ hl₇ | |
| simp [w₆, w₅, w₄, w₃, w₂, w₁, w, prepared] at ht₁ ht₂ ht₃ ht₄ ht₅ ht₆ ht₇ | |
| have hbase : base.length ≤ M.length + 3 := by simpa using hl₁ | |
| have hH : sum.length ≤ (k - 1) * (M.length + 6) := by | |
| exact hl₂.trans (Nat.mul_le_mul_left _ (by omega)) | |
| have hsumL : sum.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hscaledL : scaled.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hargL : arg.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hlogL : logarithm.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hprodL : product.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hthreshL : threshold.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hbaseL : base.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hML : M.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hsL : s.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hΓL : (SparseCharging.rightConstant k).bits.length ≤ L := by | |
| dsimp [L, candidateWidth]; omega | |
| have hsquare (a b : ℕ) (h : a ≤ b * L) : a ^ 2 ≤ b ^ 2 * L ^ 2 := by | |
| simpa only [mul_pow] using Nat.pow_le_pow_left h 2 | |
| have hc₁ : t₁ ≤ 100 * L ^ 2 := by | |
| have harg : M.length + 3 ≤ L := by dsimp [L, candidateWidth]; omega | |
| have := Nat.pow_le_pow_left harg 2 | |
| nlinarith only [ht₁, this] | |
| have hc₂ : t₂ ≤ 1200 * (k - 1) * L ^ 2 := by | |
| have hsum : (∑ i ∈ Finset.range (k - 1), (0 + (i + 1) * (base.length + 1 + 2) + 2) ^ 2) ≤ | |
| (k - 1) * L ^ 2 := by | |
| calc | |
| _ ≤ ∑ _i ∈ Finset.range (k - 1), L ^ 2 := by | |
| apply Finset.sum_le_sum | |
| intro i hi | |
| apply Nat.pow_le_pow_left | |
| have hi' : i + 1 ≤ k - 1 := by have := Finset.mem_range.mp hi; omega | |
| have hh := Nat.mul_le_mul hi' (show base.length + 1 + 2 ≤ M.length + 6 by omega) | |
| dsimp [L, candidateWidth] | |
| omega | |
| _ = _ := by simp | |
| simp only [Nat.zero_add] at hsum | |
| nlinarith only [ht₂, hsum] | |
| have hc₃ : t₃ ≤ 1350 * L ^ 2 := by | |
| have := hsquare (sum.length + 5 + sum.length + 2) 3 (by omega) | |
| nlinarith only [ht₃, this] | |
| have hc₄ : t₄ ≤ 2400 * L ^ 2 := by | |
| have := hsquare (scaled.length + M.length + scaled.length + 2) 4 (by omega) | |
| nlinarith only [ht₄, this] | |
| have hc₅ : t₅ ≤ 320 * L ^ 2 := by | |
| have := hsquare (arg.length + 2) 2 (by omega) | |
| nlinarith only [ht₅, this] | |
| have hc₆ : t₆ ≤ 900 * L ^ 2 := by | |
| have := hsquare (logarithm.length + (SparseCharging.rightConstant k).bits.length + 1) | |
| 3 (by omega) | |
| nlinarith only [ht₆, this] | |
| have hc₇ : t₇ ≤ 900 * L ^ 2 := by | |
| have := hsquare (product.length + s.length + 1) 3 (by omega) | |
| nlinarith only [ht₇, this] | |
| have hmax : max M.length threshold.length ≤ L := max_le hML hthreshL | |
| have hself : L ≤ L ^ 2 := by nlinarith only [hL] | |
| simp [w₁₂, w₁₁, w₁₀, w₉, w₈, w₇, w₆, w₅, w₄, w₃, w₂, w₁, w, prepared] | |
| change _ ≤ 10000 * (k + 1) * L ^ 2 | |
| have hkl : (k - 1) * L ^ 2 ≤ k * L ^ 2 := Nat.mul_le_mul_right _ (Nat.sub_le k 1) | |
| nlinarith only [hc₁, hc₂, hc₃, hc₄, hc₅, hc₆, hc₇, hmax, hself, | |
| hML, hargL, hlogL, hprodL, hbaseL, hkl, hL] | |
| /-- First test the constant lower bound; the expensive logarithm is evaluated only | |
| when `M >= Gamma`. Both branches return with every temporary word empty. -/ | |
| def test (k : ℕ) : Cmd 8 32 := | |
| .seq (copyCmd 1 8) (.seq (copyCmd 7 9) | |
| (.seq (compareCmd 8 9) (.ite 0 (.base .skip) (budgetTest k)))) | |
| theorem test_eval (k : ℕ) (hk : 2 ≤ k) (r : Regs) (s M : List Bool) | |
| (hM : 0 < toNat M) : | |
| ∃ t rf, Eval (test k) t (state r (prepared k s M)) | |
| (state rf (prepared k s M)) ∧ | |
| (rf 0 = true ↔ toNat M < SparseCharging.rightConstant k ∨ | |
| toNat M < SparseCharging.rightConstant k * | |
| Nat.clog 2 (4 * SparseCharging.depthConstant k (toNat M) * toNat M) * toNat s) ∧ | |
| t ≤ 12000 * (k + 1) * candidateWidth k s M ^ 2 := by | |
| let w := prepared k s M | |
| obtain ⟨r₁, he₁⟩ := copy_eval r w 1 8 (by decide) (by simp [w, prepared]) | |
| let w₁ := Function.update w 8 (w 1) | |
| obtain ⟨r₂, he₂⟩ := copy_eval r₁ w₁ 7 9 (by decide) (by simp [w₁, w, prepared]) | |
| let w₂ := Function.update w₁ 9 (w₁ 7) | |
| obtain ⟨r₃, he₃, hf₃⟩ := compare_eval r₂ w₂ 8 9 (by decide) | |
| have hframe : Function.update (Function.update w₂ 8 []) 9 [] = w := by | |
| funext i | |
| fin_cases i <;> simp [w₂, w₁, w, prepared] | |
| rw [hframe] at he₃ | |
| have hflag : r₃ 0 = true ↔ toNat M < SparseCharging.rightConstant k := by | |
| simpa [w₂, w₁, w, prepared, ArithmeticExpressionSupport.bits_value] using hf₃ | |
| let L := candidateWidth k s M | |
| have hL : 20 ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hML : M.length ≤ L := by dsimp [L, candidateWidth]; omega | |
| have hΓL : (SparseCharging.rightConstant k).bits.length ≤ L := by | |
| dsimp [L, candidateWidth]; omega | |
| have hmax : max M.length (SparseCharging.rightConstant k).bits.length ≤ L := | |
| max_le hML hΓL | |
| have hself : L ≤ L ^ 2 := by nlinarith | |
| cases hreg : r₃ 0 with | |
| | false => | |
| obtain ⟨t, rf, he, hf, ht⟩ := budgetTest_eval k hk r₃ s M hM | |
| refine ⟨_, rf, he₁.seq (he₂.seq (he₃.seq (.ite_false hreg he))), ?_, ?_⟩ | |
| · have hn : ¬ toNat M < SparseCharging.rightConstant k := by | |
| intro h | |
| have := hflag.mpr h | |
| simp [hreg] at this | |
| simpa only [hn, false_or] using hf | |
| · simp [w₂, w₁, w, prepared] | |
| change _ ≤ 12000 * (k + 1) * L ^ 2 | |
| change t ≤ 10000 * (k + 1) * L ^ 2 at ht | |
| nlinarith | |
| | true => | |
| refine ⟨_, r₃, he₁.seq (he₂.seq (he₃.seq (.ite_true hreg | |
| (Eval.base (StructuredProgram.Eval.skip (state r₃ w)))))), ?_, ?_⟩ | |
| · exact ⟨fun _ => Or.inl (hflag.mp hreg), fun _ => hreg⟩ | |
| · simp [w₂, w₁, w, prepared] | |
| change _ ≤ 12000 * (k + 1) * L ^ 2 | |
| nlinarith | |
| def dyadicWord : ℕ → List Bool | |
| | 0 => [true] | |
| | e + 1 => false :: dyadicWord e | |
| @[simp] theorem dyadicWord_value (e : ℕ) : toNat (dyadicWord e) = 2 ^ e := by | |
| induction e with | |
| | zero => simp [dyadicWord, BinaryArithmetic.toNat, BinaryArithmetic.bitVal] | |
| | succ e ih => | |
| simp [dyadicWord, BinaryArithmetic.bitVal, ih, pow_succ, | |
| Nat.mul_comm] | |
| @[simp] theorem dyadicWord_length (e : ℕ) : (dyadicWord e).length = e + 1 := by | |
| induction e with | |
| | zero => rfl | |
| | succ e ih => simp [dyadicWord, ih] | |
| theorem test_dyadic_eval (k : ℕ) (hk : 2 ≤ k) (r : Regs) (s : List Bool) (e : ℕ) : | |
| ∃ t rf, Eval (test k) t (state r (prepared k s (dyadicWord e))) | |
| (state rf (prepared k s (dyadicWord e))) ∧ | |
| (rf 0 = true ↔ SparseBudget.parameterTest k 1 (toNat s) e = false) ∧ | |
| t ≤ 12000 * (k + 1) * candidateWidth k s (dyadicWord e) ^ 2 := by | |
| obtain ⟨t, rf, he, hf, ht⟩ := test_eval k hk r s (dyadicWord e) (by simp) | |
| refine ⟨t, rf, he, hf.trans ?_, ht⟩ | |
| have hΓ := SparseBudget.four_le_rightConstant k hk | |
| simp only [dyadicWord_value, SparseBudget.parameterTest, decide_eq_false_iff_not, one_mul] | |
| omega | |
| def double : Cmd 8 32 := | |
| .seq (.base (.atom (.set 0 false))) (.base (.atom (.push (port 1) 0))) | |
| theorem double_eval (r : Regs) (w : Words) : | |
| Eval double 2 (state r w) | |
| (state (Function.update r 0 false) (Function.update w 1 (false :: w 1))) := by | |
| have hs := Eval.base (StructuredProgram.Eval.atom (.set (0 : Fin 8) false) (state r w)) | |
| have hp := Eval.base (StructuredProgram.Eval.atom (.push (port 1) (0 : Fin 8)) | |
| ((StructuredProgram.Atom.set (0 : Fin 8) false).eval (state r w))) | |
| have h : Eval double 2 (state r w) | |
| (⟨Function.update r 0 false, Function.update (state r w).stacks (port 1) | |
| (false :: w 1)⟩ : Data) := by | |
| simpa [double, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr, | |
| StructuredProgram.State.ofCfg, StructuredProgram.State.withPC, execInstr] using hs.seq hp | |
| simpa only [state_update] using h | |
| theorem double_prepared_eval (k : ℕ) (r : Regs) (s : List Bool) (e : ℕ) : | |
| Eval double 2 (state r (prepared k s (dyadicWord e))) | |
| (state (Function.update r 0 false) (prepared k s (dyadicWord (e + 1)))) := by | |
| have h := double_eval r (prepared k s (dyadicWord e)) | |
| have heq : Function.update (prepared k s (dyadicWord e)) 1 | |
| (false :: prepared k s (dyadicWord e) 1) = prepared k s (dyadicWord (e + 1)) := by | |
| funext i | |
| by_cases hi : i = 1 | |
| · subst i | |
| simp [prepared, dyadicWord] | |
| · simp [hi, prepared] | |
| simpa only [heq] using h | |
| /-- Termination follows from the proved first-passing index; every loop iteration | |
| is an actual doubling trace followed by the concrete test trace. -/ | |
| theorem loop_eval (k : ℕ) (hk : 2 ≤ k) (s : List Bool) (e left : ℕ) | |
| (hstop : e + left = SparseBudget.chooseExponent k 1 (toNat s) (by decide)) | |
| (r : Regs) (hr : r 0 = true ↔ SparseBudget.parameterTest k 1 (toNat s) e = false) : | |
| ∃ t rf, Eval (.while 0 (.seq double (test k))) t | |
| (state r (prepared k s (dyadicWord e))) | |
| (state rf (prepared k s (dyadicWord | |
| (SparseBudget.chooseExponent k 1 (toNat s) (by decide))))) ∧ | |
| t ≤ (left + 1) * (12000 * (k + 1) * candidateWidth k s | |
| (dyadicWord (SparseBudget.chooseExponent k 1 (toNat s) (by decide))) ^ 2 + 3) := by | |
| induction left generalizing e r with | |
| | zero => | |
| have he : e = SparseBudget.chooseExponent k 1 (toNat s) (by decide) := by omega | |
| have hp := SparseBudget.chooseExponent_spec k 1 (toNat s) (by decide) | |
| have hrfalse : r 0 = false := by | |
| cases h : r 0 | |
| · rfl | |
| · have hbad := hr.mp h | |
| rw [he, hp] at hbad | |
| cases hbad | |
| refine ⟨1, r, ?_, by omega⟩ | |
| simpa only [he] using Eval.while_false (body := .seq double (test k)) hrfalse | |
| | succ left ih => | |
| have he : e < SparseBudget.chooseExponent k 1 (toNat s) (by decide) := by omega | |
| have hfail : SparseBudget.parameterTest k 1 (toNat s) e = false := by | |
| have hn := Nat.find_min (SparseBudget.exists_parameter k 1 (toNat s) (by decide)) he | |
| cases h : SparseBudget.parameterTest k 1 (toNat s) e | |
| · rfl | |
| · exact False.elim (hn h) | |
| have hd := double_prepared_eval k r s e | |
| obtain ⟨t, r₁, ht, hf, htime⟩ := test_dyadic_eval k hk (Function.update r 0 false) s (e + 1) | |
| obtain ⟨u, rf, hu, hutime⟩ := ih (e + 1) (by omega) r₁ hf | |
| refine ⟨2 + t + u + 1, rf, Eval.while_true (hr.mpr hfail) (hd.seq ht) hu, ?_⟩ | |
| have hwidth : candidateWidth k s (dyadicWord (e + 1)) ≤ | |
| candidateWidth k s (dyadicWord | |
| (SparseBudget.chooseExponent k 1 (toNat s) (by decide))) := by | |
| simp only [candidateWidth, dyadicWord_length] | |
| have hh := Nat.mul_le_mul_left (k - 1) | |
| (show e + 1 + 1 + 6 ≤ | |
| SparseBudget.chooseExponent k 1 (toNat s) (by decide) + 1 + 6 by omega) | |
| omega | |
| have hcost := Nat.mul_le_mul_left (12000 * (k + 1)) (Nat.pow_le_pow_left hwidth 2) | |
| let C := 12000 * (k + 1) * candidateWidth k s | |
| (dyadicWord (SparseBudget.chooseExponent k 1 (toNat s) (by decide))) ^ 2 | |
| have htC : t ≤ C := htime.trans (by simpa only [C] using hcost) | |
| have huC : u ≤ (left + 1) * (C + 3) := by simpa only [C] using hutime | |
| change 2 + t + u + 1 ≤ (left + 2) * (C + 3) | |
| calc | |
| 2 + t + u + 1 ≤ 3 + C + (left + 1) * (C + 3) := by omega | |
| _ = (left + 2) * (C + 3) := by ring | |
| /-- These constants are part of the fixed instruction table chosen from k. -/ | |
| def initCmd (k : ℕ) : Cmd 8 32 := | |
| .seq (loadCmd 1 [true]) (.seq (loadCmd 4 (3 : ℕ).bits) | |
| (.seq (loadCmd 5 [true]) (.seq (loadCmd 6 (16 : ℕ).bits) | |
| (loadCmd 7 (SparseCharging.rightConstant k).bits)))) | |
| def inputWords (s : List Bool) : Words := fun i => if i = 0 then s else [] | |
| theorem initCmd_eval (k : ℕ) (r : Regs) (s : List Bool) : | |
| ∃ t rf, Eval (initCmd k) t (state r (inputWords s)) | |
| (state rf (prepared k s (dyadicWord 0))) ∧ | |
| t ≤ 2 * (SparseCharging.rightConstant k).bits.length + 18 := by | |
| let w := inputWords s | |
| obtain ⟨r₁, he₁⟩ := load_eval r w 1 [true] (by simp [w, inputWords]) | |
| let w₁ := Function.update w 1 [true] | |
| obtain ⟨r₂, he₂⟩ := load_eval r₁ w₁ 4 (3 : ℕ).bits (by simp [w₁, w, inputWords]) | |
| let w₂ := Function.update w₁ 4 (3 : ℕ).bits | |
| obtain ⟨r₃, he₃⟩ := load_eval r₂ w₂ 5 [true] (by simp [w₂, w₁, w, inputWords]) | |
| let w₃ := Function.update w₂ 5 [true] | |
| obtain ⟨r₄, he₄⟩ := load_eval r₃ w₃ 6 (16 : ℕ).bits | |
| (by simp [w₃, w₂, w₁, w, inputWords]) | |
| let w₄ := Function.update w₃ 6 (16 : ℕ).bits | |
| obtain ⟨rf, he₅⟩ := load_eval r₄ w₄ 7 (SparseCharging.rightConstant k).bits | |
| (by simp [w₄, w₃, w₂, w₁, w, inputWords]) | |
| have hframe : Function.update w₄ 7 (SparseCharging.rightConstant k).bits = | |
| prepared k s (dyadicWord 0) := by | |
| funext i | |
| fin_cases i <;> simp [w₄, w₃, w₂, w₁, w, inputWords, prepared, dyadicWord] | |
| refine ⟨_, rf, by | |
| simpa only [initCmd, hframe] using he₁.seq (he₂.seq (he₃.seq (he₄.seq he₅))), ?_⟩ | |
| simp only [bits_three_length, bits_sixteen_length, List.length_singleton] | |
| omega | |
| /-- The actual dyadic search. The natural-number minimizer appears only in its | |
| specification, never as a machine instruction or a supplied runtime service. -/ | |
| def search (k : ℕ) : Cmd 8 32 := | |
| .seq (initCmd k) (.seq (test k) (.while 0 (.seq double (test k)))) | |
| def searchCost (k : ℕ) (s : List Bool) : ℕ := | |
| let N := SparseBudget.chooseExponent k 1 (toNat s) (by decide) | |
| (N + 3) * (12000 * (k + 1) * candidateWidth k s (dyadicWord N) ^ 2 + | |
| 2 * (SparseCharging.rightConstant k).bits.length + 21) | |
| theorem search_eval (k : ℕ) (hk : 2 ≤ k) (r : Regs) (s : List Bool) : | |
| ∃ t rf, Eval (search k) t (state r (inputWords s)) | |
| (state rf (prepared k s (dyadicWord | |
| (SparseBudget.chooseExponent k 1 (toNat s) (by decide))))) ∧ | |
| t ≤ searchCost k s := by | |
| obtain ⟨t₁, r₁, he₁, ht₁⟩ := initCmd_eval k r s | |
| obtain ⟨t₂, r₂, he₂, hf₂, ht₂⟩ := test_dyadic_eval k hk r₁ s 0 | |
| obtain ⟨t₃, rf, he₃, ht₃⟩ := loop_eval k hk s 0 | |
| (SparseBudget.chooseExponent k 1 (toNat s) (by decide)) (by omega) r₂ hf₂ | |
| refine ⟨t₁ + (t₂ + t₃), rf, he₁.seq (he₂.seq he₃), ?_⟩ | |
| have hwidth : candidateWidth k s (dyadicWord 0) ≤ candidateWidth k s | |
| (dyadicWord (SparseBudget.chooseExponent k 1 (toNat s) (by decide))) := by | |
| simp only [candidateWidth, dyadicWord_length] | |
| have := Nat.mul_le_mul_left (k - 1) | |
| (show 0 + 1 + 6 ≤ SparseBudget.chooseExponent k 1 (toNat s) (by decide) + 1 + 6 by omega) | |
| omega | |
| have hcost := Nat.mul_le_mul_left (12000 * (k + 1)) (Nat.pow_le_pow_left hwidth 2) | |
| dsimp [searchCost] | |
| nlinarith | |
| theorem chooseExponent_input_bits (k : ℕ) : | |
| ∃ T : ℕ, ∀ s : List Bool, 0 < toNat s → | |
| SparseBudget.chooseExponent k 1 (toNat s) (by decide) ≤ T + 2 * s.length := by | |
| obtain ⟨K, T, h⟩ := SparseBudget.choose_encoding_bounds k | |
| refine ⟨T, ?_⟩ | |
| intro s hs | |
| have hb := ModularArithmetic.toNat_lt_pow_length s | |
| have hl := Nat.log_lt_of_lt_pow (ne_of_gt hs) hb | |
| have hn := (h 1 (toNat s) (by decide) hs).2 | |
| omega | |
| /-- Constants are chosen before the binary input. This is polynomial in encoding | |
| length, not in the integer represented by the input word. -/ | |
| theorem searchCost_polynomial (k : ℕ) : | |
| ∃ K : ℕ, ∀ s : List Bool, 0 < toNat s → searchCost k s ≤ K * (s.length + 1) ^ 3 := by | |
| obtain ⟨T, hT⟩ := chooseExponent_input_bits k | |
| let g := (SparseCharging.rightConstant k).bits.length | |
| let D := (k + 2) * (T + g + 32) | |
| let E := 12000 * (k + 1) * D ^ 2 + 2 * g + 21 | |
| refine ⟨(T + 5) * E, ?_⟩ | |
| intro s hs | |
| let N := SparseBudget.chooseExponent k 1 (toNat s) (by decide) | |
| have hN : N ≤ T + 2 * s.length := hT s hs | |
| have hN' : N + 3 ≤ (T + 5) * (s.length + 1) := by nlinarith | |
| have hwidth : candidateWidth k s (dyadicWord N) ≤ D * (s.length + 1) := by | |
| simp only [candidateWidth, dyadicWord_length] | |
| have hsub := Nat.mul_le_mul_right (N + 1 + 6) (Nat.sub_le k 1) | |
| have hscaled := Nat.mul_le_mul_left (k + 1) hN | |
| have hD₁ : 2 * k + 3 ≤ D := by dsimp [D]; nlinarith | |
| have hD₂ : (k + 1) * T + 7 * k + g + 21 ≤ D := by dsimp [D]; nlinarith | |
| have hD₃ := Nat.mul_le_mul_right s.length hD₁ | |
| change _ ≤ D * (s.length + 1) | |
| change _ + _ + _ + g + _ ≤ _ | |
| nlinarith | |
| have hsq := Nat.pow_le_pow_left hwidth 2 | |
| have hone : 1 ≤ (s.length + 1) ^ 2 := by nlinarith | |
| have hconstant := Nat.mul_le_mul_left (2 * g + 21) hone | |
| have hterm : 12000 * (k + 1) * candidateWidth k s (dyadicWord N) ^ 2 + 2 * g + 21 ≤ | |
| E * (s.length + 1) ^ 2 := by | |
| dsimp [E] | |
| rw [mul_pow] at hsq | |
| have hscaled := Nat.mul_le_mul_left (12000 * (k + 1)) hsq | |
| nlinarith | |
| have hprod := Nat.mul_le_mul hN' hterm | |
| dsimp [searchCost] | |
| change (N + 3) * _ ≤ _ | |
| calc | |
| _ ≤ ((T + 5) * (s.length + 1)) * (E * (s.length + 1) ^ 2) := hprod | |
| _ = (T + 5) * E * (s.length + 1) ^ 3 := by ring | |
| /-- Fixed-k multiplication computes the safe occurrence bound `4*M^(k-1)`. -/ | |
| def boundPowers : ℕ → Cmd 8 32 | |
| | 0 => .base .skip | |
| | j + 1 => .seq (boundPowers j) | |
| (replaceCmd .multiply 2 1 2 3 (by decide) (by decide)) | |
| theorem boundPowers_eval (j : ℕ) (r : Regs) (w : Words) (ht : w 3 = []) : | |
| ∃ t rf word, Eval (boundPowers j) t (state r w) | |
| (state rf (Function.update w 2 word)) ∧ | |
| toNat word = toNat (w 2) * toNat (w 1) ^ j ∧ | |
| word.length ≤ (w 2).length + j * ((w 1).length + 1) ∧ | |
| t ≤ 600 * j * ((w 2).length + j * ((w 1).length + 1) + 2) ^ 2 := by | |
| induction j with | |
| | zero => | |
| refine ⟨0, r, w 2, ?_, ?_, ?_, ?_⟩ | |
| · simpa only [boundPowers, Function.update_eq_self] using | |
| Eval.base (StructuredProgram.Eval.skip (state r w)) | |
| · simp | |
| · simp | |
| · simp | |
| | succ j ih => | |
| obtain ⟨t, r₁, word, he, hv, hl, htime⟩ := ih | |
| obtain ⟨u, rf, word', he', hv', hl', htime'⟩ := replace_eval .multiply r₁ | |
| (Function.update w 2 word) 2 1 2 3 (by decide) (by decide) (by decide) | |
| (by simpa using ht) | |
| simp only [Function.update_self, | |
| Function.update_of_ne (by decide : (1 : Fin 19) ≠ 2), Arithmetic.value] at hv' hl' htime' | |
| refine ⟨t + u, rf, word', ?_, ?_, ?_, ?_⟩ | |
| · simpa only [boundPowers, Function.update_idem] using he.seq he' | |
| · rw [hv', hv, pow_succ] | |
| ring | |
| · simp only [Nat.add_mul, Nat.one_mul] | |
| omega | |
| · have hstep : word.length + (w 1).length + word.length + 2 ≤ | |
| 2 * ((w 2).length + (j + 1) * ((w 1).length + 1) + 2) := by | |
| simp only [Nat.add_mul, Nat.one_mul] | |
| omega | |
| have hs := Nat.pow_le_pow_left hstep 2 | |
| have hmono : ((w 2).length + j * ((w 1).length + 1) + 2) ^ 2 ≤ | |
| ((w 2).length + (j + 1) * ((w 1).length + 1) + 2) ^ 2 := | |
| Nat.pow_le_pow_left (by simp only [Nat.add_mul, Nat.one_mul]; omega) 2 | |
| have hm := Nat.mul_le_mul_left (600 * j) hmono | |
| nlinarith | |
| def command (k : ℕ) : Cmd 8 32 := | |
| .seq (search k) (.seq (loadCmd 2 (4 : ℕ).bits) (.seq (boundPowers (k - 1)) | |
| (.seq (clearCmd 4) (.seq (clearCmd 5) (.seq (clearCmd 6) (clearCmd 7)))))) | |
| def outputWords (s M B : List Bool) : Words := | |
| fun i => if i = 0 then s else if i = 1 then M else if i = 2 then B else [] | |
| def commandCost (k : ℕ) (s : List Bool) : ℕ := | |
| searchCost k s + 600 * k * | |
| (5 + k * (SparseBudget.chooseExponent k 1 (toNat s) (by decide) + 2)) ^ 2 + | |
| 2 * (SparseCharging.rightConstant k).bits.length + 50 | |
| /-- The two parameter words are returned in ports one and two; the input in port | |
| zero is preserved for the calling algorithm. All remaining 29 stacks are empty. -/ | |
| theorem command_eval (k : ℕ) (hk : 2 ≤ k) (r : Regs) (s : List Bool) : | |
| ∃ t rf M B, Eval (command k) t (state r (inputWords s)) | |
| (state rf (outputWords s M B)) ∧ | |
| toNat M = SparseBudget.chooseM k 1 (toNat s) (by decide) ∧ | |
| toNat B = 4 * toNat M ^ (k - 1) ∧ t ≤ commandCost k s := by | |
| let M := dyadicWord (SparseBudget.chooseExponent k 1 (toNat s) (by decide)) | |
| obtain ⟨t₁, r₁, he₁, ht₁⟩ := search_eval k hk r s | |
| let w := prepared k s M | |
| obtain ⟨r₂, he₂⟩ := load_eval r₁ w 2 (4 : ℕ).bits (by simp [w, prepared]) | |
| let w₂ := Function.update w 2 (4 : ℕ).bits | |
| obtain ⟨t₃, r₃, B, he₃, hv₃, _, ht₃⟩ := boundPowers_eval (k - 1) r₂ w₂ | |
| (by simp [w₂, w, prepared]) | |
| let w₃ := Function.update w₂ 2 B | |
| obtain ⟨r₄, he₄⟩ := clear_eval r₃ w₃ 4 | |
| let w₄ := Function.update w₃ 4 [] | |
| obtain ⟨r₅, he₅⟩ := clear_eval r₄ w₄ 5 | |
| let w₅ := Function.update w₄ 5 [] | |
| obtain ⟨r₆, he₆⟩ := clear_eval r₅ w₅ 6 | |
| let w₆ := Function.update w₅ 6 [] | |
| obtain ⟨rf, he₇⟩ := clear_eval r₆ w₆ 7 | |
| have hframe : Function.update w₆ 7 [] = outputWords s M B := by | |
| funext i | |
| fin_cases i <;> simp [w₆, w₅, w₄, w₃, w₂, w, prepared, outputWords] | |
| have hrun := he₁.seq (he₂.seq (he₃.seq (he₄.seq (he₅.seq (he₆.seq he₇))))) | |
| refine ⟨_, rf, M, B, by simpa only [command, hframe] using hrun, | |
| by simp [M, SparseBudget.chooseM], ?_, ?_⟩ | |
| · simpa [w₂, w, prepared, ArithmeticExpressionSupport.bits_value] using hv₃ | |
| · simp [w₂, w, prepared, M] at ht₃ | |
| let N := SparseBudget.chooseExponent k 1 (toNat s) (by decide) | |
| have harg : 3 + (k - 1) * (N + 1 + 1) + 2 ≤ 5 + k * (N + 2) := by | |
| rw [show N + 1 + 1 = N + 2 by omega] | |
| have := Nat.mul_le_mul_right (N + 2) (Nat.sub_le k 1) | |
| omega | |
| have hbudget := Nat.mul_le_mul (Nat.mul_le_mul_left 600 (Nat.sub_le k 1)) | |
| (Nat.pow_le_pow_left harg 2) | |
| change t₃ ≤ 600 * (k - 1) * (3 + (k - 1) * (N + 1 + 1) + 2) ^ 2 at ht₃ | |
| have htime₃ := ht₃.trans hbudget | |
| simp [w₆, w₅, w₄, w₃, w₂, w, prepared] | |
| dsimp [commandCost] | |
| change _ ≤ searchCost k s + 600 * k * (5 + k * (N + 2)) ^ 2 + _ + _ | |
| omega | |
| theorem commandCost_polynomial (k : ℕ) : | |
| ∃ K : ℕ, ∀ s : List Bool, 0 < toNat s → commandCost k s ≤ K * (s.length + 1) ^ 3 := by | |
| obtain ⟨K, hK⟩ := searchCost_polynomial k | |
| obtain ⟨T, hT⟩ := chooseExponent_input_bits k | |
| let D := 5 + k * (T + 4) | |
| let g := (SparseCharging.rightConstant k).bits.length | |
| refine ⟨K + 600 * k * D ^ 2 + 2 * g + 50, ?_⟩ | |
| intro s hs | |
| have hsearch := hK s hs | |
| have hindex := Nat.mul_le_mul_left k (hT s hs) | |
| have harg : 5 + k * (SparseBudget.chooseExponent k 1 (toNat s) (by decide) + 2) ≤ | |
| D * (s.length + 1) := by | |
| have hcoef : 2 * k ≤ D := by dsimp [D]; nlinarith | |
| have hconst : 5 + k * (T + 2) ≤ D := by dsimp [D]; nlinarith | |
| have hlin := Nat.mul_le_mul_right s.length hcoef | |
| calc | |
| _ ≤ (5 + k * (T + 2)) + 2 * k * s.length := by nlinarith | |
| _ ≤ D + D * s.length := Nat.add_le_add hconst hlin | |
| _ = D * (s.length + 1) := by ring | |
| have hsquare := Nat.pow_le_pow_left harg 2 | |
| rw [mul_pow] at hsquare | |
| have hscaled := Nat.mul_le_mul_left (600 * k) hsquare | |
| have hpow : (s.length + 1) ^ 2 ≤ (s.length + 1) ^ 3 := by | |
| exact Nat.pow_le_pow_right (by omega) (by decide) | |
| have hone : 1 ≤ (s.length + 1) ^ 3 := Nat.one_le_pow' 3 s.length | |
| have hp := Nat.mul_le_mul_left (600 * k * D ^ 2) hpow | |
| have hc := Nat.mul_le_mul_left (2 * g + 50) hone | |
| dsimp [commandCost] | |
| change _ + _ + 2 * g + 50 ≤ _ | |
| nlinarith | |
| def program (k : ℕ) : Program 8 32 (size (command k) + 1) := | |
| compiled (command k) (port 0) (port 1) | |
| /-- One finite Boolean/stack instruction table is chosen from k before the input. | |
| The returned configuration exposes both full parameter words for the caller. -/ | |
| theorem program_execution (k : ℕ) (hk : 2 ≤ k) : | |
| ∃ K : ℕ, ∀ s : List Bool, 0 < toNat s → | |
| ∃ t rf M B, Trace (program k) t (initial (program k) s) | |
| ((state rf (outputWords s M B)).withPC none) ∧ | |
| t ≤ K * (s.length + 1) ^ 3 ∧ | |
| toNat M = SparseBudget.chooseM k 1 (toNat s) (by decide) ∧ | |
| toNat B = 4 * toNat M ^ (k - 1) := by | |
| obtain ⟨K, hK⟩ := commandCost_polynomial k | |
| refine ⟨K + 1, ?_⟩ | |
| intro s hs | |
| obtain ⟨t, rf, M, B, he, hM, hB, ht⟩ := command_eval k hk (fun _ => false) s | |
| have hinput : state (fun _ => false) (inputWords s) = | |
| (StructuredProgram.ioState (port 0) s : Data) := by | |
| apply CounterForPrograms.data_ext | |
| · rfl | |
| · funext i | |
| fin_cases i <;> rfl | |
| have hc := compiled_halt_trace he (port 0) (port 1) | |
| rw [hinput] at hc | |
| refine ⟨t + 1, rf, M, B, hc, ?_, hM, hB⟩ | |
| have hb := ht.trans (hK s hs) | |
| have hp : 1 ≤ (s.length + 1) ^ 3 := Nat.one_le_pow' 3 s.length | |
| nlinarith | |
| /-- The polynomial-time local parameter search has polynomial storage at every | |
| source prefix, including every arithmetic temporary and every one of its stacks. -/ | |
| theorem program_execution_space (k : ℕ) (hk : 2 ≤ k) : | |
| ∃ K : ℕ, ∀ s : List Bool, 0 < toNat s → | |
| ∃ t rf M B, Trace (program k) t (initial (program k) s) | |
| ((state rf (outputWords s M B)).withPC none) ∧ | |
| t ≤ K * (s.length + 1) ^ 3 ∧ | |
| toNat M = SparseBudget.chooseM k 1 (toNat s) (by decide) ∧ | |
| toNat B = 4 * toNat M ^ (k - 1) ∧ | |
| ∀ prefixSteps intermediate, prefixSteps ≤ t → | |
| Trace (program k) prefixSteps (initial (program k) s) intermediate → | |
| dataBits intermediate ≤ K * (s.length + 1) ^ 3 := by | |
| obtain ⟨K, hK⟩ := program_execution k hk | |
| refine ⟨K + 1, ?_⟩ | |
| intro s hs | |
| obtain ⟨t, rf, M, B, ht, htime, hM, hB⟩ := hK s hs | |
| refine ⟨t, rf, M, B, ht, htime.trans ?_, hM, hB, ?_⟩ | |
| · exact Nat.mul_le_mul_right _ (Nat.le_succ K) | |
| · intro prefixSteps intermediate hp htrace | |
| have hdata := trace_dataBits (program k) htrace | |
| rw [initial_dataBits] at hdata | |
| have hlen : s.length ≤ (s.length + 1) ^ 3 := | |
| (Nat.le_succ _).trans (Nat.le_self_pow (by decide : (3 : ℕ) ≠ 0) _) | |
| calc | |
| dataBits intermediate ≤ s.length + prefixSteps := hdata | |
| _ ≤ (s.length + 1) ^ 3 + K * (s.length + 1) ^ 3 := | |
| Nat.add_le_add hlen (hp.trans htime) | |
| _ = (K + 1) * (s.length + 1) ^ 3 := by ring | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseBudgetProgram | |