| import OAI.Computability.WLIdentification.PolynomialArithmetic |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
|
|
| namespace NumericFinite |
|
|
| def elements (b : ℕ) (p : ℕ → Bool) : List ℕ := (List.range b).filter p |
| def count (b : ℕ) (p : ℕ → Bool) : ℕ := (elements b p).length |
|
|
| @[simp] theorem elements_zero (p : ℕ → Bool) : elements 0 p = [] := rfl |
| @[simp] theorem elements_succ (b : ℕ) (p : ℕ → Bool) : |
| elements (b+1) p = elements b p ++ if p b then [b] else [] := by |
| simp only [elements, List.range_succ, List.filter_append] |
| cases hb : p b <;> simp [hb] |
|
|
| @[simp] theorem count_zero (p : ℕ → Bool) : count 0 p = 0 := rfl |
| @[simp] theorem count_succ (b : ℕ) (p : ℕ → Bool) : |
| count (b+1) p = count b p + if p b then 1 else 0 := by |
| simp only [count, elements_succ, List.length_append] |
| cases p b <;> rfl |
|
|
| theorem mem_elements {b v : ℕ} {p : ℕ → Bool} : v ∈ elements b p ↔ v < b ∧ p v = true := by |
| simp [elements, and_comm] |
|
|
| theorem count_mono (p : ℕ → Bool) {a b : ℕ} (h : a ≤ b) : count a p ≤ count b p := by |
| induction h with |
| | refl => rfl |
| | @step b h ih => rw [count_succ]; omega |
|
|
| theorem count_strict {p : ℕ → Bool} {a b : ℕ} (h : a < b) (ha : p a = true) : |
| count a p < count b p := by |
| have hh := count_mono p h |
| rw [count_succ, ha] at hh |
| simp only [↓reduceIte] at hh |
| omega |
|
|
| theorem rank (b : ℕ) (p : ℕ → Bool) (j : ℕ) (hj : j < (elements b p).length) : |
| count (elements b p)[j] p = j := by |
| induction b with |
| | zero => simp at hj |
| | succ b ih => |
| by_cases hp : p b = true |
| · have he : elements (b+1) p = elements b p ++ [b] := by simp [hp] |
| simp only [he, List.length_append, List.length_singleton] at hj |
| simp only [he] |
| by_cases hh : j < (elements b p).length |
| · rw [List.getElem_append_left hh] |
| exact ih hh |
| · have hj' : j = (elements b p).length := by omega |
| subst j |
| simp [count] |
| · have he : elements (b+1) p = elements b p := by simp [hp] |
| simp only [he] |
| exact ih (by simpa only [he] using hj) |
|
|
| def select (b : ℕ) (p : ℕ → Bool) (j : ℕ) : ℕ := |
| Nat.findGreatest (fun i => i < b ∧ p i = true ∧ count i p = j) b |
|
|
| theorem select_correct (b : ℕ) (p : ℕ → Bool) (j : ℕ) (hj : j < (elements b p).length) : |
| select b p j = (elements b p)[j] := by |
| let v := (elements b p)[j] |
| have hv : v < b ∧ p v = true := mem_elements.mp (List.getElem_mem hj) |
| have hr : count v p = j := rank b p j hj |
| apply Nat.findGreatest_eq_iff.mpr |
| refine ⟨by omega, fun _ => ⟨hv.1,hv.2,hr⟩, ?_⟩ |
| intro i hi _ hh |
| have hlt := count_strict (p := p) hi hv.2 |
| exact (ne_of_gt hlt) (hh.2.2.trans hr.symm) |
|
|
| end NumericFinite |
| namespace WordExpressions.NatPoly |
| variable {n : ℕ} |
|
|
| theorem filterCount {b : (Fin n → Word) → ℕ} {p : (Fin (n+1) → Word) → Bool} |
| (hb : NatPoly b) (hp : BoolPoly p) : |
| NatPoly (fun S => NumericFinite.count (b S) (fun i => p (Fin.snoc S (unary i)))) := by |
| apply (sum hb (ite hp (const 1) (const 0))).congr |
| intro S |
| dsimp only |
| congr 1 |
| generalize b S = k |
| induction k with |
| | zero => rfl |
| | succ k ih => simp only [List.sum_range_succ, ih, NumericFinite.count_succ] |
|
|
| end WordExpressions.NatPoly |
| namespace WordExpressions.NatPoly |
| variable {n : ℕ} |
|
|
| theorem filterSelect {b j : (Fin n → Word) → ℕ} {p : (Fin (n+1) → Word) → Bool} |
| (hb : NatPoly b) (hj : NatPoly j) (hp : BoolPoly p) : |
| NatPoly (fun S => NumericFinite.select (b S) (fun i => p (Fin.snoc S (unary i))) (j S)) := by |
| have hp' : BoolPoly (fun T : Fin (n+2) → Word => |
| p (Fin.snoc (T ∘ Fin.castSucc ∘ Fin.castSucc) (T (Fin.last (n+1))))) := |
| Poly.applyWord hp (Fin.castSucc ∘ Fin.castSucc) (Poly.var _) |
| have hc := filterCount (var (Fin.last n)) hp' |
| have htest := BoolPoly.and (lt (var (Fin.last n)) (rename hb Fin.castSucc)) |
| (BoolPoly.and hp (eqtest hc (rename hj Fin.castSucc))) |
| apply (findGreatest hb htest).congr |
| intro S |
| dsimp only [NumericFinite.select] |
| congr 2 |
| funext i |
| simp only [Fin.snoc_last, unary, List.length_replicate, snoc_prefix, |
| Bool.and_eq_true, decide_eq_true_eq] |
| simp only [Function.comp_def, Fin.snoc_castSucc] |
|
|
| end WordExpressions.NatPoly |
|
|
| namespace WordExpressions.Expr |
| open StackModel.Command ComputationBounds |
|
|
| def decisionBound {n} (e : Expr n) (B : ℕ) : ℕ := |
| 2+(e.cost B+15*B+15)*(2*(B+(e.cost B+15*B+15))+3) |
|
|
| theorem decisionBound_polynomial {n} (e : Expr n) : Polynomial e.decisionBound := by |
| have h := add (add e.cost_polynomial (mul (constant 15) identity)) (constant 15) |
| exact add (constant 2) (mul h (add (mul (constant 2) (add identity h)) (constant 3))) |
|
|
| / |
| Rejection is a literal rejecting state, including on malformed words. -/ |
| theorem decides (e : Expr 1) (B : ℕ → ℕ) |
| (hw : ∀ n, n ≤ B n) (h : ∀ w, e.Bounded (fun _ => w) (B w.length)) : |
| ∃ M : Machine, DecidesWithin M {w | (e.eval (fun _ => w)).getLast?.getD false = true} |
| (fun n => e.decisionBound (B n)) := by |
| obtain ⟨N,hN,hsmall⟩ := e.outputCode.small_exists |
| let c := e.outputCode.rename (finiteIndex N (by omega)) |
| let input : Fin N := finiteIndex N (by omega) 0 |
| let P := c.testProgram none input |
| refine ⟨StackModel.compile P input, ?_⟩ |
| intro w |
| obtain ⟨t,ht,he⟩ := e.outputCode_exec w (B w.length) (hw _) (h w) |
| have he' := he.restrict N (by omega) hsmall |
| simp only [restrict_update (show 0 < N by omega) (show 0 < N by omega)] at he' |
| have hs : (fun _ : ℕ => ([] : Word)) ∘ Fin.val = fun _ : Fin N => [] := rfl |
| rw [hs] at he' |
| have hr := he'.testRun input input w rfl |
| simp only [input, Function.update_self] at hr |
| change (StackModel.run P input w (3+t)).control = |
| .inl ((e.eval (fun _ => w)).getLast?.getD false) at hr |
| obtain ⟨T,hT,hTe⟩ := StackModel.run_execution P input w (3+t) |
| refine ⟨T, ?_, ?_, ?_⟩ |
| · apply hT.trans |
| dsimp only [decisionBound] |
| have htp : 3+t ≤ e.cost (B w.length)+15*(B w.length)+15 := by omega |
| have hn := hw w.length |
| gcongr |
| · rw [hTe] |
| simp only [Halted, StackModel.encodeConfig, hr] |
| cases hb : (e.eval (fun _ => w)).getLast?.getD false <;> simp |
| · rw [hTe] |
| simp only [StackModel.encodeConfig, hr, Set.mem_ofPred_eq] |
| cases hb : (e.eval (fun _ => w)).getLast?.getD false <;> simp |
| change ¬(2 : Fin ((StackModel.compile P input).extraStates+3)) = 1 |
| intro heq |
| have hv := congrArg Fin.val heq |
| change 2 % ((StackModel.compile P input).extraStates+3) = |
| 1 % ((StackModel.compile P input).extraStates+3) at hv |
| have h1 : 1 < (StackModel.compile P input).extraStates+3 := by omega |
| have h2 : 2 < (StackModel.compile P input).extraStates+3 := by omega |
| rw [Nat.mod_eq_of_lt h2, Nat.mod_eq_of_lt h1] at hv |
| omega |
|
|
| end WordExpressions.Expr |
| namespace ComputationBounds |
|
|
| / |
| def Exponential (f : ℕ → ℕ) : Prop := ∃ C d : ℕ, ∀ n, f n ≤ 2^(C*(n+1)^d) |
|
|
| theorem power {f : ℕ → ℕ} (hf : Polynomial f) (d : ℕ) : Polynomial (fun n => (f n)^d) := by |
| induction d with |
| | zero => simpa using constant 1 |
| | succ d ih => simpa only [pow_succ] using mul ih hf |
|
|
| theorem exp_dominates {f g : ℕ → ℕ} (hf : Exponential f) (h : ∀ n, g n ≤ f n) : Exponential g := by |
| obtain ⟨C,d,hf⟩ := hf |
| exact ⟨C,d,fun n => (h n).trans (hf n)⟩ |
|
|
| theorem two_pow {f : ℕ → ℕ} (hf : Polynomial f) : Exponential (fun n => 2^(f n)) := by |
| obtain ⟨C,d,hf⟩ := hf |
| exact ⟨C,d,fun n => Nat.pow_le_pow_right (by decide) (hf n)⟩ |
|
|
| theorem polynomial_exponential {f : ℕ → ℕ} (hf : Polynomial f) : Exponential f := |
| exp_dominates (two_pow hf) (fun _ => (Nat.lt_two_pow_self).le) |
|
|
| theorem exp_constant (c : ℕ) : Exponential (fun _ => c) := polynomial_exponential (constant c) |
|
|
| theorem exp_identity : Exponential id := polynomial_exponential identity |
|
|
| theorem exp_add {f g : ℕ → ℕ} (hf : Exponential f) (hg : Exponential g) : |
| Exponential (fun n => f n+g n) := by |
| obtain ⟨C,d,hf⟩ := hf |
| obtain ⟨D,e,hg⟩ := hg |
| let p := fun n => C*(n+1)^d |
| let q := fun n => D*(n+1)^e |
| have hp : Polynomial p := ⟨C,d,fun _ => le_rfl⟩ |
| have hq : Polynomial q := ⟨D,e,fun _ => le_rfl⟩ |
| apply exp_dominates (two_pow (add (add hp hq) (constant 1))) |
| intro n |
| have ha : f n ≤ 2^(p n+q n) := (hf n).trans (Nat.pow_le_pow_right (by decide) (Nat.le_add_right (p n) (q n))) |
| have hb : g n ≤ 2^(p n+q n) := (hg n).trans (Nat.pow_le_pow_right (by decide) (Nat.le_add_left (q n) (p n))) |
| change f n+g n ≤ 2^(p n+q n+1) |
| rw [pow_succ] |
| omega |
|
|
| theorem exp_mul {f g : ℕ → ℕ} (hf : Exponential f) (hg : Exponential g) : |
| Exponential (fun n => f n*g n) := by |
| obtain ⟨C,d,hf⟩ := hf |
| obtain ⟨D,e,hg⟩ := hg |
| have hp : Polynomial (fun n => C*(n+1)^d) := ⟨C,d,fun _ => le_rfl⟩ |
| have hq : Polynomial (fun n => D*(n+1)^e) := ⟨D,e,fun _ => le_rfl⟩ |
| apply exp_dominates (two_pow (add hp hq)) |
| intro n |
| simpa only [pow_add] using Nat.mul_le_mul (hf n) (hg n) |
|
|
| theorem exp_power {f : ℕ → ℕ} (hf : Exponential f) (d : ℕ) : Exponential (fun n => (f n)^d) := by |
| induction d with |
| | zero => simpa using exp_constant 1 |
| | succ d ih => simpa only [pow_succ] using exp_mul ih hf |
|
|
| theorem polynomial_exp_comp {f g : ℕ → ℕ} (hf : Polynomial f) (hg : Exponential g) : |
| Exponential (fun n => f (g n)) := by |
| obtain ⟨C,d,hf⟩ := hf |
| exact exp_dominates (exp_mul (exp_constant C) (exp_power (exp_add hg (exp_constant 1)) d)) |
| (fun n => hf (g n)) |
|
|
| end ComputationBounds |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
