import OAI.Computability.StarHeight.PeriodicSplicing

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uJ uC uAlphabet2 uJ2 uC2 uAlphabet3 uAlphabet4
universe uJ3 uC3 uAlphabet5 uM uAlphabet6 uJ4 uC4 uP
universe uAlphabet7 uM2 uJ5 uC5 uAlphabet8 uAlphabet9 uJ6 uC6

namespace StreamSplice.Frame

open LocalMarkers WordIntervals
variable {Alphabet : Type uAlphabet} {J : Type uJ} {C : Type uC} {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet}
    (H : Frame f f' N x y) (A : ExceptionalOrigins.Parameters Alphabet J C)

include H

lemma anchor_phase {t b : ℤ} (hv : A.endRule.Visible (-N) N (t+A.endRule.offset))
    (hd : (A.B:ℤ) ∣ (y.length:ℤ)-x.length)
    (hφ : A.φ ((y.length:ℤ)-x.length)=0) :
    A.residue (A.anchor f (b-A.endRule.tail) t-t)=
      A.residue (A.anchor f' (b+((y.length:ℤ)-x.length)-A.endRule.tail) t-t) ∧
    A.φ (A.anchor f (b-A.endRule.tail) t-t)=
      A.φ (A.anchor f' (b+((y.length:ℤ)-x.length)-A.endRule.tail) t-t) := by
  have hs := (A.endRule.searches_congr hv (H.agrees_left (le_refl N))).2
  unfold ExceptionalOrigins.Parameters.anchor
  rw [←hs]
  cases hζ : A.endRule.large f (t+A.endRule.offset) with
  | some q => simp only [Option.getD_some,and_self]
  | none =>
    simp only [Option.getD_none]
    constructor
    · apply A.residue_eq_of_dvd
      convert hd using 1
      ring
    · rw [show b+((y.length:ℤ)-x.length)-A.endRule.tail-t=
        (b-A.endRule.tail-t)+((y.length:ℤ)-x.length) by ring,map_add,hφ,add_zero]

lemma failed {t b : ℤ} (hw₀ : 0≤A.w₀)
    (hv : A.Visible (-N) N t (A.anchor f (b-A.endRule.tail) t))
    (hd : (A.B:ℤ) ∣ (y.length:ℤ)-x.length)
    (hφ : A.φ ((y.length:ℤ)-x.length)=0) :
    A.Failed f t (A.anchor f (b-A.endRule.tail) t) ↔
      A.Failed f' t (A.anchor f' (b+((y.length:ℤ)-x.length)-A.endRule.tail) t) := by
  have hphase := H.anchor_phase A (b := b) hv.base hd hφ
  exact A.Failed_phase_congr hw₀ hv (H.agrees_left (le_refl N)) hphase.2 hphase.1

end StreamSplice.Frame

namespace ExceptionalOrigins.Parameters

open LocalMarkers WordIntervals StreamSplice
variable {Alphabet : Type uAlphabet2} {J : Type uJ2} {C : Type uC2} (A : ExceptionalOrigins.Parameters Alphabet J C)

def failedLanguage (t : ℤ) : Language Alphabet := {w | ∃ f : ℤ → Alphabet,
  Realizes w 0 f ∧ A.Failed f t (A.anchor f (w.length-A.endRule.tail) t)}

lemma failed_regular [Finite Alphabet] [Fintype J] (n : ℕ) (hn : 0<n)
    (hφ : A.φ (n:ℤ)=0) (hw₀ : 0≤A.w₀) (t : ℤ) : (A.failedLanguage t).IsRegular := by
  classical
  obtain ⟨N,_,hN⟩ := A.exists_horizon t.natAbs
  have ht : |t|≤(t.natAbs:ℤ) := by rw [Int.natCast_natAbs]
  let : NeZero (A.B*n) := ⟨Nat.ne_of_gt (Nat.mul_pos A.B_pos hn)⟩
  let T := PeriodicSummary.lengthMod (Alphabet := Alphabet) (A.B*n)
  apply FiniteRecognition.regular_sandwich T N 0
  intro a b x y ha hb he
  have hbnil : b=[] := List.length_eq_zero_iff.mp hb
  subst b
  have trans : ∀ x y : List Alphabet, T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y) →
      a++x++[]∈A.failedLanguage t → a++y++[]∈A.failedLanguage t := by
    intro x y he ⟨f,hf,hfail⟩
    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 hdiv := PeriodicSummary.lengthMod_dvd he
    have hB : (A.B:ℤ)∣(y.length:ℤ)-x.length :=
      (show (A.B:ℤ)∣(A.B*n:ℕ) by exact_mod_cast dvd_mul_right A.B n).trans hdiv
    have hn' : (n:ℤ)∣(y.length:ℤ)-x.length :=
      (show (n:ℤ)∣(A.B*n:ℕ) by exact_mod_cast dvd_mul_left n A.B).trans hdiv
    have hδ : A.φ ((y.length:ℤ)-x.length)=0 := by
      obtain ⟨k,hk⟩ := hn'
      rw [hk,mul_comm,←Int.zsmul_eq_mul,map_zsmul,hφ,smul_zero]
    have hh := (H.failed A hw₀ (hN t ht _) hB hδ).mp hfail
    refine ⟨f',by simpa only [ha] using splice_realizes hf y,?_⟩
    have hl : ((a++y++[]).length:ℤ)=((a++x++[]).length:ℤ)+((y.length:ℤ)-x.length) := by
      simp only [List.length_append,List.length_nil,Nat.cast_add,Nat.cast_zero]
      omega
    rw [hl]
    exact hh
  exact ⟨trans x y he,trans y x he.symm⟩

end ExceptionalOrigins.Parameters
namespace CanonicalEpisodes.Parameters

open LocalMarkers
variable {Alphabet : Type uAlphabet3} (C : CanonicalEpisodes.Parameters Alphabet)

lemma exists_uniform_horizon (D : ℕ) : ∃ N : ℕ, D<N ∧ ∀ (t : ℤ), |t|≤(D:ℤ) →
    C.Visible (-(N:ℤ)) N (t+C.offset) ∧
      t+C.offset+(C.d:ℤ)+(C.B-1)*C.S<N := by
  obtain ⟨N,hN⟩ := exists_nat_gt ((D:ℤ)+|C.offset|+C.width+|C.rule.r|+C.K+1)
  have ho := abs_le.mp (le_refl |C.offset|)
  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,?_⟩
  intro t ht
  have ht' := abs_le.mp ht
  exact ⟨⟨by omega,by omega,by omega,by omega⟩,by omega⟩

end CanonicalEpisodes.Parameters

namespace ExceptionalOrigins.Parameters

open LocalMarkers
variable {Alphabet : Type uAlphabet4} {J : Type uJ3} {C : Type uC3} (A : ExceptionalOrigins.Parameters Alphabet J C)

lemma exists_inner_horizon [Fintype J] (D : ℕ) : ∃ N : ℕ, D<N ∧
    ∀ (t : ℤ), |t|≤(D:ℤ) → ∀ j u, A.InnerVisible (-(N:ℤ)) N t j u := by
  let U : ℤ := (SourceSchedule.absoluteBound A.offset:ℤ)
  let H : ℤ := (SourceSchedule.absoluteBound A.H:ℤ)
  obtain ⟨N,hN⟩ := exists_nat_gt ((D:ℤ)+U+H+|A.innerRule.r|+1)
  have hU : 0≤U := by dsimp [U];positivity
  have hH : 0≤H := by dsimp [H];positivity
  have hr := abs_le.mp (le_refl |A.innerRule.r|)
  refine ⟨N,by omega,?_⟩
  intro t ht j u
  have ht' := abs_le.mp ht
  have hj' := abs_le.mp (SourceSchedule.abs_le_absoluteBound A.offset j)
  have hu' := abs_le.mp (SourceSchedule.abs_le_absoluteBound A.H u)
  change -↑N≤t+A.offset j-A.innerRule.r ∧ t+A.offset j+A.H u+A.innerRule.r≤N
  dsimp [U,H] at hN
  constructor <;> omega

lemma InnerVisible.mono {s b s' b' t : ℤ} {j : J} {u : Fin A.B}
    (hv : A.InnerVisible s b t j u) (hs : s' ≤ s) (hb : b ≤ b') :
    A.InnerVisible s' b' t j u := ⟨hs.trans hv.1,hv.2.trans hb⟩

lemma Visible.from_bounds {s b s' N b' t Q Q' : ℤ}
    (hv : A.Visible s b t Q) (hN : A.Visible s' N t Q')
    (hb : N ≤ b') : A.Visible s b' t Q' := by
  refine ⟨⟨hv.base.1,hN.base.2.1.trans hb,hv.base.2.2.1,hN.base.2.2.2.trans hb⟩,?_,?_⟩
  · intro v hv' hw
    exact ⟨(hv.ends v hv' hw).1,(hN.ends v hv' hw).2.trans hb⟩
  · intro j
    exact ⟨(hv.inner j).1,(hN.inner j).2.trans hb⟩

end ExceptionalOrigins.Parameters

namespace StreamSplice.Frame

open LocalMarkers WordIntervals BoundarySnapshot
variable {Alphabet : Type uAlphabet5} {M : Type uM} [Monoid M] {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet}
    (H : Frame f f' N x y) (T : FreeMonoid Alphabet →* M)

include H

lemma factors {g : ℕ} {s b : ℤ} (hb : N+x.length≤b)
    (hT : T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y))
    (search : Fin (g+1) → Option ℤ) (hsearch : ∀ i q, search i=some q → q≤N) :
    BoundarySnapshot.factors T f' s (b+((y.length:ℤ)-x.length)) search=
      BoundarySnapshot.factors T f s b search := by
  classical
  have hbN : N≤b := by omega
  have hbN' : N≤b+((y.length:ℤ)-x.length) := by omega
  have hp : Present search s b ↔ Present search s (b+((y.length:ℤ)-x.length)) := by
    constructor
    · rintro ⟨p,hp,hm,hs,_⟩
      exact ⟨p,hp,hm,hs,(hsearch _ _ (hp _)).trans hbN'⟩
    · rintro ⟨p,hp,hm,hs,_⟩
      exact ⟨p,hp,hm,hs,(hsearch _ _ (hp _)).trans hbN⟩
  by_cases hpres : Present search s b
  · obtain ⟨p,hp',hm,hs',hb'⟩ := hpres
    rw [factors_present T f hp' hm hs' hb',
      factors_present T f' hp' hm hs' ((hsearch _ _ (hp' _)).trans hbN')]
    congr 2
    · exact (product_congr T hs' (H.agrees_left (hsearch _ _ (hp' _)))).symm
    · funext i
      exact (product_congr T (hm (Fin.castSucc_le_succ i))
        (H.agrees_left (hsearch _ _ (hp' _)))).symm
    · exact H.product T hT (hsearch _ _ (hp' _)) hb
  · simp only [BoundarySnapshot.factors,dite_eq_right hpres,dite_eq_right (mt hp.mpr hpres)]

lemma later {g : ℕ} {s b : ℤ} (hs : s≤N) (hb : N+x.length≤b)
    (hT : T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y))
    (search : Fin (g+1) → Option ℤ) (hsearch : ∀ i q, search i=some q → q≤N) :
    BoundarySnapshot.later T f' s (b+((y.length:ℤ)-x.length)) search=
      BoundarySnapshot.later T f s b search := by
  apply BoundarySnapshot.later_ext
  · exact H.product T hT hs hb
  · exact H.factors T hb hT search hsearch

end StreamSplice.Frame

namespace StreamSplice.Frame

open LocalMarkers WordIntervals
variable {Alphabet : Type uAlphabet6} {J : Type uJ4} {C : Type uC4} {f f' : ℤ → Alphabet} {N : ℤ} {x y : List Alphabet}
    (H : Frame f f' N x y)

include H

lemma guard (E : CanonicalEpisodes.Parameters Alphabet) {O : Finset ℤ} {r k b : ℤ}
    (hN : ∀ t∈O, E.Visible (-N) N (t+E.offset) ∧
      t+E.offset+(E.d:ℤ)+(E.B-1)*E.S<N)
    (hb : N+x.length≤b-E.tail)
    (hd : (E.d.factorial:ℤ)∣(y.length:ℤ)-x.length)
    (hm : PeriodicSummary.transition (p := E.d.factorial) (FreeMonoid.ofList x)=
      PeriodicSummary.transition (FreeMonoid.ofList y))
    (hg : E.Guard O r k b f) : E.Guard O r k (b+((y.length:ℤ)-x.length)) f' := by
  have hbN : N≤b+((y.length:ℤ)-x.length) := by have := E.tail_pos;omega
  have hs := fun t ht => E.searches_congr (hN t ht).1 (H.agrees_left (le_refl N))
  refine ⟨hg.1,?_,?_,H.endAt (hN r hg.1).1 (hN r hg.1).2 hb hd hm hg.2.2.2⟩
  · intro t ht
    have hv := hg.2.1 t ht
    have hv' := (hN t ht).1
    exact ⟨hv.1,hv'.2.1.trans hbN,hv.2.2.1,hv'.2.2.2.trans hbN⟩
  · intro t ht
    rw [←(hs t ht).1,←(hs r hg.1).1,←(hs t ht).2,←(hs r hg.1).2]
    exact hg.2.2.1 t ht

lemma anchor_relative_phase (A : ExceptionalOrigins.Parameters Alphabet J C) {t b r : ℤ}
    (hv : A.endRule.Visible (-N) N (t+A.endRule.offset))
    (hd : (A.B:ℤ)∣(y.length:ℤ)-x.length)
    (hφ : A.φ ((y.length:ℤ)-x.length)=0) :
    A.residue (A.anchor f (b-A.endRule.tail) t-r)=
      A.residue (A.anchor f' (b+((y.length:ℤ)-x.length)-A.endRule.tail) t-r) ∧
    A.φ (A.anchor f (b-A.endRule.tail) t-r)=
      A.φ (A.anchor f' (b+((y.length:ℤ)-x.length)-A.endRule.tail) t-r) := by
  have hs := (A.endRule.searches_congr hv (H.agrees_left (le_refl N))).2
  unfold ExceptionalOrigins.Parameters.anchor
  rw [←hs]
  cases A.endRule.large f (t+A.endRule.offset) with
  | some q => simp only [Option.getD_some,and_self]
  | none =>
    simp only [Option.getD_none]
    constructor
    · apply A.residue_eq_of_dvd
      convert hd using 1
      ring
    · rw [show b+((y.length:ℤ)-x.length)-A.endRule.tail-r=
        (b-A.endRule.tail-r)+((y.length:ℤ)-x.length) by ring,map_add,hφ,add_zero]

lemma decoder (A : ExceptionalOrigins.Parameters Alphabet J C) {P : Type uP}
    {τ : P → ℤ} {reference decoded : P} {k b : ℤ} (hw₀ : 0≤A.w₀)
    (hN : ∀ t, A.Visible (-N) N (τ t) (A.anchor f (b-A.endRule.tail) (τ t)))
    (hN' : ∀ t Q, A.Visible (-N) N (τ t) Q)
    (hstrict : ∀ t, τ t+A.endRule.offset+(A.endRule.d:ℤ)+
      (A.endRule.B-1)*A.endRule.S<N)
    (hb : N+x.length≤b-A.endRule.tail)
    (hd : (A.endRule.d.factorial:ℤ)∣(y.length:ℤ)-x.length)
    (hm : PeriodicSummary.transition (p := A.endRule.d.factorial) (FreeMonoid.ofList x)=
      PeriodicSummary.transition (FreeMonoid.ofList y))
    (hB : (A.B:ℤ)∣(y.length:ℤ)-x.length) (hφ : A.φ ((y.length:ℤ)-x.length)=0)
    (ht : SuffixDecoder.Test A τ reference k b f decoded) :
    SuffixDecoder.Test A τ reference k (b+((y.length:ℤ)-x.length)) f' decoded := by
  have hbN : N≤b+((y.length:ℤ)-x.length) := by have := A.endRule.tail_pos;omega
  have hs := fun t => A.endRule.searches_congr (hN t).base (H.agrees_left (le_refl N))
  have hfail := fun t => H.failed A hw₀ (hN t) hB hφ
  refine ⟨?_,?_,⟨(hfail decoded).mp ht.unique.1,?_⟩,?_⟩
  · intro t
    exact ExceptionalOrigins.Parameters.Visible.from_bounds A (ht.visible t) (hN' t _) hbN
  · intro habsent
    have ha : ∃ i, A.endRule.large f (τ i+A.endRule.offset)=none := by
      obtain ⟨i,hi⟩ := habsent
      exact ⟨i,(hs i).2.trans hi⟩
    have hg := ht.reference_guard ha
    refine ⟨fun i => (hs i).1.symm.trans (hg.1 i),?_⟩
    exact H.endAt (hN reference).base (hstrict reference) hb hd hm hg.2
  · intro i hi
    exact ht.unique.2 i ((hfail i).mpr hi)
  · exact H.endAt (hN decoded).base (hstrict decoded) hb hd hm ht.final_guard

end StreamSplice.Frame
namespace StreamSplice

open LocalMarkers WordIntervals
variable {Alphabet : Type uAlphabet7} {M : Type uM2} {J : Type uJ5} {C : Type uC5} [Monoid M]

def wordTest (R : (ℤ → Alphabet) → ℤ → Prop) : Language Alphabet :=
  {w | ∃ f, Realizes w 0 f ∧ R f w.length}

structure SummaryEq (A : ExceptionalOrigins.Parameters Alphabet J C)
    (T : FreeMonoid Alphabet →* M) (x y : List Alphabet) : Prop where
  monoid_eq : T (FreeMonoid.ofList x)=T (FreeMonoid.ofList y)
  residue_dvd : (A.B:ℤ)∣(y.length:ℤ)-x.length
  period_dvd : (A.endRule.d.factorial:ℤ)∣(y.length:ℤ)-x.length
  matcher_eq : PeriodicSummary.transition (p := A.endRule.d.factorial) (FreeMonoid.ofList x)=
    PeriodicSummary.transition (FreeMonoid.ofList y)
  clock_eq : A.φ ((y.length:ℤ)-x.length)=0

lemma clock_eq_of_dvd (φ : ℤ →+ (C → RobustClock.Circle)) {n : ℕ}
    (hφ : φ (n:ℤ)=0) {δ : ℤ} (hδ : (n:ℤ)∣δ) : φ δ=0 := by
  obtain ⟨k,rfl⟩ := hδ
  rw [mul_comm,←Int.zsmul_eq_mul,map_zsmul,hφ,smul_zero]

lemma wordTest_regular [Finite Alphabet] [Finite M]
    (A : ExceptionalOrigins.Parameters Alphabet J C) (T : FreeMonoid Alphabet →* M)
    (n : ℕ) (hn : 0<n) (hφ : A.φ (n:ℤ)=0) (N : ℕ)
    (R : (ℤ → Alphabet) → ℤ → Prop)
    (hc : ∀ (f f' : ℤ → Alphabet) (b : ℤ) (x y : List Alphabet),
      Frame f f' N x y → (N:ℤ)+x.length≤b-A.endRule.tail →
      SummaryEq A T x y → R f b → R f' (b+((y.length:ℤ)-x.length))) :
    (wordTest R).IsRegular := by
  classical
  let p := A.endRule.d.factorial
  let m := A.B*n*p
  have hp : 0<p := Nat.factorial_pos _
  have hm : 0 < m := Nat.mul_pos (Nat.mul_pos A.B_pos hn) hp
  let : NeZero m := ⟨Nat.ne_of_gt hm⟩
  let : NeZero p := ⟨Nat.ne_of_gt hp⟩
  let : Fintype Alphabet := Fintype.ofFinite Alphabet
  let : Fintype M := Fintype.ofFinite M
  let : Fintype ((Function.End (Option (ZMod p)))ᵐᵒᵖ) :=
    Fintype.ofEquiv (Option (ZMod p) → Option (ZMod p))
      (Equiv.refl _ |>.trans MulOpposite.opEquiv)
  let U := (T.prod (PeriodicSummary.lengthMod m)).prod (PeriodicSummary.transition (p := p))
  apply FiniteRecognition.regular_sandwich U N A.endRule.tail.toNat
  intro a b x y ha hb he
  have ht : (A.endRule.tail.toNat:ℤ)=A.endRule.tail := Int.toNat_of_nonneg A.endRule.tail_pos.le
  have trans : ∀ (x y : List Alphabet), U (FreeMonoid.ofList x)=U (FreeMonoid.ofList y) →
      a++x++b∈wordTest R → a++y++b∈wordTest R := by
    intro x y he ⟨f,hf,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 hdiv := PeriodicSummary.lengthMod_dvd (congrArg (Prod.snd ∘ Prod.fst) he)
    have hB : (A.B:ℤ)∣(y.length:ℤ)-x.length :=
      (show (A.B:ℤ)∣(m:ℤ) by exact_mod_cast dvd_mul_of_dvd_left (dvd_mul_right A.B n) p).trans hdiv
    have hn' : (n:ℤ)∣(y.length:ℤ)-x.length :=
      (show (n:ℤ)∣(m:ℤ) by exact_mod_cast dvd_mul_of_dvd_left (dvd_mul_left n A.B) p).trans hdiv
    have hp' : (p:ℤ)∣(y.length:ℤ)-x.length :=
      (show (p:ℤ)∣(m:ℤ) by exact_mod_cast dvd_mul_left p (A.B*n)).trans hdiv
    have hh := hc f f' _ x y H (by simp only [List.length_append,Nat.cast_add,ha,hb];omega)
      ⟨congrArg (Prod.fst ∘ Prod.fst) he,hB,hp',congrArg Prod.snd he,clock_eq_of_dvd A.φ hφ hn'⟩ hw
    refine ⟨f',by simpa only [ha] using splice_realizes hf y,?_⟩
    have hl : ((a++y++b).length:ℤ)=((a++x++b).length:ℤ)+((y.length:ℤ)-x.length) := by
      simp only [List.length_append,Nat.cast_add]
      omega
    rw [hl]
    exact hh
  exact ⟨trans x y he,trans y x he.symm⟩

end StreamSplice

namespace CanonicalEpisodes.Parameters

open LocalMarkers WordIntervals EpisodeEnd
variable {Alphabet : Type uAlphabet8} (C : CanonicalEpisodes.Parameters Alphabet)

lemma ending_middle (L : Language Alphabet) (D : ℕ)
    (hL : ∀ w∈L, ∃ f t, Realizes w 0 f ∧ |t|≤(D:ℤ) ∧
      EndAt C.d C.K C.tail f (t+C.offset) (C.small f (t+C.offset)) w.length) :
    ∃ N : ℕ, ∀ w∈L, 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⟩ := C.exists_uniform_horizon D
  refine ⟨N,?_⟩
  intro w hw
  by_cases hl : w.length≤N+C.tail.toNat
  · exact Or.inl hl
  · right
    obtain ⟨f,t,hf,ht,he⟩ := hL w hw
    have htail : (C.tail.toNat:ℤ)=C.tail := Int.toNat_of_nonneg C.tail_pos.le
    cases hη : C.small f (t+C.offset) with
    | some q =>
      have hq := ((EndSearch.search_some C.B_pos C.S_nonneg).mp hη).1.2
      have hwidth := (EndSearch.width_bounds (x := q-(t+C.offset)) (a := C.d)
        C.B_pos C.S_nonneg).2
      have hright := (abs_le.mp (hq.trans hwidth)).2
      rw [hη] at he
      change (w.length:ℤ)=q+C.tail at he
      have hs := (hN t ht).2
      omega
    | none =>
      rw [hη] at he
      obtain ⟨v,hv,hmis⟩ := he
      obtain ⟨p,hp,hpd,hper⟩ := hv.1
      refine ⟨f,v,p,hf,by omega,hp,hpd.le,hper,?_⟩
      intro z hz hz'
      have hseed := (hN t ht).1.2.2.2
      exact hmis.2.2 z (by omega) (by omega)

lemma ending_height [Finite Alphabet] (L : Language Alphabet) (hreg : L.IsRegular) (D : ℕ)
    (hL : ∀ w∈L, ∃ f t, Realizes w 0 f ∧ |t|≤(D:ℤ) ∧
      EndAt C.d C.K C.tail f (t+C.offset) (C.small f (t+C.offset)) w.length) :
    HasHeightAtMost L 1 := by
  obtain ⟨N,hN⟩ := C.ending_middle L D hL
  exact PeriodicTemplates.regular_middle_height L hreg
    (N+C.tail.toNat) N C.tail.toNat C.d hN

end CanonicalEpisodes.Parameters
namespace ExceptionalOrigins.Parameters

open LocalMarkers
variable {Alphabet : Type uAlphabet9} {J : Type uJ6} {C : Type uC6} (A : ExceptionalOrigins.Parameters Alphabet J C)

structure Inspection (D N : ℕ) : Prop where
  contains : D<N
  full : ∀ (t : ℤ), |t|≤(D:ℤ) → ∀ Q, A.Visible (-(N:ℤ)) N t Q
  inner : ∀ (t : ℤ), |t|≤(D:ℤ) → ∀ j u, A.InnerVisible (-(N:ℤ)) N t j u
  strict : ∀ (t : ℤ), |t|≤(D:ℤ) →
    t+A.endRule.offset+(A.endRule.d:ℤ)+(A.endRule.B-1)*A.endRule.S<N

lemma exists_inspection [Fintype J] (D : ℕ) : ∃ N : ℕ, A.Inspection D N := by
  obtain ⟨N₁,h₁,V₁⟩ := A.exists_horizon D
  obtain ⟨N₂,h₂,V₂⟩ := A.exists_inner_horizon D
  obtain ⟨N₃,h₃,V₃⟩ := A.endRule.exists_uniform_horizon D
  let N := max N₁ (max N₂ N₃)
  have n₁ : N₁≤N := le_max_left _ _
  have n₂ : N₂≤N := (le_max_left _ _).trans (le_max_right _ _)
  have n₃ : N₃≤N := (le_max_right _ _).trans (le_max_right _ _)
  refine ⟨N,⟨h₁.trans_le n₁,?_,?_,?_⟩⟩
  · intro t ht Q
    exact Visible.mono A (V₁ t ht Q) (by omega) (by omega)
  · intro t ht j u
    exact InnerVisible.mono A (V₂ t ht j u) (by omega) (by omega)
  · intro t ht
    exact (V₃ t ht).2.trans_le (by exact_mod_cast n₃)

end ExceptionalOrigins.Parameters

end GeneralizedStarHeight

end OAI