File size: 4,748 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 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeListMore
import OAI.Combinatorics.MatchingCount.Machines.TreePostRealization
import OAI.Combinatorics.MatchingCount.Tapes.Codec
namespace OAI
namespace MatchingFPRAS.LiteralPacked
open TreeTyped TreeData TreeFunction TreeMachine TreePost
abbrev Row := K Reg→Option Bool
def baseRow : Row
| .inl _ => some false
| .inr _ => none
def bitRow (b : Bool) : Row := fun k=>if k=Sum.inl 0 then some b else none
def bottom : Alphabet := (true,baseRow)
def letter (b : Bool) : Alphabet := (false,bitRow b)
lemma rows_eq {A : Type} [Codec A] (a : A) (bs : List Bool)
(hs : (TreeData.encode (TreeTyped.encode a)).reverse=false::bs) :
StackWords.rows (inputStacks a) (weight a)=baseRow::bs.map bitRow := by
have hw : weight a=bs.length+1 := by
have h:=congrArg List.length hs
simpa only [List.length_reverse,List.length_cons,weight,TreeFunction.size] using h
apply List.ext_getElem
· simp only [StackWords.rows,List.length_ofFn,List.length_cons,List.length_map,hw]
· intro i hi hj
simp only [StackWords.rows,List.getElem_ofFn]
funext k
cases k with
| inr k =>
cases i <;> simp [inputStacks,encodeEnv,baseRow,bitRow]
| inl r =>
by_cases hr:r=0
· subst r
simp only [inputStacks,encodeEnv,env,ite_true,hs]
cases i <;> simp [baseRow,bitRow]
· have hn : env (TreeTyped.encode a) .nil .nil r=.nil := by simp [env,hr]
simp only [inputStacks,encodeEnv,hn,TreeData.encode,List.reverse_singleton]
cases i <;> simp [baseRow,bitRow,hr]
lemma word_eq {A : Type} [Codec A] (a : A) (bs : List Bool)
(hs : (TreeData.encode (TreeTyped.encode a)).reverse=false::bs) :
StackWords.word (inputStacks a) (weight a)=bottom::bs.map letter := by
rw [StackWords.word,rows_eq a bs hs]
simp only [List.headI_cons,List.tail_cons]
change (true,baseRow)::(bs.map bitRow).map (fun a=>(false,a)) = (true,baseRow)::bs.map LiteralPacked.letter
rw [List.map_map]
rfl
def symbolBits (a : Symbol) : List Bool := (TreeData.encode (TreeTyped.encode a)).reverse++[true]
lemma symbolBits_length (a : Symbol) : (symbolBits a).length=18 := by
simp only [symbolBits,List.length_append,List.length_reverse,List.length_singleton]
change weight a+1=18
rw [LiteralCodec.weight_symbol]
lemma list_bits (as : List Symbol) :
(TreeData.encode (TreeTyped.encode as)).reverse=false::as.reverse.flatMap symbolBits := by
induction as with
| nil => rfl
| cons a as ih =>
simp only [TreeTyped.encode_list_cons,TreeData.encode,List.reverse_cons,List.reverse_append,ih,
List.flatMap_append,List.flatMap_cons,List.flatMap_nil,List.append_nil,symbolBits,
List.cons_append,List.append_assoc]
noncomputable def block (a : Alphabet) : List Symbol :=
(FixedEncoding.enc Alphabet a).toList.map BoolPostCompiler.up
noncomputable def header : List Symbol := block bottom
noncomputable def chunk (a : Symbol) : List Symbol := (symbolBits a).flatMap (fun b=>block (letter b))
noncomputable def width : ℕ := Fintype.card Alphabet
lemma map_enc_length {α : Type} [Fintype α] [Inhabited α] (a : α) :
((FixedEncoding.enc α a).toList.map BoolPostCompiler.up).length=Fintype.card α := by
rw [List.length_map]
exact (FixedEncoding.enc α a).2
lemma block_length (a : Alphabet) : (block a).length=width := by
unfold width block
exact map_enc_length a
lemma flatMap_uniform_length {α β : Type} (as : List α) (f : α→List β) (w : ℕ)
(h : ∀ a,(f a).length=w) : (as.flatMap f).length=as.length*w := by
induction as with
| nil => simp
| cons a as ih => simp only [List.flatMap_cons,List.length_append,h,ih,List.length_cons,Nat.add_mul,Nat.one_mul];omega
lemma chunk_length (a : Symbol) : (chunk a).length=18*width := by
exact (flatMap_uniform_length (symbolBits a) (fun b=>block (letter b)) width
(fun b=>block_length (letter b))).trans (congrArg (fun n=>n*width) (symbolBits_length a))
lemma packed_eq (as : List Symbol) : TreePost.packed as=header++as.reverse.flatMap chunk := by
unfold TreePost.packed StackWords.encoded FixedAlphabetCompiler.word FixedAlphabetCompiler.bitsWord
rw [word_eq as _ (list_bits as)]
simp only [List.flatMap_cons,List.map_append,List.flatMap_map,List.map_flatMap,
List.flatMap_assoc,LiteralPacked.header,LiteralPacked.block]
rfl
lemma block_alphabet (a : Alphabet) (s : Symbol) (hs : s∈block a) : s=0 ∨ s=1 := by
obtain ⟨b,_,rfl⟩:=List.mem_map.mp hs
cases b <;> simp [BoolPostCompiler.up]
lemma chunk_alphabet (a s : Symbol) (hs : s∈chunk a) : s≠6 ∧ s≠7 := by
obtain ⟨b,_,hb⟩:=List.mem_flatMap.mp hs
rcases block_alphabet _ _ hb with rfl|rfl <;> decide
end MatchingFPRAS.LiteralPacked
end OAI
|