| import OAI.Computability.MatchingCount.SelectRoutine |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.StackCode |
| open Polynomial |
|
|
| def unary (n : ℕ) : List Bool := List.replicate n true |
| @[simp] lemma unary_length (n : ℕ) : (unary n).length=n := by simp [unary] |
| @[simp] lemma unary_reverse (n : ℕ) : (unary n).reverse=unary n := by simp [unary] |
| @[simp] lemma unary_zero : unary 0=[] := rfl |
| @[simp] lemma unary_succ (n : ℕ) : unary (n+1)=true::unary n := by simp [unary,List.replicate_succ] |
|
|
| namespace Routine |
| variable {α : Type} {ea : α → List Bool} {f : α → α} |
|
|
| lemma iterate_runs_at (p : Routine ea ea f) {R : ℕ} |
| (ι : Fin (p.scratch+1) → Fin R) (hι : Function.Injective ι) |
| (counter : Fin R) (hc : ∀ i,ι i≠counter) (B n : ℕ) (a : α) (s : Store R) |
| (hin : s (ι 0)=ea a) (hclean : ∀ i,i≠0 → s (ι i)=[]) (hcount : s counter=unary n) |
| (hb : ∀ j≤n,(ea (f^[j] a)).length≤B) : |
| ∃ t≤n*(p.time.eval B+2)+1, |
| (Block.loop counter ((Block.pop counter).seq (p.block.rename ι))).Runs s |
| (Function.update (Function.update s counter []) (ι 0) (ea (f^[n] a))) t := by |
| induction n generalizing a s with |
| | zero => |
| have he : Function.update (Function.update s counter []) (ι 0) (ea (f^[0] a))=s := by |
| simp only [Function.iterate_zero, id_eq] |
| have hc0 : s counter=[] := hcount |
| rw [←hin,←hc0,Function.update_eq_self,Function.update_eq_self] |
| rw [he] |
| exact ⟨1,by simp,Block.loop_runs_empty _ _ _ (by simpa using hcount)⟩ |
| | succ n ih => |
| let s₁ := Function.update s counter (unary n) |
| let s₂ := Function.update s₁ (ι 0) (ea (f a)) |
| have hp : (Block.pop counter).Runs s s₁ 1 := by |
| simpa [s₁,hcount] using Block.pop_runs counter s |
| obtain ⟨t,ht,hp₀⟩ := p.run_at ι hι s₁ a (by simpa [s₁,hc] using hin) (by |
| intro i hi |
| simpa [s₁,hc] using hclean i hi) |
| change (p.block.rename ι).Runs s₁ s₂ t at hp₀ |
| obtain ⟨u,hu,hi⟩ := ih (f a) s₂ (by simp [s₂]) (by |
| intro i hi |
| have hne : ι i≠ι 0 := fun h => hi (hι h) |
| simp [s₂,s₁,Function.update_of_ne hne,hc,hclean i hi]) |
| (by simp [s₂,s₁,(hc 0).symm]) (by |
| intro j hj |
| simpa only [Function.iterate_succ_apply] using hb (j+1) (by omega)) |
| have he : Function.update (Function.update s₂ counter []) (ι 0) (ea (f^[n] (f a)))= |
| Function.update (Function.update s counter []) (ι 0) (ea (f^[n+1] a)) := by |
| funext k |
| by_cases hk : k=ι 0 |
| · subst k; simp [Function.iterate_succ_apply] |
| · by_cases hkc : k=counter |
| · subst k; simp [(hc 0).symm] |
| · simp [s₂,s₁,Function.update_of_ne,hk,hkc] |
| rw [he] at hi |
| have hh := Block.loop_runs_step counter ((Block.pop counter).seq (p.block.rename ι)) |
| (by simp [hcount]) (Block.seq_runs _ _ hp hp₀) hi |
| refine ⟨_,?_,hh⟩ |
| have ht' : t≤p.time.eval B := ht.trans (polynomial_eval_mono p.time (by simpa using hb 0 (by omega))) |
| nlinarith |
|
|
| noncomputable def boundedIterate {δ : Type} (p : Routine ea ea f) |
| (count : δ → ℕ) (initial : δ → α) (P : Polynomial ℕ) |
| (hbound : ∀ d j,j≤count d → (ea (f^[j] (initial d))).length≤ |
| P.eval (pairBits (unary (count d)) (ea (initial d))).length) : |
| Routine (fun d => pairBits (unary (count d)) (ea (initial d))) ea |
| (fun d => f^[count d] (initial d)) where |
| scratch := p.scratch+1 |
| block := |
| let ι : Fin (p.scratch+1) → Fin (p.scratch+2) := fun i => ⟨i.val,by omega⟩ |
| let c : Fin (p.scratch+2) := ⟨p.scratch+1,by omega⟩ |
| (Block.decodeRev 0 c).seq (Block.loop c ((Block.pop c).seq (p.block.rename ι))) |
| time := X*(p.time.comp P+7)+3 |
| correct d := by |
| let R := p.scratch+2 |
| let ι : Fin (p.scratch+1) → Fin R := fun i => ⟨i.val,by omega⟩ |
| let c : Fin R := ⟨p.scratch+1,by omega⟩ |
| have hι : Function.Injective ι := fun i j h => Fin.ext (congrArg (fun k : Fin R => k.val) h) |
| have hc : ∀ i,ι i≠c := by |
| intro i h |
| have hh := congrArg (fun k : Fin R => k.val) h |
| have hi := i.isLt |
| simp only [ι,c] at hh |
| omega |
| have h0c : (0:Fin R)≠c := hc 0 |
| let e := pairBits (unary (count d)) (ea (initial d)) |
| let s₀ : Store R := Function.update (fun _ => []) 0 e |
| let s₁ : Store R := Function.update (Function.update s₀ 0 (ea (initial d))) c (unary (count d)) |
| have hd : (Block.decodeRev 0 c).Runs s₀ s₁ (5*count d+2) := by |
| simpa [s₁,s₀,h0c.symm] using Block.decodeRev_runs (0:Fin R) c h0c |
| (unary (count d)) (ea (initial d)) s₀ (by simp [s₀,e]) |
| obtain ⟨t,ht,hi⟩ := p.iterate_runs_at ι hι c hc (P.eval e.length) (count d) (initial d) s₁ |
| (by change s₁ 0=_; simp [s₁,h0c]) (by |
| intro i hi |
| have hne : ι i≠0 := fun h => hi (hι h) |
| simp [s₁,s₀,Function.update_of_ne,hne,hc]) |
| (by simp [s₁]) (hbound d) |
| have he : Function.update (Function.update s₁ c []) (ι 0) (ea (f^[count d] (initial d)))= |
| Function.update (fun _ => []) 0 (ea (f^[count d] (initial d))) := by |
| funext k |
| change Function.update (Function.update s₁ c []) 0 _ k=_ |
| by_cases hk : k=0 |
| · subst k; simp |
| · by_cases hkc : k=c |
| · subst k; simp [h0c.symm] |
| · simp [s₁,s₀,Function.update_of_ne,hk,hkc] |
| rw [he] at hi |
| refine ⟨_,?_,Block.seq_runs _ _ hd hi⟩ |
| simp only [eval_add,eval_mul,eval_X,eval_comp,eval_ofNat] |
| change 5*count d+2+t≤e.length*(p.time.eval (P.eval e.length)+7)+3 |
| have hn : count d≤e.length := by simp [e,pairBits_length]; omega |
| have hmul := Nat.mul_le_mul_right (p.time.eval (P.eval e.length)+7) hn |
| nlinarith |
|
|
| end Routine |
| end BinaryMatching.StackCode |
| end |
|
|
| end OAI |
|
|
