File size: 3,468 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 | 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
|