| import OAI.Computability.StarHeight.UsableCopies |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uAlphabet uI uI2 uM uM2 uAlphabet2 uAlphabet3 uAlphabet4 |
| universe uM3 |
|
|
| namespace FiniteRecognition |
|
|
| variable {Alphabet : Type uAlphabet} |
|
|
| lemma regular_mul {L R : Language Alphabet} (hL : L.IsRegular) (hR : R.IsRegular) : |
| (L*R).IsRegular := by |
| let combine (q : Language Alphabet) (s : Set (Language Alphabet)) : Language Alphabet := |
| let U : Language Alphabet := {w | ∃ r ∈ s, w ∈ r} |
| q*R + U |
| apply Language.IsRegular.of_finite_range_leftQuotient |
| apply (hL.finite_range_leftQuotient.image2 combine hR.finite_range_leftQuotient.powerset).subset |
| rintro _ ⟨x,rfl⟩ |
| let s : Set (Language Alphabet) := {r | ∃ u v, x=u++v ∧ u∈L ∧ r=R.leftQuotient v} |
| refine ⟨L.leftQuotient x, ⟨x,rfl⟩, s, ?_, ?_⟩ |
| · rintro r ⟨u,v,_,_,rfl⟩ |
| exact ⟨v,rfl⟩ |
| · ext y |
| change (y∈(L.leftQuotient x)*R ∨ ∃ r∈s,y∈r) ↔ x++y∈L*R |
| constructor |
| · rintro (hy | ⟨r,⟨u,v,hx,hu,hr⟩,hy⟩) |
| · obtain ⟨u,hu,v,hv,rfl⟩ := Language.mem_mul.mp hy |
| exact Language.mem_mul.mpr ⟨x++u,hu,v,hv,by simp⟩ |
| · rw [hr] at hy |
| exact Language.mem_mul.mpr ⟨u,hu,v++y,hy,by simp [hx]⟩ |
| · rintro ⟨u,hu,v,hv,he⟩ |
| rcases List.append_eq_append_iff.mp he.symm with ⟨a,ha,hy⟩ | ⟨a,ha,hv'⟩ |
| · left |
| refine Language.mem_mul.mpr ⟨a,?_,v,hv,hy.symm⟩ |
| change x++a∈L |
| rwa [←ha] |
| · right |
| refine ⟨R.leftQuotient a,⟨u,a,ha,hu,rfl⟩,?_⟩ |
| change a++y∈R |
| rw [←hv'] |
| exact hv |
|
|
| lemma regular_finite {L : Language Alphabet} (hL : (L : Set (List Alphabet)).Finite) : |
| L.IsRegular := by |
| let S : Set (List Alphabet) := ⋃ w∈L, {v | v∈w.tails} |
| have hS : S.Finite := hL.biUnion (fun w _ => w.tails.finite_toSet) |
| apply Language.IsRegular.of_finite_range_leftQuotient |
| apply hS.powerset.subset |
| rintro _ ⟨x,rfl⟩ y hy |
| exact Set.mem_iUnion_of_mem (x++y) (Set.mem_iUnion_of_mem hy |
| ((List.mem_tails _ _).mpr ⟨x,rfl⟩)) |
|
|
| lemma regular_singleton (w : List Alphabet) : ({w} : Language Alphabet).IsRegular := |
| regular_finite (Set.finite_singleton w) |
|
|
| lemma regular_finset_iSup {I : Type uI} (s : Finset I) (L : I → Language Alphabet) |
| (h : ∀ i∈s, (L i).IsRegular) : (⨆ i∈s,L i).IsRegular := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => |
| simp only [Finset.notMem_empty,iSup_false,iSup_bot] |
| exact regular_finite Set.finite_empty |
| | @insert i s hi ih => |
| have he : (⨆ j∈insert i s,L j)=L i+(⨆ j∈s,L j) := by |
| ext w |
| simp only [Language.mem_iSup,Finset.mem_insert,Language.mem_add] |
| aesop |
| rw [he] |
| exact (h i (Finset.mem_insert_self _ _)).add |
| (ih fun j hj => h j (Finset.mem_insert_of_mem hj)) |
|
|
| lemma regular_iSup {I : Type uI2} [Finite I] (L : I → Language Alphabet) |
| (h : ∀ i, (L i).IsRegular) : (⨆ i,L i).IsRegular := by |
| classical |
| let := Fintype.ofFinite I |
| simpa only [Finset.mem_univ, iSup_pos] using |
| regular_finset_iSup (Finset.univ : Finset I) L (fun i _ => h i) |
|
|
| lemma regular_recognized {M : Type uM} [Monoid M] [Fintype M] |
| (T : FreeMonoid Alphabet →* M) (F : Set M) : |
| Language.IsRegular ({w | T (FreeMonoid.ofList w)∈F} : Language Alphabet) := by |
| let A : DFA Alphabet M := ⟨fun q a => q*T (FreeMonoid.of a),1,F⟩ |
| have he : ∀ (w : List Alphabet) (q : M), A.evalFrom q w=q*T (FreeMonoid.ofList w) := by |
| intro w |
| induction w with |
| | nil => intro q;simp [DFA.evalFrom] |
| | cons a w ih => |
| intro q |
| rw [DFA.evalFrom_cons,ih] |
| change q*T (FreeMonoid.of a)*T (FreeMonoid.ofList w)=q*T (FreeMonoid.of a*FreeMonoid.ofList w) |
| rw [map_mul,mul_assoc] |
| apply Language.isRegular_iff.mpr |
| refine ⟨M,inferInstance,A,?_⟩ |
| ext w |
| simp only [DFA.mem_accepts,DFA.eval,he] |
| change 1*T (FreeMonoid.ofList w)∈F ↔ T (FreeMonoid.ofList w)∈F |
| rw [one_mul] |
|
|
| lemma regular_sandwich [Finite Alphabet] {M : Type uM2} [Monoid M] [Fintype M] |
| (T : FreeMonoid Alphabet →* M) (N tail : ℕ) (L : Language Alphabet) |
| (hc : ∀ (a b x y : List Alphabet), a.length=N → b.length=tail → |
| T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y) → |
| (a++x++b∈L ↔ a++y++b∈L)) : L.IsRegular := by |
| classical |
| let small : Language Alphabet := {w | w.length<N+tail ∧ w∈L} |
| have hsmall : small.IsRegular := regular_finite |
| ((List.finite_length_le Alphabet (N+tail)).subset (fun w hw => hw.1.le)) |
| let As := (List.finite_length_le Alphabet N).toFinset.filter (fun a => a.length=N) |
| let Bs := (List.finite_length_le Alphabet tail).toFinset.filter (fun b => b.length=tail) |
| let F (a b : List Alphabet) : Set M := {q | ∃ x, T (FreeMonoid.ofList x)=q ∧ a++x++b∈L} |
| let R (a b : List Alphabet) : Language Alphabet := |
| let mid : Language Alphabet := {x | T (FreeMonoid.ofList x)∈F a b} |
| ({a} : Language Alphabet)*mid*({b} : Language Alphabet) |
| have hR : ∀ a b, (R a b).IsRegular := fun a b => |
| regular_mul (regular_mul (regular_singleton a) (regular_recognized T (F a b))) |
| (regular_singleton b) |
| have he : L=small+(⨆ a∈As,⨆ b∈Bs,R a b) := by |
| ext w |
| constructor |
| · intro hw |
| by_cases hl : w.length<N+tail |
| · exact Or.inl ⟨hl,hw⟩ |
| · let a := w.take N |
| let x := (w.drop N).take (w.length-N-tail) |
| let b := w.drop (w.length-tail) |
| have ha : a.length=N := by simp only [a,List.length_take];omega |
| have hb : b.length=tail := by simp only [b,List.length_drop];omega |
| have hw' : a++x++b=w := by |
| have hcut : N+(w.length-N-tail)=w.length-tail := by omega |
| dsimp [a,x,b] |
| rw [←hcut,←List.drop_drop,List.append_assoc,List.take_append_drop,List.take_append_drop] |
| right |
| apply Language.mem_iSup.mpr |
| refine ⟨a,Language.mem_iSup.mpr ⟨?_,Language.mem_iSup.mpr ⟨b,Language.mem_iSup.mpr ⟨?_,?_⟩⟩⟩⟩ |
| · simp only [As,Finset.mem_filter,Set.Finite.mem_toFinset,Set.mem_ofPred_eq,ha,le_refl,and_self] |
| · simp only [Bs,Finset.mem_filter,Set.Finite.mem_toFinset,Set.mem_ofPred_eq,hb,le_refl,and_self] |
| · rw [←hw'] |
| exact Language.append_mem_mul (Language.append_mem_mul (Set.mem_singleton _) |
| ⟨x,rfl,by simpa only [hw'] using hw⟩) (Set.mem_singleton _) |
| · rintro (⟨_,hw⟩ | hw) |
| · exact hw |
| · obtain ⟨a,hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨ha,hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨b,hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨hb,hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨u,hu,v,hv,rfl⟩ := Language.mem_mul.mp hw |
| obtain ⟨a',ha',x,hx,rfl⟩ := Language.mem_mul.mp hu |
| have ha'eq : a'=a := ha' |
| subst a' |
| have hveq : v=b := hv |
| subst v |
| obtain ⟨y,hy,hyL⟩ := hx |
| exact (hc a b y x (Finset.mem_filter.mp ha).2 (Finset.mem_filter.mp hb).2 hy).mp hyL |
| rw [he] |
| exact hsmall.add (regular_finset_iSup As _ (fun a _ => |
| regular_finset_iSup Bs _ (fun b _ => hR a b))) |
|
|
| end FiniteRecognition |
| namespace PeriodicSummary |
|
|
| variable {Alphabet : Type uAlphabet2} {p : ℕ} |
|
|
| noncomputable def matcher (v : ZMod p → Alphabet) : DFA Alphabet (Option (ZMod p)) := by |
| classical |
| exact ⟨fun q a => q.bind (fun i => if a=v i then some (i+1) else none),some 0, {q | q.isSome}⟩ |
|
|
| def Fits (v : ZMod p → Alphabet) : ZMod p → List Alphabet → Prop |
| | _, [] => True |
| | q, a::w => a=v q ∧ Fits v (q+1) w |
|
|
| lemma eval_none (v : ZMod p → Alphabet) (w : List Alphabet) : |
| (matcher v).evalFrom none w=none := by |
| induction w with |
| | nil => rfl |
| | cons a w ih => simpa [DFA.evalFrom_cons,matcher] using ih |
|
|
| lemma eval_isSome (v : ZMod p → Alphabet) (w : List Alphabet) (q : ZMod p) : |
| ((matcher v).evalFrom (some q) w).isSome ↔ Fits v q w := by |
| classical |
| induction w generalizing q with |
| | nil => simp [DFA.evalFrom_nil,Fits] |
| | cons a w ih => |
| rw [DFA.evalFrom_cons] |
| change ((matcher v).evalFrom (if a=v q then some (q+1) else none) w).isSome ↔ _ |
| by_cases h : a=v q |
| · rw [ite_eq_left h,ih] |
| simp only [Fits,h,true_and] |
| · rw [ite_eq_right h,eval_none] |
| simp only [Option.isSome_none,Bool.false_eq_true,Fits,h,false_and] |
|
|
| lemma fits_iff (v : ZMod p → Alphabet) (w : List Alphabet) (q : ZMod p) : |
| Fits v q w ↔ ∀ i : Fin w.length, w[i.val]=v (q+i.val) := by |
| induction w generalizing q with |
| | nil => simp [Fits] |
| | cons a w ih => |
| simp only [Fits,ih,List.length_cons,Fin.forall_fin_succ,List.getElem_cons_zero, |
| List.getElem_cons_succ,Fin.val_zero,Nat.cast_zero,add_zero,Fin.val_succ,Nat.cast_add, |
| Nat.cast_one] |
| constructor |
| · rintro ⟨ha,hw⟩ |
| exact ⟨ha,fun i => by simpa [add_assoc,add_comm,add_left_comm] using hw i⟩ |
| · rintro ⟨ha,hw⟩ |
| exact ⟨ha,fun i => by simpa [add_assoc,add_comm,add_left_comm] using hw i⟩ |
|
|
| noncomputable def transition : FreeMonoid Alphabet →* |
| ((ZMod p → Alphabet) → (Function.End (Option (ZMod p)))ᵐᵒᵖ) := |
| MonoidHom.pi (fun v => FiniteRecognition.transition (matcher v)) |
|
|
| lemma fits_congr {x y : List Alphabet} |
| (h : transition (p := p) (FreeMonoid.ofList x)=transition (FreeMonoid.ofList y)) |
| (v : ZMod p → Alphabet) (q : ZMod p) : Fits v q x ↔ Fits v q y := by |
| have he := congrArg (fun t => (t v).unop (some q)) h |
| change (matcher v).evalFrom (some q) x=(matcher v).evalFrom (some q) y at he |
| rw [←eval_isSome,←eval_isSome,he] |
|
|
| end PeriodicSummary |
|
|
| namespace PeriodicSummary |
|
|
| variable {Alphabet : Type uAlphabet3} |
|
|
| def lengthMod (n : ℕ) : FreeMonoid Alphabet →* Multiplicative (ZMod n) where |
| toFun w := Multiplicative.ofAdd (w.toList.length:ZMod n) |
| map_one' := by simp only [FreeMonoid.toList_one,List.length_nil,Nat.cast_zero]; rfl |
| map_mul' x y := by |
| change Multiplicative.ofAdd ((x.toList++y.toList).length:ZMod n)=_ |
| simp only [List.length_append,Nat.cast_add] |
| rfl |
|
|
| lemma lengthMod_dvd {n : ℕ} {x y : List Alphabet} |
| (h : lengthMod n (FreeMonoid.ofList x)=lengthMod n (FreeMonoid.ofList y)) : |
| (n:ℤ) ∣ (y.length:ℤ)-x.length := by |
| have he : (x.length:ZMod n)=(y.length:ZMod n) := congrArg Multiplicative.toAdd h |
| have hz : ((x.length:ℤ):ZMod n)=((y.length:ℤ):ZMod n) := by simpa only [Int.cast_natCast] using he |
| exact ((ZMod.intCast_eq_intCast_iff _ _ _).mp hz).dvd |
|
|
| end PeriodicSummary |
| namespace StreamSplice |
|
|
| open WordIntervals LocalMarkers |
|
|
| variable {Alphabet : Type uAlphabet4} |
|
|
| noncomputable def splice (f : ℤ → Alphabet) (N : ℤ) (x y : List Alphabet) (z : ℤ) : Alphabet := |
| if h : z<N then f z else if h' : z<N+y.length then |
| y[(z-N).toNat]'(by omega) else f (z-((y.length:ℤ)-x.length)) |
|
|
| lemma splice_left (f : ℤ → Alphabet) (N : ℤ) (x y : List Alphabet) {z : ℤ} (hz : z<N) : |
| splice f N x y z=f z := by simp only [splice,dite_eq_left hz] |
|
|
| lemma splice_right (f : ℤ → Alphabet) (N : ℤ) (x y : List Alphabet) {z : ℤ} |
| (hz : N+y.length≤z) : splice f N x y z=f (z-((y.length:ℤ)-x.length)) := by |
| have hy : (0:ℤ)≤y.length := Int.natCast_nonneg _ |
| simp only [splice,dite_eq_right (show ¬z<N by omega),dite_eq_right (show ¬z<N+y.length by omega)] |
|
|
| lemma splice_middle (f : ℤ → Alphabet) (N : ℤ) (x y : List Alphabet) : |
| Realizes y N (splice f N x y) := by |
| intro i |
| rw [splice,dite_eq_right (show ¬N+(i.val:ℤ)<N by omega), |
| dite_eq_left (show N+(i.val:ℤ)<N+y.length by omega)] |
| simp only [add_sub_cancel_left,Int.toNat_natCast] |
|
|
| lemma splice_realizes {f : ℤ → Alphabet} {a b x : List Alphabet} |
| (hf : Realizes (a++x++b) 0 f) (y : List Alphabet) : |
| Realizes (a++y++b) 0 (splice f a.length x y) := by |
| have ha := hf.append_left.append_left |
| have hb := hf.append_right |
| apply Realizes.append |
| · apply Realizes.append |
| · intro i |
| rw [splice_left f a.length x y (by omega)] |
| exact ha i |
| · simpa only [zero_add] using splice_middle f a.length x y |
| · intro i |
| rw [splice_right f a.length x y (by simp only [List.length_append,Nat.cast_add];omega)] |
| have hh := hb i |
| simp only [List.length_append,Nat.cast_add,zero_add] at hh ⊢ |
| convert hh using 2 |
| omega |
|
|
| structure Frame (f f' : ℤ → Alphabet) (N : ℤ) (x y : List Alphabet) : Prop where |
| left : ∀ z, z<N → f' z=f z |
| oldMiddle : Realizes x N f |
| newMiddle : Realizes y N f' |
| right : ∀ z, N+y.length≤z → f' z=f (z-((y.length:ℤ)-x.length)) |
|
|
| lemma splice_frame {f : ℤ → Alphabet} {a b x : List Alphabet} |
| (hf : Realizes (a++x++b) 0 f) (y : List Alphabet) : |
| Frame f (splice f a.length x y) a.length x y := by |
| refine ⟨fun z hz => splice_left f a.length x y hz,?_,splice_middle f a.length x y, |
| fun z hz => splice_right f a.length x y hz⟩ |
| simpa only [zero_add] using hf.append_left.append_right |
|
|
| namespace Frame |
|
|
| variable {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet} (H : Frame f f' N x y) |
|
|
| include H |
|
|
| lemma agrees_left {s t : ℤ} (ht : t≤N) : AgreesOn f f' s t := by |
| intro z _ hz |
| exact (H.left z (hz.trans_le ht)).symm |
|
|
| lemma piece_left {s t : ℤ} (hst : s ≤ t) (ht : t≤N) : piece f s t=piece f' s t := |
| piece_congr hst (H.agrees_left ht) |
|
|
| lemma piece_right {s t : ℤ} (hs : N+x.length ≤ s) : |
| piece f' (s+((y.length:ℤ)-x.length)) (t+((y.length:ℤ)-x.length))=piece f s t := by |
| dsimp [piece] |
| have hl : (t+((y.length:ℤ)-x.length)-(s+((y.length:ℤ)-x.length))).toNat=(t-s).toNat := by |
| congr 1;ring |
| rw [hl] |
| apply List.ofFn_inj.mpr |
| funext i |
| rw [H.right _ (by omega)] |
| congr 1 |
| ring |
|
|
| lemma product {M : Type uM3} [Monoid M] (T : FreeMonoid Alphabet →* M) |
| (hT : T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y)) {s b : ℤ} |
| (hs : s≤N) (hb : N+x.length≤b) : |
| WordIntervals.product T f' s (b+((y.length:ℤ)-x.length))=WordIntervals.product T f s b := by |
| have hx : N≤N+(x.length:ℤ) := by omega |
| have hy : N≤N+(y.length:ℤ) := by omega |
| have hb' : N+(y.length:ℤ)≤b+((y.length:ℤ)-x.length) := by omega |
| unfold WordIntervals.product |
| rw [piece_append f' hs (hy.trans hb'),piece_append f hs (hx.trans hb)] |
| rw [piece_append f' hy hb',piece_append f hx hb] |
| rw [H.piece_left hs (le_refl _),WordIntervals.realizes_piece H.oldMiddle, |
| WordIntervals.realizes_piece H.newMiddle] |
| have ht : piece f' (N+y.length) (b+((y.length:ℤ)-x.length))=piece f (N+x.length) b := by |
| have hh := H.piece_right (s := N+x.length) (t := b) (le_refl _) |
| simpa only [show N+(x.length:ℤ)+((y.length:ℤ)-x.length)=N+y.length by ring] using hh |
| rw [ht] |
| change T (FreeMonoid.ofList (piece f' s N)*(FreeMonoid.ofList y* |
| FreeMonoid.ofList (piece f (N+x.length) b)))= |
| T (FreeMonoid.ofList (piece f' s N)*(FreeMonoid.ofList x* |
| FreeMonoid.ofList (piece f (N+x.length) b))) |
| simp only [map_mul,hT] |
|
|
| end Frame |
| end StreamSplice |
|
|
| end GeneralizedStarHeight |
|
|
| end OAI |
|
|
