| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Encoding.BinarySyntax |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets.BinarySyntax |
|
|
| inductive Mark where |
| | first (r : Fin 3) |
| | empty |
| deriving DecidableEq |
|
|
| def event : Phase → Bool → Option Mark |
| | .sign r true, _ => some (.first r) |
| | .widthStart, false => some .empty |
| | _, _ => none |
|
|
| def shift (k : ℕ) (xs : List (ℕ × Mark)) : List (ℕ × Mark) := |
| xs.map (fun x => (k+x.1,x.2)) |
|
|
| @[simp] lemma shift_nil (k : ℕ) : shift k []=[] := rfl |
| @[simp] lemma shift_cons (k : ℕ) (p : ℕ) (e : Mark) (xs : List (ℕ × Mark)) : |
| shift k ((p,e)::xs)=(k+p,e)::shift k xs := rfl |
| @[simp] lemma shift_append (k : ℕ) (a b : List (ℕ × Mark)) : |
| shift k (a++b)=shift k a++shift k b := List.map_append |
| @[simp] lemma shift_shift (j k : ℕ) (xs : List (ℕ × Mark)) : |
| shift j (shift k xs)=shift (j+k) xs := by simp [shift,List.map_map,Function.comp_def,Nat.add_assoc] |
| @[simp] lemma shift_zero (xs : List (ℕ × Mark)) : shift 0 xs=xs := by simp [shift] |
|
|
| def events (q : Phase) : List Bool → List (ℕ × Mark) |
| | [] => [] |
| | b::s => ((event q b).toList.map (fun e => (0,e))) ++ shift 1 (events (transition q b) s) |
|
|
| lemma events_append (q : Phase) (a b : List Bool) : |
| events q (a++b)=events q a++shift a.length (events (run q a) b) := by |
| induction a generalizing q with |
| | nil => simp [events] |
| | cons x a ih => |
| simp only [List.cons_append,events,ih,shift_append,shift_shift,List.length_cons,run_cons, |
| List.append_assoc,Nat.add_comm 1] |
|
|
| lemma events_header (s : List Bool) : events .headerMark (frame s)=[] := by |
| induction s with |
| | nil => rfl |
| | cons b s ih => simp [frame,events,transition,event,ih] |
|
|
| lemma events_name (r : Fin 3) (s : List Bool) : events (.mark r) (frame s)=[] := by |
| induction s with |
| | nil => rfl |
| | cons b s ih => simp [frame,events,transition,event,ih] |
|
|
| lemma events_literal (r : Fin 3) (first : Bool) (l : Literal) : |
| events (.sign r first) (literalBits l)=if first then [(0,.first r)] else [] := by |
| cases first <;> simp [literalBits,nameBits,events,event,transition,events_name] |
|
|
| def clauseMark (C : List Literal) : ℕ × Mark := |
| if C=[] then (0,.empty) else ((nameBits C.length).length,.first ⟨(C.length-1)%3,Nat.mod_lt _ (by decide)⟩) |
|
|
| lemma events_clause (C : List Literal) (hw : C.length ≤ 3) : |
| events .widthStart (clauseBits C)=[clauseMark C] := by |
| cases C with |
| | nil => rfl |
| | cons a C => |
| cases C with |
| | nil => |
| simp only [clauseMark,clauseBits,List.cons_ne_nil,ite_false,List.length_cons,List.length_nil, |
| List.flatMap_cons,List.flatMap_nil] |
| change events .widthStart ([true,true,false]++(literalBits a++[])) = [(3,.first 0)] |
| rw [events_append,events_append] |
| simp [events,event,transition,run,events_literal] |
| | cons b C => |
| cases C with |
| | nil => |
| simp only [clauseMark,clauseBits,List.cons_ne_nil,ite_false,List.length_cons,List.length_nil, |
| List.flatMap_cons,List.flatMap_nil] |
| change events .widthStart ([true,false,true,true,false]++(literalBits a++(literalBits b++[]))) = [(5,.first 1)] |
| rw [events_append] |
| change [] ++ shift 5 (events (.sign 1 true) (literalBits a++(literalBits b++[]))) = _ |
| rw [events_append,events_append,run_literal] |
| simp [events_literal,events,after] |
| | cons c C => |
| have hc : C=[] := by apply List.length_eq_zero_iff.mp; simp only [List.length_cons] at hw; omega |
| subst C |
| simp only [clauseMark,clauseBits,List.cons_ne_nil,ite_false,List.length_cons,List.length_nil, |
| List.flatMap_cons,List.flatMap_nil] |
| change events .widthStart ([true,true,true,true,false]++(literalBits a++(literalBits b++(literalBits c++[])))) = [(5,.first 2)] |
| rw [events_append] |
| change [] ++ shift 5 (events (.sign 2 true) (literalBits a++(literalBits b++(literalBits c++[])))) = _ |
| rw [events_append,run_literal] |
| change shift 5 (events (.sign 2 true) (literalBits a) ++ |
| shift (literalBits a).length (events (.sign 1 false) (literalBits b++(literalBits c++[])))) = _ |
| rw [events_append,events_append,run_literal] |
| simp [events_literal,events,after] |
|
|
| lemma mem_shift (k p : ℕ) (e : Mark) (xs : List (ℕ × Mark)) : |
| (p,e) ∈ shift k xs ↔ ∃ j, (j,e) ∈ xs ∧ p=k+j := by |
| simp only [shift,List.mem_map,Prod.exists,Prod.mk.injEq] |
| constructor |
| · rintro ⟨j,d,h,he,hd⟩; subst d; exact ⟨j,h,he.symm⟩ |
| · rintro ⟨j,h,rfl⟩; exact ⟨j,e,h,rfl,rfl⟩ |
|
|
| lemma events_complete (q : Phase) (s : List Bool) (p : ℕ) (hp : p < s.length) (e : Mark) : |
| (p,e) ∈ events q s ↔ event (run q (s.take p)) s[p]=some e := by |
| induction s generalizing q p with |
| | nil => simp at hp |
| | cons b s ih => |
| cases p with |
| | zero => |
| simp only [events,List.mem_append,List.mem_map,Option.mem_toList,Prod.mk.injEq, |
| true_and,mem_shift,List.take_zero,run_nil,List.getElem_cons_zero] |
| constructor |
| · rintro (⟨e',he',rfl⟩|⟨j,hj,he⟩) |
| · exact he' |
| · omega |
| · intro h; exact Or.inl ⟨e,h,rfl⟩ |
| | succ p => |
| have hp' : p < s.length := by simpa using hp |
| simp only [events,List.mem_append,List.mem_map,Option.mem_toList,Prod.mk.injEq, |
| show ¬(0=p+1) by omega,false_and,and_false,exists_false, false_or,mem_shift, |
| List.take_succ_cons,run_cons,List.getElem_cons_succ] |
| rw [← ih (transition q b) p hp'] |
| constructor |
| · rintro ⟨j,hj,he⟩ |
| have : j=p := by omega |
| subst j |
| exact hj |
| · intro h; exact ⟨p,h,by omega⟩ |
|
|
| lemma event_clause_location (Cs : List (List Literal)) (hw : ∀ C ∈ Cs, C.length ≤ 3) |
| (p : ℕ) (e : Mark) (he : (p,e) ∈ events .widthStart (Cs.flatMap clauseBits)) : |
| ∃ pre C post, Cs=pre++C::post ∧ |
| p=(pre.flatMap clauseBits).length+(clauseMark C).1 ∧ e=(clauseMark C).2 := by |
| induction Cs generalizing p with |
| | nil => simp [events] at he |
| | cons C Cs ih => |
| rw [List.flatMap_cons,events_append,events_clause C (hw C (by simp)), |
| run_clause C (hw C (by simp))] at he |
| rcases List.mem_append.mp he with h | h |
| · have hh : (p,e)=clauseMark C := List.mem_singleton.mp h |
| refine ⟨[],C,Cs,rfl,?_,?_⟩ |
| · simpa using congrArg Prod.fst hh |
| · exact congrArg Prod.snd hh |
| · obtain ⟨j,hj,hp⟩ := (mem_shift _ _ _ _).mp h |
| obtain ⟨pre,D,post,hs,hj',he'⟩ := ih (fun D hD => hw D (by simp [hD])) j hj |
| refine ⟨C::pre,D,post,by simp [hs],?_,he'⟩ |
| simp [hp,hj',List.flatMap_cons,Nat.add_assoc] |
|
|
| lemma events_bound (q : Phase) (s : List Bool) (p : ℕ) (e : Mark) |
| (hp : (p,e) ∈ events q s) : p < s.length := by |
| induction s generalizing q p with |
| | nil => simp [events] at hp |
| | cons b s ih => |
| rw [events,List.mem_append] at hp |
| rcases hp with h | h |
| · obtain ⟨e',_he,he'⟩ := List.mem_map.mp h |
| have : p=0 := (congrArg Prod.fst he').symm |
| simp [this] |
| · obtain ⟨j,hj,hp⟩ := (mem_shift _ _ _ _).mp h |
| have := ih (transition q b) j hj |
| simp only [List.length_cons] |
| omega |
|
|
| lemma clause_event_location (pre : List (List Literal)) (C : List Literal) (post : List (List Literal)) |
| (hw : ∀ D ∈ pre++C::post, D.length ≤ 3) : |
| ((pre.flatMap clauseBits).length+(clauseMark C).1,(clauseMark C).2) ∈ |
| events .widthStart ((pre++C::post).flatMap clauseBits) := by |
| rw [List.flatMap_append,events_append,run_clauses pre (fun D hD => hw D (by simp [hD]))] |
| apply List.mem_append_right |
| apply (mem_shift _ _ _ _).mpr |
| refine ⟨(clauseMark C).1,?_,rfl⟩ |
| rw [List.flatMap_cons,events_append,events_clause C (hw C (by simp))] |
| apply List.mem_append_left |
| simp |
|
|
| lemma event_formula_location (F : Formula) (p : ℕ) (e : Mark) |
| (he : (p,e) ∈ events .headerMark (formulaBits F)) : |
| ∃ pre C post, F.clauses=pre++C::post ∧ |
| p=(nameBits F.clauses.length).length+(pre.flatMap clauseBits).length+(clauseMark C).1 ∧ |
| e=(clauseMark C).2 := by |
| rw [formulaBits,events_append] at he |
| simp only [nameBits,events_header,run_header,List.nil_append] at he |
| obtain ⟨j,hj,hp⟩ := (mem_shift _ _ _ _).mp he |
| obtain ⟨pre,C,post,hs,hj',he'⟩ := event_clause_location F.clauses F.width j e hj |
| exact ⟨pre,C,post,hs,by dsimp [nameBits]; omega,he'⟩ |
|
|
| lemma formula_clause_event (F : Formula) (pre : List (List Literal)) (C : List Literal) |
| (post : List (List Literal)) (hF : F.clauses=pre++C::post) : |
| ((nameBits F.clauses.length).length+(pre.flatMap clauseBits).length+(clauseMark C).1, |
| (clauseMark C).2) ∈ events .headerMark (formulaBits F) := by |
| rw [formulaBits,events_append] |
| simp only [nameBits,events_header,run_header,List.nil_append] |
| apply (mem_shift _ _ _ _).mpr |
| refine ⟨(pre.flatMap clauseBits).length+(clauseMark C).1,?_,by omega⟩ |
| rw [hF] |
| exact clause_event_location pre C post (fun D hD => F.width D (hF ▸ hD)) |
|
|
| end LargeIndependentSets.BinarySyntax |
|
|
| end OAI |
|
|
