| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Tapes.RandomWordLaw |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.RandomWord |
| open Turing BinaryArithmetic |
|
|
| lemma draw_forward_suffix (xs : List (Bool×Bool)) (L R : List Symbol) : |
| execute (pairCoins xs) (cfg (some 0) L (List.replicate xs.length 1++3::R))= |
| cfg (some 0) ((drawnWord xs).reverse++L) (3::R) := by |
| induction xs generalizing L with |
| | nil=>rfl |
| | cons p xs ih=> |
| simp only [pairCoins,List.flatMap_cons,List.length_cons,List.replicate_succ,List.cons_append] |
| change execute ([p.1,p.2]++pairCoins xs) (cfg (some 0) L (1::(List.replicate xs.length 1++3::R)))=_ |
| rw [execute_append,draw_two,ih] |
| simp [drawnWord,List.reverse_cons,List.append_assoc] |
| lemma finish_run_suffix (L R : List Symbol) (hL : ∀ b∈L,b≠0) |
| (xs : List Bool) (hx : xs.length=L.length+3) : |
| execute xs (cfg (some 0) L (3::R))=cfg none [] (L.reverse++3::R) := by |
| obtain ⟨ys,b,rfl⟩ : ∃ ys b,xs=ys++[b] := by |
| have hn : xs.reverse≠[] := by |
| intro h |
| have h' : xs.length=0 := by simpa only [List.length_reverse,List.length_nil] using congrArg List.length h |
| omega |
| obtain ⟨b,ys,he⟩:=List.exists_cons_of_ne_nil hn |
| exact ⟨ys.reverse,b,by have h:=congrArg List.reverse he; simpa using h⟩ |
| have hy : ys.length=L.length+2 := by simpa using hx |
| have he : execute ys (cfg (some 0) L (3::R))=cfg (some 3) [] (L.reverse++3::R) := by |
| have hr:=reset_run L R 3 (by decide) hL ys hy |
| cases ys with |
| | nil=>simp at hy |
| | cons c ys=> |
| rw [execute_cons] at hr ⊢ |
| have ht : tick machine (cfg (some 0) L (3::R)) c=tick machine (cfg (some 2) L (3::R)) c := by |
| simp [tick,machine,Tape.mk₂,Tape.mk'] |
| rw [ht] |
| exact hr |
| rw [execute_append,he] |
| simp [execute,tick,machine,cfg] |
| lemma execute_word_suffix (xs : List (Bool×Bool)) (tail : List Bool) (R : List Symbol) |
| (ht : tail.length=xs.length+3) : |
| execute (pairCoins xs++tail) (cfg (some 0) [] (List.replicate xs.length 1++3::R))= |
| cfg none [] (drawnWord xs++3::R) := by |
| rw [execute_append,draw_forward_suffix,List.append_nil] |
| have hn : ∀ b∈(drawnWord xs).reverse,b≠0 := by |
| intro b hb |
| obtain ⟨p,hp,rfl⟩:=List.mem_map.mp (List.mem_reverse.mp hb) |
| exact bitSymbol_ne_zero _ |
| simpa using finish_run_suffix (drawnWord xs).reverse R hn tail (by simpa [drawnWord] using ht) |
| lemma run_word_suffix (m : ℕ) (R : List Symbol) (bits : Fin (m*2+(m+3))→Bool) : |
| run machine (List.replicate m 1++3::R) bits= |
| cfg none [] ((List.ofFn (outputCoins m bits)).map bitSymbol++3::R) := by |
| obtain ⟨⟨x,y⟩,rfl⟩:=(wordTapeEquiv m).symm.surjective bits |
| change execute (List.ofFn ((wordTapeEquiv m).symm (x,y))) |
| (cfg (some 0) [] (List.replicate m 1++3::R))=_ |
| rw [wordTape_list] |
| have h:=execute_word_suffix (List.ofFn x) (List.ofFn y) R (by simp) |
| have ho : outputCoins m ((wordTapeEquiv m).symm (x,y))=(fun i=>(x i).1) := by |
| funext i |
| simp only [outputCoins,Equiv.apply_symm_apply] |
| rw [ho] |
| simpa only [List.length_ofFn,drawnWord,List.map_ofFn,Function.comp_def] using h |
| end MatchingFPRAS.RandomWord |
|
|
| end OAI |
|
|
