| import Mathlib |
| import OAI.Computability.MaxCut.Estimates.Put |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace OptimalMaxCut.CounterMachine.Expr |
| open scoped BigOperators |
| open Finset |
|
|
| def rename (ρ : ℕ → ℕ) : Expr → Expr |
| | .const n => .const n |
| | .arg i => .arg (ρ i) |
| | .length => .length |
| | .bit e => .bit (rename ρ e) |
| | .add a b => .add (rename ρ a) (rename ρ b) |
| | .sub a b => .sub (rename ρ a) (rename ρ b) |
| | .mul a b => .mul (rename ρ a) (rename ρ b) |
| | .zero a => .zero (rename ρ a) |
| | .sum b f => .sum (rename ρ b) (rename (bind (fun i => ρ i+1) 0) f) |
|
|
| @[simp] theorem rename_eval (e : Expr) (ρ : ℕ → ℕ) (input : List Bool) (args : ℕ → ℕ) : |
| (e.rename ρ).eval input args = e.eval input (fun i => args (ρ i)) := by |
| induction e generalizing ρ args <;> simp only [rename, eval] at * |
| all_goals try simp_all |
| case sum b f ib iF => |
| apply sum_congr rfl |
| intro i hi |
| congr 1 |
| funext j |
| cases j <;> rfl |
|
|
| def bindExpr (σ : ℕ → Expr) (e : Expr) : ℕ → Expr |
| | 0 => e |
| | i+1 => σ i |
|
|
| def subst (σ : ℕ → Expr) : Expr → Expr |
| | .const n => .const n |
| | .arg i => σ i |
| | .length => .length |
| | .bit e => .bit (subst σ e) |
| | .add a b => .add (subst σ a) (subst σ b) |
| | .sub a b => .sub (subst σ a) (subst σ b) |
| | .mul a b => .mul (subst σ a) (subst σ b) |
| | .zero a => .zero (subst σ a) |
| | .sum b f => .sum (subst σ b) (subst (bindExpr (fun i => (σ i).rename Nat.succ) (.arg 0)) f) |
|
|
| @[simp] theorem subst_eval (e : Expr) (σ : ℕ → Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (e.subst σ).eval input args = e.eval input (fun i => (σ i).eval input args) := by |
| induction e generalizing σ args <;> simp only [subst, eval] at * |
| all_goals try simp_all |
| case sum b f ib iF => |
| apply sum_congr rfl |
| intro i hi |
| congr 1 |
| funext j |
| cases j with |
| | zero => rfl |
| | succ j => simp [bindExpr, bind] |
|
|
| def positive (a : Expr) : Expr := .zero (.zero a) |
| def equal (a b : Expr) : Expr := .zero (.add (.sub a b) (.sub b a)) |
| def le (a b : Expr) : Expr := .zero (.sub a b) |
| def lt (a b : Expr) : Expr := le (.add a (.const 1)) b |
|
|
| @[simp] theorem positive_eval (a : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (positive a).eval input args = if a.eval input args ≠ 0 then 1 else 0 := by |
| simp [positive, eval] |
|
|
| @[simp] theorem equal_eval (a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (equal a b).eval input args = if a.eval input args = b.eval input args then 1 else 0 := by |
| by_cases h : a.eval input args = b.eval input args |
| · simp only [equal, eval, h, Nat.sub_self, Nat.zero_add, ↓reduceIte] |
| · have hn : a.eval input args-b.eval input args+(b.eval input args-a.eval input args) ≠ 0 := by omega |
| simp only [equal, eval, ite_eq_right h] |
| exact ite_eq_right hn |
|
|
| @[simp] theorem le_eval (a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (le a b).eval input args = if a.eval input args ≤ b.eval input args then 1 else 0 := by |
| simp [le, eval, Nat.sub_eq_zero_iff_le] |
|
|
| @[simp] theorem lt_eval (a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (lt a b).eval input args = if a.eval input args < b.eval input args then 1 else 0 := by |
| simp [lt, eval] |
|
|
| def cond (c a b : Expr) : Expr := .add (.mul (positive c) a) (.mul (.zero c) b) |
| @[simp] theorem cond_eval (c a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (cond c a b).eval input args = if c.eval input args ≠ 0 then a.eval input args else b.eval input args := by |
| simp only [cond, eval, positive_eval]; split_ifs <;> simp_all |
|
|
| def quotient (a b : Expr) : Expr := |
| .mul (positive b) (.sum a (le (.mul (.add (.arg 0) (.const 1)) (b.rename Nat.succ)) (a.rename Nat.succ))) |
|
|
| theorem quotient_sum (a b : ℕ) (hb : 0 < b) : |
| (∑ i ∈ range a, if (i+1)*b ≤ a then (1:ℕ) else 0) = a/b := by |
| have hcond (i : ℕ) : (i+1)*b ≤ a ↔ i < a/b := by |
| rw [← Nat.le_div_iff_mul_le hb, Nat.add_one_le_iff] |
| simp_rw [hcond] |
| rw [sum_boole] |
| have hs : {i ∈ range a | i < a/b} = range (a/b) := by |
| ext i; simp only [mem_filter, mem_range] |
| exact and_iff_right_of_imp (fun hi => hi.trans_le (Nat.div_le_self _ _)) |
| simp only [hs, card_range, Nat.cast_id] |
|
|
| @[simp] theorem quotient_eval (a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (quotient a b).eval input args = a.eval input args / b.eval input args := by |
| simp only [quotient, eval, positive_eval, le_eval, rename_eval, bind] |
| by_cases hb : b.eval input args = 0 |
| · simp [hb] |
| · simp only [hb, ne_eq, not_false_eq_true, ↓reduceIte, one_mul] |
| simpa using quotient_sum (a.eval input args) (b.eval input args) (by omega) |
|
|
| def remainder (a b : Expr) : Expr := .sub a (.mul (quotient a b) b) |
| @[simp] theorem remainder_eval (a b : Expr) (input : List Bool) (args : ℕ → ℕ) : |
| (remainder a b).eval input args = a.eval input args % b.eval input args := by |
| simp only [remainder, eval, quotient_eval] |
| exact Nat.mod_eq_sub_div_mul.symm |
|
|
| def power (a : Expr) : ℕ → Expr |
| | 0 => .const 1 |
| | n+1 => .mul (power a n) a |
| @[simp] theorem power_eval (a : Expr) (n : ℕ) (input : List Bool) (args : ℕ → ℕ) : |
| (power a n).eval input args = (a.eval input args)^n := by |
| induction n <;> simp [power, eval, pow_succ, *] |
|
|
| end OptimalMaxCut.CounterMachine.Expr |
|
|
| end |
|
|
| end OAI |
|
|
