| import OAI.Computability.StarHeight.RegularLanguages |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uAlphabet uAlphabet2 uAlphabet3 uAlphabet4 uAlphabet5 uAlphabet6 uAlphabet7 uJ |
| universe uC |
|
|
| namespace StreamSplice |
|
|
| open LocalMarkers WordIntervals PeriodicSummary |
|
|
| variable {Alphabet : Type uAlphabet} |
|
|
| lemma periodic_of_dvd {v : ℤ → Alphabet} {p δ : ℤ} (h : Function.Periodic v p) |
| (hd : p∣δ) : Function.Periodic v δ := by |
| obtain ⟨k,rfl⟩ := hd |
| simpa only [Int.cast_id,mul_comm] using h.int_mul k |
|
|
| lemma periodic_pattern {p : ℕ} [NeZero p] {v : ℤ → Alphabet} |
| (h : Function.Periodic v (p:ℤ)) (N : ℤ) (i : ℕ) : |
| v (N+(((i:ZMod p).val:ℕ):ℤ))=v (N+i) := by |
| have he := ZMod.val_intCast (n := p) (i:ℤ) |
| simp only [Int.cast_natCast] at he |
| rw [he] |
| exact (periodic_remainder h N (N+i) |>.trans (by rw [add_sub_cancel_left])).symm |
|
|
| lemma fits_realizes {p : ℕ} [NeZero p] {v f : ℤ → Alphabet} {N : ℤ} {w : List Alphabet} |
| (hp : Function.Periodic v (p:ℤ)) (hf : Realizes w N f) : |
| Fits (fun q : ZMod p => v (N+q.val)) 0 w ↔ AgreesOn f v N (N+w.length) := by |
| rw [fits_iff] |
| simp only [zero_add] |
| constructor |
| · intro h z hz hz' |
| let i : Fin w.length := ⟨(z-N).toNat,by omega⟩ |
| have hi : N+(i.val:ℤ)=z := by dsimp [i];omega |
| rw [←hi,hf i,h i,periodic_pattern hp] |
| · intro h i |
| rw [←hf i,periodic_pattern hp] |
| exact h _ (by omega) (by omega) |
|
|
| namespace Frame |
|
|
| variable {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet} (H : Frame f f' N x y) |
|
|
| include H |
|
|
| lemma symm : Frame f' f N y x := by |
| refine ⟨fun z hz => (H.left z hz).symm,H.newMiddle,H.oldMiddle,?_⟩ |
| intro z hz |
| have he := H.right (z-((x.length:ℤ)-y.length)) (by omega) |
| rw [show z-((x.length:ℤ)-y.length)-((y.length:ℤ)-x.length)=z by ring] at he |
| exact he.symm |
|
|
| include H |
|
|
| lemma agrees_periodic {p : ℕ} [NeZero p] {v : ℤ → Alphabet} |
| (hp : Function.Periodic v (p:ℤ)) |
| (hd : (p:ℤ) ∣ (y.length:ℤ)-x.length) |
| (hm : PeriodicSummary.transition (p := p) (FreeMonoid.ofList x)= |
| PeriodicSummary.transition (FreeMonoid.ofList y)) {z q : ℤ} |
| (hz : z≤N) (hq : N+x.length≤q) (ha : AgreesOn f v z q) : |
| AgreesOn f' v z (q+((y.length:ℤ)-x.length)) := by |
| have hmidx : AgreesOn f v N (N+x.length) := by |
| intro t ht ht' |
| exact ha t (hz.trans ht) (ht'.trans_le hq) |
| have hmidx' := (fits_realizes hp H.oldMiddle).mpr hmidx |
| have hmidy := (fits_realizes hp H.newMiddle).mp ((fits_congr hm _ 0).mp hmidx') |
| have hδ := periodic_of_dvd hp hd |
| intro t ht ht' |
| by_cases htN : t<N |
| · rw [H.left t htN] |
| exact ha t ht (by omega) |
| · by_cases htY : t<N+y.length |
| · exact hmidy t (by omega) htY |
| · rw [H.right t (by omega)] |
| rw [ha _ (by omega) (by omega)] |
| have he := hδ (t-((y.length:ℤ)-x.length)) |
| rw [sub_add_cancel] at he |
| exact he.symm |
|
|
| lemma mismatch_periodic {p : ℕ} [NeZero p] {v : ℤ → Alphabet} |
| (hp : Function.Periodic v (p:ℤ)) (hd : (p:ℤ) ∣ (y.length:ℤ)-x.length) |
| {q : ℤ} (hq : N+x.length≤q) : |
| f' (q+((y.length:ℤ)-x.length)) ≠ v (q+((y.length:ℤ)-x.length)) ↔ f q ≠ v q := by |
| rw [H.right _ (by omega)] |
| rw [add_sub_cancel_right,(periodic_of_dvd hp hd) q] |
|
|
| end Frame |
| end StreamSplice |
| namespace StreamSplice.Frame |
|
|
| open LocalMarkers WordIntervals EpisodeEnd |
|
|
| variable {Alphabet : Type uAlphabet2} {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet} |
| (H : Frame f f' N x y) |
|
|
| lemma short_period_factorial {d K : ℕ} {v : ℤ → Alphabet} {z : ℤ} |
| (hv : ShortContinuation d K f z v) : Function.Periodic v (d.factorial:ℤ) := by |
| obtain ⟨p,hp,hpd,hper⟩ := hv.1 |
| apply periodic_of_dvd hper |
| exact_mod_cast Nat.dvd_factorial hp hpd.le |
|
|
| include H |
|
|
| lemma endAt_none {d K : ℕ} {tail z b : ℤ} |
| (hseed : z+(K:ℤ)≤N) (hb : N+x.length≤b-tail) |
| (hd : (d.factorial:ℤ) ∣ (y.length:ℤ)-x.length) |
| (hm : PeriodicSummary.transition (p := d.factorial) (FreeMonoid.ofList x)= |
| PeriodicSummary.transition (FreeMonoid.ofList y)) |
| (he : EndAt d K tail f z none b) : |
| EndAt d K tail f' z none (b+((y.length:ℤ)-x.length)) := by |
| obtain ⟨v,hv,hmis⟩ := he |
| have : NeZero d.factorial := ⟨Nat.factorial_ne_zero d⟩ |
| have hp := short_period_factorial hv |
| refine ⟨v,(shortCont_congr (H.agrees_left hseed)).mp hv,?_,?_,?_⟩ |
| · omega |
| · have hh := (H.mismatch_periodic hp hd hb).mpr hmis.2.1 |
| convert hh using 1 <;> congr 1 <;> ring |
| · rw [show b+((y.length:ℤ)-x.length)-tail=(b-tail)+((y.length:ℤ)-x.length) by ring] |
| exact H.agrees_periodic hp hd hm (by omega) hb hmis.2.2 |
|
|
| lemma endAt {C : CanonicalEpisodes.Parameters Alphabet} {z b : ℤ} |
| (hvis : C.Visible (-N) N z) (hstrict : z+(C.d:ℤ)+(C.B-1)*C.S<N) |
| (hb : N+x.length≤b-C.tail) |
| (hd : (C.d.factorial:ℤ) ∣ (y.length:ℤ)-x.length) |
| (hm : PeriodicSummary.transition (p := C.d.factorial) (FreeMonoid.ofList x)= |
| PeriodicSummary.transition (FreeMonoid.ofList y)) |
| (he : EndAt C.d C.K C.tail f z (C.small f z) b) : |
| EndAt C.d C.K C.tail f' z (C.small f' z) (b+((y.length:ℤ)-x.length)) := by |
| have hs := (C.searches_congr hvis (H.agrees_left (le_refl N))).1 |
| rw [←hs] |
| cases hη : C.small f z with |
| | some q => |
| have hq := (EndSearch.search_some C.B_pos C.S_nonneg).mp hη |
| have hw := (EndSearch.width_bounds (x := q-z) (a := C.d) C.B_pos C.S_nonneg).2 |
| have hbd := (abs_le.mp (hq.1.2.trans hw)).2 |
| rw [hη] at he |
| change b=q+C.tail at he |
| omega |
| | none => |
| rw [hη] at he |
| exact H.endAt_none hvis.2.2.2 hb hd hm he |
|
|
| end StreamSplice.Frame |
|
|
| namespace CanonicalEpisodes.Parameters |
|
|
| open LocalMarkers WordIntervals EpisodeEnd StreamSplice |
|
|
| variable {Alphabet : Type uAlphabet3} (C : CanonicalEpisodes.Parameters Alphabet) |
|
|
| lemma exists_horizon (z : ℤ) : ∃ N : ℕ, |
| C.Visible (-(N:ℤ)) N z ∧ z+(C.d:ℤ)+(C.B-1)*C.S<N := by |
| obtain ⟨N,hN⟩ := exists_nat_gt (|z|+C.width+|C.rule.r|+C.K+1) |
| have hz := abs_le.mp (le_refl |z|) |
| have hr := abs_le.mp (le_refl |C.rule.r|) |
| have hw := C.width_nonneg |
| have hs := C.small_width_le |
| refine ⟨N,⟨by omega,by omega,by omega,by omega⟩,by omega⟩ |
|
|
| lemma visible_long {z : ℤ} {N : ℕ} (h : C.Visible (-(N:ℤ)) N z) |
| {b : ℤ} (hb : (N:ℤ)≤b) (hl : 0≤z-C.width-C.rule.r) (hz : 0≤z) : |
| C.Visible 0 b z := ⟨hl,h.2.1.trans hb,hz,h.2.2.2.trans hb⟩ |
|
|
| lemma complete_regular [Finite Alphabet] (lag : ℤ) : (C.complete lag).IsRegular := by |
| classical |
| obtain ⟨N,hN,hs⟩ := C.exists_horizon (lag+C.offset) |
| let : NeZero C.d.factorial := ⟨Nat.factorial_ne_zero C.d⟩ |
| let T := (PeriodicSummary.lengthMod C.d.factorial (Alphabet := Alphabet)).prod |
| (PeriodicSummary.transition (p := C.d.factorial)) |
| let : Fintype Alphabet := Fintype.ofFinite Alphabet |
| let : Fintype (Function.End (Option (ZMod C.d.factorial)))ᵐᵒᵖ := |
| Fintype.ofEquiv (Option (ZMod C.d.factorial) → Option (ZMod C.d.factorial)) |
| (Equiv.refl _ |>.trans MulOpposite.opEquiv) |
| apply FiniteRecognition.regular_sandwich T N C.tail.toNat |
| intro a b x y ha hb he |
| have hh : C.tail.toNat=C.tail := Int.toNat_of_nonneg C.tail_pos.le |
| have trans : ∀ (x y : List Alphabet), T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y) → |
| a++x++b∈C.complete lag → a++y++b∈C.complete lag := by |
| intro x y he hw |
| obtain ⟨f,hf,hv,hend⟩ := hw |
| let f' := splice f N x y |
| have H : Frame f f' N x y := by simpa only [ha] using splice_frame hf y |
| have hnew := H.endAt hN hs (by simp only [List.length_append,Nat.cast_add,ha,hb];omega) |
| (PeriodicSummary.lengthMod_dvd (congrArg Prod.fst he)) (congrArg Prod.snd he) hend |
| refine ⟨f',?_,?_,?_⟩ |
| · simpa only [f',ha] using splice_realizes hf y |
| · exact C.visible_long hN (by simp only [List.length_append,Nat.cast_add,ha,hb];omega) |
| hv.1 hv.2.2.1 |
| · convert hnew using 1 |
| simp only [List.length_append,Nat.cast_add] |
| omega |
| exact ⟨trans x y he,trans y x he.symm⟩ |
|
|
| end CanonicalEpisodes.Parameters |
| namespace EpisodeAlgebra |
|
|
| variable {Alphabet : Type uAlphabet4} |
|
|
| def remainder (E : Language Alphabet) : Language Alphabet := |
| {w | ∀ e∈E, ¬ e <+: w} |
|
|
| lemma remainder_eq (E : Language Alphabet) : remainder E=(E*⊤)ᶜ := by |
| ext w |
| constructor |
| · intro h hw |
| obtain ⟨e,he,v,_,rfl⟩ := hw |
| exact h e he ⟨v,rfl⟩ |
| · intro h e he ⟨v,hv⟩ |
| exact h ⟨e,he,v,Set.mem_univ _,hv⟩ |
|
|
| lemma factor_remainder {E : Language Alphabet} (hnil : []∉E) (w : List Alphabet) : |
| ∃ es r, AllIn E es ∧ r∈remainder E ∧ w=es.flatten++r := by |
| classical |
| induction hlen : w.length using Nat.strong_induction_on generalizing w with |
| | h n ih => |
| by_cases h : w∈remainder E |
| · exact ⟨[],w,by simp [AllIn],h,by simp⟩ |
| · change ¬∀ e∈E, ¬ e <+: w at h |
| push Not at h |
| obtain ⟨e,he,hp⟩ := h |
| obtain ⟨v,rfl⟩ := hp |
| have hpos : 0<e.length := by |
| by_contra h |
| exact hnil ((List.length_eq_zero_iff.mp (by omega : e.length=0)) ▸ he) |
| obtain ⟨es,r,hes,hr,hv⟩ := ih v.length (by simp only [List.length_append] at hlen;omega) v rfl |
| refine ⟨e::es,r,fun a ha => ?_,hr,?_⟩ |
| · rcases List.mem_cons.mp ha with rfl|ha |
| · exact he |
| · exact hes a ha |
| · simp only [List.flatten_cons,List.append_assoc,hv] |
|
|
| end EpisodeAlgebra |
|
|
| namespace EpisodeEnd |
|
|
| open LocalMarkers |
| variable {Alphabet : Type uAlphabet5} |
|
|
| lemma firstMismatch_of_disagrees {d K : ℕ} {f v : ℤ → Alphabet} {z q : ℤ} |
| (hv : ShortContinuation d K f z v) (hq : z≤q) (hm : f q≠v q) : |
| ∃ q', q'≤q ∧ FirstMismatch f v z K q' := by |
| rcases MarkerSearch.search_some_or_none {x | f x≠v x} z q with hn|⟨q',hq',hle⟩ |
| · exact False.elim (hn q hm hq le_rfl) |
| · refine ⟨q',hle,?_,hq'.1,?_⟩ |
| · by_contra h |
| exact hq'.1 (hv.2 q' hq'.2.1 (by omega)) |
| · intro x hx hx' |
| by_contra h |
| exact (not_le_of_gt hx') (hq'.2.2 x h hx) |
|
|
| end EpisodeEnd |
|
|
| namespace CanonicalEpisodes.Parameters |
|
|
| open LocalMarkers WordIntervals EpisodeEnd EpisodeAlgebra |
|
|
| variable {Alphabet : Type uAlphabet6} (C : CanonicalEpisodes.Parameters Alphabet) |
|
|
| lemma complete_prefix {lag b : ℤ} {w : List Alphabet} {f : ℤ → Alphabet} |
| (hf : Realizes w 0 f) (hv : C.Visible 0 b (lag+C.offset)) |
| (he : EndAt C.d C.K C.tail f (lag+C.offset) (C.small f (lag+C.offset)) b) |
| (hb : b≤w.length) : ∃ e∈C.complete lag, e<+:w := by |
| have hb0 : 0≤b := hv.2.2.1.trans (le_trans (by omega) hv.2.2.2) |
| let e := w.take b.toNat |
| have hl : (e.length:ℤ)=b := by |
| simp only [e,List.length_take] |
| omega |
| refine ⟨e,⟨f,hf.prefix (List.take_prefix _ _),?_,?_⟩,List.take_prefix _ _⟩ |
| · simpa only [hl] using hv |
| · simpa only [hl] using he |
|
|
| lemma remainder_middle [Nonempty Alphabet] (lag : ℤ) |
| (hvisible : ∀ (f : ℤ → Alphabet) b, |
| EndAt C.d C.K C.tail f (lag+C.offset) (C.small f (lag+C.offset)) b → |
| C.Visible 0 b (lag+C.offset)) : |
| ∃ N : ℕ, ∀ w∈remainder (C.complete lag), |
| w.length≤N+C.tail.toNat ∨ ∃ (f v : ℤ → Alphabet) (p : ℕ), |
| Realizes w 0 f ∧ N+C.tail.toNat≤w.length ∧ 0<p ∧ p≤C.d ∧ |
| Function.Periodic v (p:ℤ) ∧ AgreesOn f v N (w.length-C.tail.toNat) := by |
| obtain ⟨N,hN,hs⟩ := C.exists_horizon (lag+C.offset) |
| refine ⟨N,?_⟩ |
| intro w hw |
| by_cases hlen : w.length≤N+C.tail.toNat |
| · exact Or.inl hlen |
| · right |
| obtain ⟨f,hf⟩ := realizes_exists w 0 |
| have htail : (C.tail.toNat:ℤ)=C.tail := Int.toNat_of_nonneg C.tail_pos.le |
| have hnone : C.small f (lag+C.offset)=none := by |
| cases hη : C.small f (lag+C.offset) with |
| | none => rfl |
| | some q => |
| have hq := ((EndSearch.search_some C.B_pos C.S_nonneg).mp hη).1.2 |
| have hwidth := (EndSearch.width_bounds (x := q-(lag+C.offset)) (a := C.d) |
| C.B_pos C.S_nonneg).2 |
| have hright := (abs_le.mp (hq.trans hwidth)).2 |
| have he : EndAt C.d C.K C.tail f (lag+C.offset) |
| (C.small f (lag+C.offset)) (q+C.tail) := by rw [hη];rfl |
| obtain ⟨e,he,hp⟩ := C.complete_prefix hf (hvisible f _ he) he (by omega) |
| exact False.elim (hw e he hp) |
| obtain ⟨v,hv⟩ := EndSearch.absent_continuation C.rule |
| (by nlinarith [C.seed_long]) C.B_pos C.S_nonneg hnone |
| obtain ⟨p,hp,hpd,hper⟩ := hv.1 |
| refine ⟨f,v,p,hf,by omega,hp,hpd.le,hper,?_⟩ |
| intro q hq hq' |
| by_contra hm |
| have hzq : lag+C.offset≤q := by have := hN.2.2.2;omega |
| obtain ⟨q',hle,hm'⟩ := firstMismatch_of_disagrees hv hzq hm |
| have he : EndAt C.d C.K C.tail f (lag+C.offset) |
| (C.small f (lag+C.offset)) (q'+C.tail) := by |
| rw [hnone] |
| exact ⟨v,hv,by simpa only [add_sub_cancel_right] using hm'⟩ |
| obtain ⟨e,he,hpre⟩ := C.complete_prefix hf (hvisible f _ he) he (by omega) |
| exact hw e he hpre |
|
|
| lemma remainder_regular [Finite Alphabet] (lag : ℤ) : |
| (remainder (C.complete lag)).IsRegular := by |
| rw [remainder_eq] |
| apply Language.IsRegular.compl |
| apply FiniteRecognition.regular_mul (C.complete_regular lag) |
| have ht : (⊤ : Language Alphabet)=(0 : Language Alphabet)ᶜ := by |
| ext w |
| change True ↔ ¬False |
| simp |
| rw [ht] |
| exact Language.IsRegular.compl (FiniteRecognition.regular_finite Set.finite_empty) |
|
|
| lemma remainder_height [Finite Alphabet] [Nonempty Alphabet] (lag : ℤ) |
| (hvisible : ∀ (f : ℤ → Alphabet) b, |
| EndAt C.d C.K C.tail f (lag+C.offset) (C.small f (lag+C.offset)) b → |
| C.Visible 0 b (lag+C.offset)) : |
| HasHeightAtMost (remainder (C.complete lag)) 1 := by |
| obtain ⟨N,hN⟩ := C.remainder_middle lag hvisible |
| exact PeriodicTemplates.regular_middle_height _ (C.remainder_regular lag) |
| (N+C.tail.toNat) N C.tail.toNat C.d hN |
|
|
| end CanonicalEpisodes.Parameters |
| namespace ExceptionalOrigins.Parameters |
|
|
| open LocalMarkers |
| variable {Alphabet : Type uAlphabet7} {J : Type uJ} {C : Type uC} (A : ExceptionalOrigins.Parameters Alphabet J C) |
|
|
| lemma residue_eq_of_dvd {x y : ℤ} (h : (A.B:ℤ)∣y-x) : A.residue x=A.residue y := by |
| apply Fin.ext |
| have he : x%A.B=y%A.B := Int.modEq_iff_dvd.mpr h |
| exact congrArg Int.toNat he |
|
|
| lemma exists_horizon [Fintype J] (D : ℕ) : ∃ N : ℕ, D<N ∧ |
| ∀ (t : ℤ), |t|≤(D:ℤ) → ∀ Q, A.Visible (-(N:ℤ)) N t Q := by |
| let U : ℤ := (SourceSchedule.absoluteBound A.offset:ℤ) |
| let H : ℤ := (SourceSchedule.absoluteBound A.H:ℤ) |
| obtain ⟨N,hN⟩ := exists_nat_gt ((D:ℤ)+|A.endRule.offset|+A.endRule.width+ |
| |A.endRule.rule.r|+A.endRule.K+|A.w|+U+H+|A.w₀|+|A.ext|+|A.innerRule.r|+1) |
| have hwidth := A.endRule.width_nonneg |
| have hU : 0≤U := by dsimp [U];positivity |
| have hH : 0≤H := by dsimp [H];positivity |
| have hoff := abs_le.mp (le_refl |A.endRule.offset|) |
| have hr := abs_le.mp (le_refl |A.endRule.rule.r|) |
| have hir := abs_le.mp (le_refl |A.innerRule.r|) |
| have hw := abs_le.mp (le_refl |A.w|) |
| have hw₀ := abs_le.mp (le_refl |A.w₀|) |
| have hext := abs_le.mp (le_refl |A.ext|) |
| refine ⟨N,by omega,?_⟩ |
| intro t ht Q |
| have ht' := abs_le.mp ht |
| refine ⟨⟨by omega,by omega,by omega,by omega⟩,?_,?_⟩ |
| · intro v _ hv |
| have hv' := abs_le.mp hv |
| constructor <;> omega |
| · intro j |
| have hj : |A.offset j|≤U := SourceSchedule.abs_le_absoluteBound A.offset j |
| have hH' : |A.H (A.residue (Q-t))|≤H := SourceSchedule.abs_le_absoluteBound A.H _ |
| have hj' := abs_le.mp hj |
| have hH'' := abs_le.mp hH' |
| have hmax : max A.ext A.w₀≤|A.ext|+|A.w₀| := by apply max_le <;> omega |
| constructor <;> omega |
|
|
| lemma Failed_phase_congr {s b t Q Q' : ℤ} {f g : ℤ → Alphabet} |
| (hw₀ : 0≤A.w₀) (hv : A.Visible s b t Q) (he : AgreesOn f g s b) |
| (hφ : A.φ (Q-t)=A.φ (Q'-t)) (hu : A.residue (Q-t)=A.residue (Q'-t)) : |
| A.Failed f t Q ↔ A.Failed g t Q' := by |
| rw [A.Failed_congr hw₀ hv he] |
| simp only [Failed,Star,hφ,hu] |
|
|
| end ExceptionalOrigins.Parameters |
|
|
| end GeneralizedStarHeight |
|
|
| end OAI |
|
|
