math / data /lean /OAI /Algebra /FormulaHitting /GeneratorCost.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16.9 kB
import OAI.Algebra.FormulaHitting.Program
import OAI.Algebra.FormulaHitting.ProgramCost
namespace OAI
namespace NCHitting
open BitModel
def generatorExpressionBudget (M : ℕ) : ℕ :=
expressionBudget M (intermediateWidthBound M) (registerReadBound M)
def entryCostBound (M : ℕ) : ℕ :=
20 * generatorExpressionBudget M + intermediateWidthBound M + 20
def entryOutputBound (M : ℕ) : ℕ := intermediateWidthBound M + 3
private theorem bounded_dimensionExpr {environment : List ℕ} {M nr sr n s : ℕ}
(hM : 2 ≤ M) (hlen : environment.length ≤ 5)
(henv : ∀ a ∈ environment, a ≤ M) (hnr : nr ≤ 4) (hsr : sr ≤ 4)
(hnread : environment[nr]?.getD 0 = n) (hsread : environment[sr]?.getD 0 = s)
(hn : n ≤ M) (hs : s ≤ M) :
(dimensionExpr nr sr).Bounded environment M
(intermediateWidthBound M) (registerReadBound M) := by
have htwo := Expr.bounded_literal (environment := environment) hM
have hnvar := Expr.bounded_read hlen hnr henv
have hsvar := Expr.bounded_read hlen hsr henv
have hsn : s.size ≤ M := (size_le_self s).trans hs
have hwn : width n ≤ M + 1 := width_le_of_le hn
have hws2 : width (s ^ 2) ≤ 2 + 2 * M := by
have h := width_pow_le s 2
omega
have hw2n : width (2 * n) ≤ M + 4 := by
have h := width_mul_le 2 n
have ht : width 2 = 3 := rfl
omega
have hp : (Expr.power (.read sr) (.literal 2)).Bounded environment M
(intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, hsvar, htwo, ?_, ?_⟩
· simp only [Expr.run, powerRun_value, hsread]
unfold intermediateWidthBound
omega
· simpa only [Expr.run, hsread] using hs
· exact hM
have hleft : (Expr.mul (.literal 2) (.read nr)).Bounded environment M
(intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, htwo, hnvar⟩
simp only [Expr.run, hnread]
unfold intermediateWidthBound
omega
refine ⟨?_, hleft, hp⟩
have hw := width_mul_le (2 * n) (s ^ 2)
simp only [Expr.run, powerRun_value, hnread, hsread]
unfold intermediateWidthBound
omega
theorem dimensionExpr_cost_le {environment : List ℕ} {M nr sr n s : ℕ}
(hM : 2 ≤ M) (hlen : environment.length ≤ 5)
(henv : ∀ a ∈ environment, a ≤ M) (hnr : nr ≤ 4) (hsr : sr ≤ 4)
(hnread : environment[nr]?.getD 0 = n) (hsread : environment[sr]?.getD 0 = s)
(hn : n ≤ M) (hs : s ≤ M) :
((dimensionExpr nr sr).run environment).cost ≤ 7 * generatorExpressionBudget M := by
have h := Expr.cost_le_nodes_budget environment M (intermediateWidthBound M)
(registerReadBound M) (dimensionExpr nr sr)
(bounded_dimensionExpr hM hlen henv hnr hsr hnread hsread hn hs)
simpa [dimensionExpr, Expr.nodes, generatorExpressionBudget] using h
private theorem bounded_entryExpressions {M q r i n s : ℕ}
(hM : 2 ≤ M) (hq : q ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
(hn : n ≤ M) (hs : s ≤ M) :
let environment := [q, r, i, n, s]
let bounded := fun e : Expr => e.Bounded environment M
(intermediateWidthBound M) (registerReadBound M)
bounded (.less (.read 0) (.read 1)) ∧
bounded (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1))) ∧
bounded (.mul (.read 1) (.power (.add (.read 2) (.literal 1))
(.sub (.read 1) (.read 0)))) := by
dsimp only
have henv : ∀ a ∈ [q, r, i, n, s], a ≤ M := by
intro a ha
simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
rcases ha with rfl | rfl | rfl | rfl | rfl <;> omega
have hqv := Expr.bounded_read (environment := [q, r, i, n, s])
(index := 0) (by simp) (by omega) henv
have hrv := Expr.bounded_read (environment := [q, r, i, n, s])
(index := 1) (by simp) (by omega) henv
have hiv := Expr.bounded_read (environment := [q, r, i, n, s])
(index := 2) (by simp) (by omega) henv
have hone := Expr.bounded_literal (environment := [q, r, i, n, s])
(a := 1) (by omega : 1 ≤ M)
have hsub : (Expr.sub (.read 1) (.read 0)).Bounded [q, r, i, n, s] M
(intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, hrv, hqv⟩
simpa [Expr.run] using small_width (by omega : r - q ≤ M)
have hsubone : (Expr.sub (.sub (.read 1) (.read 0)) (.literal 1)).Bounded
[q, r, i, n, s] M (intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, hsub, hone⟩
simpa [Expr.run] using small_width (by omega : r - q - 1 ≤ M)
have hadd : (Expr.add (.read 2) (.literal 1)).Bounded [q, r, i, n, s] M
(intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, hiv, hone⟩
simpa [Expr.run] using small_width hi
have hpwidth : width ((i + 1) ^ (r - q)) ≤ 2 + M * M := by
have h := width_pow_le (i + 1) (r - q)
have hsiz : (i + 1).size ≤ M := (size_le_self (i + 1)).trans hi
have hm := Nat.mul_le_mul (by omega : r - q ≤ M) hsiz
omega
have hp : (Expr.power (.add (.read 2) (.literal 1))
(.sub (.read 1) (.read 0))).Bounded [q, r, i, n, s] M
(intermediateWidthBound M) (registerReadBound M) := by
refine ⟨?_, hadd, hsub, ?_, ?_⟩
· simp only [Expr.run, List.getElem?_cons_zero, List.getElem?_cons_succ,
Option.getD_some, powerRun_value]
unfold intermediateWidthBound
omega
· simpa [Expr.run] using hi
· simpa [Expr.run] using (by omega : r - q ≤ M)
refine ⟨?_, ?_, ?_⟩
· refine ⟨?_, hqv, hrv⟩
have hw : width (if q < r then (1 : ℕ) else 0) ≤ 2 := by
by_cases hqr : q < r <;> simp [hqr, width]
have hb : 2 ≤ intermediateWidthBound M := by unfold intermediateWidthBound; omega
simpa [Expr.run] using hw.trans hb
· refine ⟨?_, hsubone⟩
simpa [Expr.run] using
small_width (by have := Nat.mod_lt (r - q - 1) (by decide : 0 < 2); omega :
(r - q - 1) % 2 ≤ M)
· refine ⟨?_, hrv, hp⟩
have hw := width_mul_le r ((i + 1) ^ (r - q))
have hrw := width_le_of_le hr
simp only [Expr.run, List.getElem?_cons_zero, List.getElem?_cons_succ,
Option.getD_some, powerRun_value]
unfold intermediateWidthBound
omega
theorem entryProgram_bounds {M q r i n s : ℕ}
(hM : 2 ≤ M) (hq : q ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
(hn : n ≤ M) (hs : s ≤ M) :
(entryProgram.run [q, r, i, n, s]).cost ≤ entryCostBound M ∧
outputBits (entryProgram.run [q, r, i, n, s]).output ≤ entryOutputBound M := by
let environment := [q, r, i, n, s]
let condition : Expr := .less (.read 0) (.read 1)
let sign : Expr := .odd (.sub (.sub (.read 1) (.read 0)) (.literal 1))
let denominator : Expr := .mul (.read 1) (.power (.add (.read 2) (.literal 1))
(.sub (.read 1) (.read 0)))
let positive : Program := .emit sign (.literal 1) denominator
let zero : Program := .emit (.literal 0) (.literal 0) (.literal 1)
let E := generatorExpressionBudget M
let B := intermediateWidthBound M
have hE : 10 ≤ E := by unfold E generatorExpressionBudget expressionBudget; omega
have hB : 1 ≤ B := by unfold B intermediateWidthBound; omega
obtain ⟨hcondition, hsign, hdenominator⟩ := bounded_entryExpressions hM hq hr hi hn hs
have hc : (condition.run environment).cost ≤ 3 * E := by
have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) condition hcondition
simpa [condition, Expr.nodes, E, B, generatorExpressionBudget] using h
have hsc : (sign.run environment).cost ≤ 6 * E := by
have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) sign hsign
simpa [sign, Expr.nodes, E, B, generatorExpressionBudget] using h
have hdc : (denominator.run environment).cost ≤ 9 * E := by
have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) denominator hdenominator
simpa [denominator, Expr.nodes, E, B, generatorExpressionBudget] using h
have hdw : width (denominator.run environment).value ≤ B :=
Expr.bounded_width hdenominator
have hlc : ((Expr.literal 1).run environment).cost ≤ E := by
change 3 ≤ E
omega
have hlw : width ((Expr.literal 1).run environment).value ≤ 2 := by
simp [Expr.run, width]
have hpc : (positive.run environment).cost ≤ 17 * E + B + 10 := by
have h := emit_cost_le environment sign (.literal 1) denominator
(6 * E) E (9 * E) 2 B hsc hlc hdc hlw hdw
change (positive.run environment).cost ≤ _ at h
omega
have hpo : outputBits (positive.run environment).output ≤ B + 3 := by
have h := emit_outputBits_le environment sign (.literal 1) denominator 2 B hlw hdw
simpa [positive, Nat.add_comm, Nat.add_left_comm, Nat.add_assoc] using h
have hzc : (zero.run environment).cost ≤ 17 * E + B + 10 := by
simp only [zero, Program.run, Expr.run, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
omega
have hzo : outputBits (zero.run environment).output ≤ B + 3 := by
simp only [zero, Program.run, Expr.run, outputBits, List.map_cons, List.map_nil,
List.sum_cons, List.sum_nil, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
omega
have hcost := branch_cost_le environment condition positive zero (3 * E)
(17 * E + B + 10) hc hpc hzc
have houtput := branch_outputBits_le environment condition positive zero (B + 3) hpo hzo
change (entryProgram.run environment).cost ≤ _ at hcost
change outputBits (entryProgram.run environment).output ≤ _ at houtput
constructor
· unfold entryCostBound
change (entryProgram.run environment).cost ≤ 20 * E + B + 20
omega
· exact houtput
def rowCostBound (M d : ℕ) : ℕ :=
7 * generatorExpressionBudget M + 1 +
d * (entryCostBound M + loopControlBound M + entryOutputBound M)
def rowOutputBound (M d : ℕ) : ℕ := d * entryOutputBound M
def variableCostBound (M d : ℕ) : ℕ :=
7 * generatorExpressionBudget M + 1 +
d * (rowCostBound M d + loopControlBound M + rowOutputBound M d)
def variableOutputBound (M d : ℕ) : ℕ := d * rowOutputBound M d
theorem rowProgram_bounds {M r i n s : ℕ}
(hM : 2 ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
(hn : n ≤ M) (hs : s ≤ M) (hd : 2 * n * s ^ 2 ≤ M) :
(rowProgram.run [r, i, n, s]).cost ≤ rowCostBound M (2 * n * s ^ 2) ∧
outputBits (rowProgram.run [r, i, n, s]).output ≤
rowOutputBound M (2 * n * s ^ 2) := by
have henv : ∀ a ∈ [r, i, n, s], a ≤ M := by
intro a ha
simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
rcases ha with rfl | rfl | rfl | rfl <;> omega
have hv : ((dimensionExpr 2 3).run [r, i, n, s]).value = 2 * n * s ^ 2 := by
simp [dimensionExpr, Expr.run]
have hc := dimensionExpr_cost_le (environment := [r, i, n, s])
(nr := 2) (sr := 3) hM (by simp) henv (by omega) (by omega) rfl rfl hn hs
have hb : ∀ q < ((dimensionExpr 2 3).run [r, i, n, s]).value,
(entryProgram.run (q :: [r, i, n, s])).cost ≤ entryCostBound M ∧
outputBits (entryProgram.run (q :: [r, i, n, s])).output ≤ entryOutputBound M := by
intro q hq
rw [hv] at hq
exact entryProgram_bounds hM (by omega) hr hi hn hs
constructor
· have h := loop_cost_le [r, i, n, s] (dimensionExpr 2 3) entryProgram M
(7 * generatorExpressionBudget M) (entryCostBound M) (entryOutputBound M)
(by rw [hv]; exact hd) hc hb
simpa only [rowProgram, rowCostBound, hv] using h
· have h := loop_outputBits_le [r, i, n, s] (dimensionExpr 2 3) entryProgram
(entryOutputBound M) (fun q hq => (hb q hq).2)
simpa only [rowProgram, rowOutputBound, hv] using h
theorem variableProgram_bounds {M i n s : ℕ}
(hM : 2 ≤ M) (hi : i + 1 ≤ M)
(hn : n ≤ M) (hs : s ≤ M) (hd : 2 * n * s ^ 2 ≤ M) :
(variableProgram.run [i, n, s]).cost ≤ variableCostBound M (2 * n * s ^ 2) ∧
outputBits (variableProgram.run [i, n, s]).output ≤
variableOutputBound M (2 * n * s ^ 2) := by
have henv : ∀ a ∈ [i, n, s], a ≤ M := by
intro a ha
simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
rcases ha with rfl | rfl | rfl <;> omega
have hv : ((dimensionExpr 1 2).run [i, n, s]).value = 2 * n * s ^ 2 := by
simp [dimensionExpr, Expr.run]
have hc := dimensionExpr_cost_le (environment := [i, n, s])
(nr := 1) (sr := 2) hM (by simp) henv (by omega) (by omega) rfl rfl hn hs
have hb : ∀ r < ((dimensionExpr 1 2).run [i, n, s]).value,
(rowProgram.run (r :: [i, n, s])).cost ≤ rowCostBound M (2 * n * s ^ 2) ∧
outputBits (rowProgram.run (r :: [i, n, s])).output ≤
rowOutputBound M (2 * n * s ^ 2) := by
intro r hr
rw [hv] at hr
exact rowProgram_bounds hM (by omega) hi hn hs hd
constructor
· have h := loop_cost_le [i, n, s] (dimensionExpr 1 2) rowProgram M
(7 * generatorExpressionBudget M) (rowCostBound M (2 * n * s ^ 2))
(rowOutputBound M (2 * n * s ^ 2)) (by rw [hv]; exact hd) hc hb
simpa only [variableProgram, variableCostBound, hv] using h
· have h := loop_outputBits_le [i, n, s] (dimensionExpr 1 2) rowProgram
(rowOutputBound M (2 * n * s ^ 2)) (fun r hr => (hb r hr).2)
simpa only [variableProgram, variableOutputBound, hv] using h
def generatorCostBound (n s : ℕ) : ℕ :=
let d := 2 * n * s ^ 2
let M := n + s + d + 3
2 * (M + 1) + 7 * generatorExpressionBudget M + 15 +
(registerReadBound M + 1 +
n * (variableCostBound M d + loopControlBound M + variableOutputBound M d)) + 1
theorem generate_cost_le (n s : ℕ) : (generate n s).cost ≤ generatorCostBound n s := by
let d := 2 * n * s ^ 2
let M := n + s + d + 3
let E := generatorExpressionBudget M
let B := intermediateWidthBound M
let R := registerReadBound M
let C := R + 1 + n * (variableCostBound M d + loopControlBound M + variableOutputBound M d)
have hM : 2 ≤ M := by unfold M; omega
have hn : n ≤ M := by unfold M; omega
have hs : s ≤ M := by unfold M; omega
have hd : d ≤ M := by unfold M; omega
have hB : 4 ≤ B := by unfold B intermediateWidthBound; omega
have henv : ∀ a ∈ [n, s], a ≤ M := by
intro a ha
simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
rcases ha with rfl | rfl <;> assumption
have hnr := Expr.bounded_read (environment := [n, s]) (index := 0)
(by simp) (by omega) henv
have hsr := Expr.bounded_read (environment := [n, s]) (index := 1)
(by simp) (by omega) henv
have h1 := Expr.bounded_literal (environment := [n, s]) (a := 1) (by omega : 1 ≤ M)
have hwif (a : ℕ) : width (if a = 1 then 1 else 0) ≤ 2 := by
split <;> decide
have hnt : (Expr.equal (.read 0) (.literal 1)).Bounded [n, s] M B R := by
refine ⟨?_, hnr, h1⟩
have h := (hwif n).trans (by omega : 2 ≤ B)
simpa [Expr.run] using h
have hst : (Expr.equal (.read 1) (.literal 1)).Bounded [n, s] M B R := by
refine ⟨?_, hsr, h1⟩
have h := (hwif s).trans (by omega : 2 ≤ B)
simpa [Expr.run] using h
let test : Expr := .mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1))
have ht : test.Bounded [n, s] M B R := by
refine ⟨?_, hnt, hst⟩
have h := width_mul_le (if n = 1 then 1 else 0) (if s = 1 then 1 else 0)
have hnv := hwif n
have hsv := hwif s
have hw : width ((if n = 1 then 1 else 0) * (if s = 1 then 1 else 0)) ≤ B := by omega
simpa [test, Expr.run] using hw
have htc : (test.run [n, s]).cost ≤ 7 * E := by
have h := Expr.cost_le_nodes_budget [n, s] M B R test ht
simpa [test, Expr.nodes, E, B, R, generatorExpressionBudget] using h
have hloop : ((Program.loop (.read 0) variableProgram).run [n, s]).cost ≤ C := by
have hc : ((Expr.read 0).run [n, s]).cost ≤ R := hnr.2
have hb : ∀ i < ((Expr.read 0).run [n, s]).value,
(variableProgram.run (i :: [n, s])).cost ≤ variableCostBound M d ∧
outputBits (variableProgram.run (i :: [n, s])).output ≤ variableOutputBound M d := by
intro i hi
change i < n at hi
exact variableProgram_bounds hM (by omega) hn hs hd
have h := loop_cost_le [n, s] (.read 0) variableProgram M R
(variableCostBound M d) (variableOutputBound M d) hn hc hb
exact h
have hexception : ((Program.emit (.literal 0) (.literal 1) (.literal 1)).run [n, s]).cost ≤ 15 + C := by
simp only [Program.run, Expr.run, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
omega
have hbranch := branch_cost_le [n, s] test
(.emit (.literal 0) (.literal 1) (.literal 1)) (.loop (.read 0) variableProgram)
(7 * E) (15 + C) htc hexception (by omega)
change (generatorProgram.run [n, s]).cost ≤ _ at hbranch
have hinput : listBits [n, s] ≤ 2 * (M + 1) := by
have hnw := width_le_of_le hn
have hsw := width_le_of_le hs
simp only [listBits, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil, Nat.add_zero]
omega
change listBits [n, s] + (generatorProgram.run [n, s]).cost ≤ _
change _ ≤ 2 * (M + 1) + 7 * E + 15 + C + 1
omega
end NCHitting
end OAI