lean/OAI/Algebra/FormulaHitting/GeneratorCost.lean

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