File size: 4,030 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Tapes.PackedInverse
namespace OAI
namespace MatchingFPRAS.LiteralPacked
open Turing LiteralTape LiteralBlockMap
noncomputable def packCode := LiteralBlockMap.code 1 (fun b=>chunk (b 0)) header
def singletonBlock (a : Symbol) : Block 1 := fun _=>a
lemma singletonBlock_word (a : Symbol) : List.ofFn (singletonBlock a)=[a] := by simp [singletonBlock,List.ofFn_succ]
lemma pack_exec (as : List Symbol) (ha : ∀ a∈as,a≠0) :
Exec packCode ⟨some .start,(fun _=>0),Tape.mk₁ as⟩
⟨none,(fun _=>0),Tape.mk₁ (TreePost.packed as)⟩
(1+LiteralBlockMap.budget 1 (18*width) as.length 0) := by
have h:=LiteralBlockMap.computes 1 (fun b=>chunk (b 0)) header (by decide)
(as.map singletonBlock) (18*width) ?_ ?_ ?_
· simpa only [packCode,List.flatMap_map,singletonBlock_word,List.flatMap_singleton,List.flatMap_singleton',List.length_map,
←List.map_reverse,singletonBlock,←packed_eq] using h
· intro b hb
obtain ⟨a,ha',rfl⟩:=List.mem_map.mp hb
intro he
exact ha a ha' (congrFun he 0)
· intro b _ a had
exact chunk_alphabet _ _ had
· intro b _
exact (chunk_length _).le
noncomputable def unpackCode := LiteralBlockMap.code (18*width) unchunk []
lemma unpack_exec (as : List Symbol) (ha : ∀ a∈as,a≠6 ∧ a≠7) :
Exec unpackCode ⟨some .start,(fun _=>0),Tape.mk₁ (as.reverse.flatMap chunk)⟩
⟨none,(fun _=>0),Tape.mk₁ as⟩
(1+LiteralBlockMap.budget (18*width) 1 as.length 0) := by
have h:=LiteralBlockMap.computes (18*width) unchunk [] (Nat.mul_pos (by decide) width_pos)
(as.reverse.map chunkFn) 1 ?_ ?_ ?_
· simpa only [unpackCode,List.flatMap_map,chunkFn_word,←List.map_reverse,List.reverse_reverse,
unchunk_chunkFn,List.flatMap_singleton,List.flatMap_singleton',List.nil_append,List.length_map,List.length_reverse] using h
· intro b hb
obtain ⟨a,_,rfl⟩:=List.mem_map.mp hb
exact chunkFn_nonzero a
· intro b hb a had
obtain ⟨c,hc,rfl⟩:=List.mem_map.mp hb
rw [unchunk_chunkFn,List.mem_singleton] at had
subst a
exact ha c (List.mem_reverse.mp hc)
· intro b hb
obtain ⟨a,_,rfl⟩:=List.mem_map.mp hb
rw [unchunk_chunkFn];rfl
end MatchingFPRAS.LiteralPacked
namespace MatchingFPRAS.LiteralTape
open Turing MachineCost
variable {Γ Λ σ : Type} [Inhabited Γ]
def eraseRight (n : ℕ) (q : TM1.Stmt Γ Λ σ) : TM1.Stmt Γ Λ σ :=
Nat.rec q (fun _ tail=>.write (fun _ _=>default) (.move .right tail)) n
lemma eraseRight_step (xs L R : List Γ) (q : TM1.Stmt Γ Λ σ) (v : σ) :
TM1.stepAux (eraseRight xs.length q) v (Tape.mk₂ L (xs++R))=
TM1.stepAux q v (Tape.mk₂ (List.replicate xs.length default++L) R) := by
induction xs generalizing L with
| nil => rfl
| cons a xs ih =>
simp only [List.length_cons,eraseRight,TM1.stepAux,List.cons_append,mk₂_write,mk₂_right]
rw [show Nat.rec q (fun _ tail=>TM1.Stmt.write (fun _ _=>default) (.move .right tail)) xs.length=eraseRight xs.length q from rfl,ih]
simp only [List.replicate_succ',List.append_assoc,List.singleton_append]
noncomputable def eraseCode (n : ℕ) : Unit→TM1.Stmt Symbol Unit Unit := fun _=>eraseRight n .halt
lemma erase_exec (xs R : List Symbol) :
Exec (eraseCode xs.length) ⟨some (),(),Tape.mk₁ (xs++R)⟩ ⟨none,(),Tape.mk₁ R⟩ 1 := by
have h:=Exec.step (eraseCode xs.length) () () (Tape.mk₁ (xs++R))
change Exec _ _ (TM1.stepAux (eraseRight xs.length .halt) () (Tape.mk₂ [] (xs++R))) 1 at h
rw [eraseRight_step] at h
have he : Tape.mk₂ (List.replicate xs.length (0:Symbol)++[]) R=Tape.mk₁ R := by
simp only [List.append_nil,Tape.mk₂,Tape.mk₁]
rw [show (ListBlank.mk (List.replicate xs.length (0:Symbol)))=ListBlank.mk [] from blank_zero xs.length]
change Exec _ _ (TM1.stepAux (.halt : TM1.Stmt Symbol Unit Unit) () (Tape.mk₂ (List.replicate xs.length (0:Symbol)++[]) R)) 1 at h
simpa only [TM1.stepAux,he] using h
end MatchingFPRAS.LiteralTape
end OAI
|