| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Complexity.GuardMachineBase |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.BoolPostCompiler |
| open Turing MachineCost |
| open scoped Classical |
|
|
| def up : PointedMap Bool Symbol := ⟨fun b=>if b then 1 else 0,rfl⟩ |
| def down : PointedMap Symbol Bool := ⟨fun a=>decide (a=1),rfl⟩ |
| lemma down_up (b : Bool) : down (up b)=b := by cases b <;> decide |
| variable {Λ : Type*} [Inhabited Λ] |
| variable (M : TM0.Machine Bool Λ) (S : Finset Λ) (hS : TM0.Supports M (S : Set Λ)) |
| def lift : TM0.Machine Symbol Λ := TM0.Machine.map M up down id id |
| include hS |
| lemma lift_supported : TM0.Supports (lift M) (S : Set Λ) := by |
| refine ⟨hS.1,?_⟩ |
| intro q a q' s he hq |
| change (q',s) ∈ (M q (down a)).map (Prod.map id (TM0.Stmt.map up)) at he |
| obtain ⟨⟨r,t⟩,hr,heq⟩:=Option.map_eq_some_iff.mp he |
| have hqr : r=q' := congrArg Prod.fst heq |
| subst r |
| exact hS.2 hr hq |
| omit hS in |
| lemma step_map (c : TM0.Cfg Bool Λ) : |
| (TM0.step M c).map (TM0.Cfg.map up id)= |
| TM0.step (lift M) (TM0.Cfg.map up id c) := |
| TM0.Machine.map_step M up down id id (S:=Set.univ) down_up (fun _ _=>rfl) c trivial |
| omit hS in |
| lemma advance_map (c : TM0.Cfg Bool Λ) : |
| advance (TM0.step (lift M)) (TM0.Cfg.map up id c)= |
| TM0.Cfg.map up id (advance (TM0.step M) c) := by |
| unfold advance |
| rw [←step_map] |
| cases TM0.step M c <;> rfl |
| omit hS in |
| lemma run_map (c : TM0.Cfg Bool Λ) (n : ℕ) : |
| MachineCost.run (TM0.step (lift M)) n (TM0.Cfg.map up id c)= |
| TM0.Cfg.map up id (MachineCost.run (TM0.step M) n c) := by |
| induction n generalizing c with |
| | zero => rfl |
| | succ n ih => rw [MachineCost.run,advance_map,ih]; rfl |
| omit hS in |
| lemma init_map (input : List Bool) : |
| TM0.Cfg.map (Λ:=Λ) up id (TM0.init input)=TM0.init (input.map up) := by |
| exact TM0.map_init up ⟨id,rfl⟩ input |
| noncomputable def compiled : RandomMachine := PostCompiler.sealedMachine (lift M) S |
| (lift_supported M S hS) |
|
|
| theorem compiled_words (input output : List Bool) (n t : ℕ) |
| (hhalt : TM0.step M (MachineCost.run (TM0.step M) n (TM0.init input))=none) |
| (hout : (MachineCost.run (TM0.step M) n (TM0.init input)).Tape.right₀= |
| ListBlank.mk output) |
| (ht : n+2 ≤ t) (bits : Fin t → Bool) : |
| (MatchingFPRAS.run (compiled M S hS) (input.map up) bits).state=none ∧ |
| (MatchingFPRAS.run (compiled M S hS) (input.map up) bits).tape.right₀= |
| ListBlank.mk (output.map up) := by |
| have he : MachineCost.run (TM0.step (lift M)) n (TM0.init (input.map up))= |
| TM0.Cfg.map up id (MachineCost.run (TM0.step M) n (TM0.init input)) := by |
| rw [←init_map,run_map] |
| have hh : TM0.step (lift M) (MachineCost.run (TM0.step (lift M)) n |
| (TM0.init (input.map up)))=none := by |
| rw [he,←step_map,hhalt] |
| rfl |
| have ho : (MachineCost.run (TM0.step (lift M)) n |
| (TM0.init (input.map up))).Tape.right₀=ListBlank.mk (output.map up) := by |
| rw [he] |
| change ((MachineCost.run (TM0.step M) n (TM0.init input)).Tape.map up).right₀=_ |
| have hm : ∀ T : Tape Bool,(T.map up).right₀=T.right₀.map up := by |
| intro T |
| obtain ⟨L,R,rfl⟩:=T.exists_mk' |
| simp only [Tape.map_mk',Tape.mk'_right₀] |
| rw [hm,hout,ListBlank.map_mk] |
| exact PostCompiler.words_extend (compiled M S hS) (input.map up) (output.map up) ht bits |
| (PostCompiler.seal_words (lift M) S (lift_supported M S hS) (input.map up) |
| (output.map up) n hh ho _) |
| end MatchingFPRAS.BoolPostCompiler |
|
|
| end OAI |
|
|
