introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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