lean/OAI/Computability/StarHeight/ObservedLanguages.lean

import OAI.Computability.StarHeight.ObservedActions

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uAlphabet2 uJ uC uAlphabet3 uM uS uK
universe uM2 uS2 uM3 uS3 uAlphabet4 uM4 uV uK2
universe uP uC2

namespace PeriodicTemplates

open WordIntervals LocalMarkers

variable {Alphabet : Type uAlphabet}

lemma segment_power {v : ℤ → Alphabet} {p : ℕ}
    (hp : Function.Periodic v (p : ℤ)) (s : ℤ) (q : ℕ) :
    segment v s (q*p) = wordPower (segment v s p) q := by
  induction q with
  | zero => simp [WordIntervals.segment]
  | succ q ih =>
    rw [Nat.succ_mul,segment_add,ih,wordPower_add,wordPower_one]
    congr 1
    simpa only [Nat.cast_mul] using PeriodicCuts.segment_shift_period hp s q p

lemma decompose_middle {w : List Alphabet} {f v : ℤ → Alphabet} {N tail p : ℕ}
    (hf : Realizes w 0 f) (hlen : N+tail ≤ w.length) (hp : 0 < p)
    (hper : Function.Periodic v (p : ℤ))
    (he : AgreesOn f v N (w.length-tail)) :
    ∃ a c b : List Alphabet, a.length = N ∧ c.length = p ∧ b.length < p+tail ∧
      ∃ q, w = a ++ wordPower c q ++ b := by
  let m := w.length-N-tail
  let q := m/p
  let r := m%p
  have hr : r<p := Nat.mod_lt _ hp
  have hm : m = q*p+r := by
    simpa only [q,r,Nat.mul_comm] using (Nat.div_add_mod m p).symm
  have hlen' : w.length = N+m+tail := by
    have : m = w.length-N-tail := rfl
    omega
  let a := segment f 0 N
  let c := segment v N p
  let b := segment v N r ++ segment f (N+m) tail
  refine ⟨a,c,b,length_segment _ _ _,length_segment _ _ _,?_,q,?_⟩
  · simpa only [b,List.length_append,length_segment] using Nat.add_lt_add_right hr tail
  · have hw : w = segment f 0 w.length := (realizes_iff_segment.mp hf).symm
    rw [hw,hlen',segment_add,segment_add]
    simp only [zero_add,Nat.cast_add]
    have he' : segment f N m = segment v N m := by
      apply segment_congr
      intro x hx hx'
      apply he x hx
      rw [hlen']
      push_cast
      omega
    rw [he',hm,segment_add,segment_power hper]
    have hs : segment v ((N : ℤ)+(q*p : ℕ)) r = segment v N r := by
      simpa only [Nat.cast_mul] using PeriodicCuts.segment_shift_period hper N q r
    rw [hs]
    simp only [a,c,b,List.append_assoc]
    rw [← hm]

noncomputable def boundedTemplates [Finite Alphabet] (A C B : ℕ) :
    Finset (Template Alphabet) :=
  (List.finite_length_le Alphabet A).toFinset ×ˢ
    ((List.finite_length_le Alphabet C).toFinset ×ˢ
      (List.finite_length_le Alphabet B).toFinset)

lemma mem_boundedTemplates [Finite Alphabet] (A C B : ℕ) (a c b : List Alphabet) :
    (a,c,b) ∈ boundedTemplates A C B ↔ a.length≤A ∧ c.length≤C ∧ b.length≤B := by
  simp only [boundedTemplates,Finset.mem_product,Set.Finite.mem_toFinset,Set.mem_ofPred_eq]

lemma finite_cover_of_middle [Finite Alphabet] (L : Language Alphabet) (short N tail d : ℕ)
    (h : ∀ w ∈ L, w.length ≤ short ∨
      ∃ (f v : ℤ → Alphabet) (p : ℕ), Realizes w 0 f ∧ N+tail≤w.length ∧
        0<p ∧ p≤d ∧ Function.Periodic v (p : ℤ) ∧
        AgreesOn f v N (w.length-tail)) :
    ∃ templates : Finset (Template Alphabet),
      ∀ w ∈ L, ∃ t ∈ templates, ∃ i, w = instanceWord t i := by
  refine ⟨boundedTemplates (max short N) d (d+tail),?_⟩
  intro w hw
  rcases h w hw with hs | ⟨f,v,p,hf,hlen,hp,hpd,hper,he⟩
  · refine ⟨(w,[],[]),(mem_boundedTemplates _ _ _ _ _ _).mpr ?_,0,?_⟩
    · exact ⟨hs.trans (le_max_left _ _),by simp,by simp⟩
    · simp [instanceWord]
  · obtain ⟨a,c,b,ha,hc,hb,q,hq⟩ := decompose_middle hf hlen hp hper he
    refine ⟨(a,c,b),(mem_boundedTemplates _ _ _ _ _ _).mpr ?_,q,hq⟩
    exact ⟨ha ▸ le_max_right _ _,hc ▸ hpd,hb.le.trans (Nat.add_le_add_right hpd tail)⟩

lemma regular_middle_height [Finite Alphabet] (L : Language Alphabet) (hL : L.IsRegular)
    (short N tail d : ℕ)
    (h : ∀ w ∈ L, w.length ≤ short ∨
      ∃ (f v : ℤ → Alphabet) (p : ℕ), Realizes w 0 f ∧ N+tail≤w.length ∧
        0<p ∧ p≤d ∧ Function.Periodic v (p : ℤ) ∧
        AgreesOn f v N (w.length-tail)) : HasHeightAtMost L 1 := by
  obtain ⟨templates,hcover⟩ := finite_cover_of_middle L short N tail d h
  exact regular_cover_height L hL templates hcover

end PeriodicTemplates

namespace ExceptionalOrigins.Parameters

open LocalMarkers

variable {Alphabet : Type uAlphabet2} {J : Type uJ} {C : Type uC} (A : ExceptionalOrigins.Parameters Alphabet J C)

def InnerVisible (s b t : ℤ) (j : J) (u : Fin A.B) : Prop :=
  s ≤ t+A.offset j-A.innerRule.r ∧ t+A.offset j+A.H u+A.innerRule.r ≤ b

lemma inner_congr {f g : ℤ → Alphabet} {s b t : ℤ} {j : J} {u : Fin A.B}
    (hv : A.InnerVisible s b t j u) (he : AgreesOn f g s b) :
    A.inner f j u t = A.inner g j u t := by
  apply MarkerSearch.search_congr
  intro m hm hm'
  apply A.innerRule.locality
  intro x hx hx'
  exact he x (by have := hv.1; omega) (by have := hv.2; omega)

lemma inner_bounds {f : ℤ → Alphabet} {j : J} {u : Fin A.B} {t p : ℤ}
    (hp : A.inner f j u t = some p) : t+A.offset j ≤ p ∧ p ≤ t+A.offset j+A.H u := by
  exact ⟨(MarkerSearch.search_some.mp hp).1.2.1,(MarkerSearch.search_some.mp hp).2⟩

lemma inner_position_bounds {g : ℕ} (A : ExceptionalOrigins.Parameters Alphabet (Fin (g+1)) C)
    {f : ℤ → Alphabet} {u : Fin A.B} {s b t : ℤ} {j : Fin (g+1)}
    (hv : A.InnerVisible s b t j u) (hp : A.inner f j u t ≠ none) :
    s ≤ BoundarySnapshot.positions (fun i => A.inner f i u t) j ∧
      BoundarySnapshot.positions (fun i => A.inner f i u t) j ≤ b := by
  have hb := A.inner_bounds (f := f) (t := t) (j := j) (u := u)
    (BoundarySnapshot.positions_return (search := fun i => A.inner f i u t) (i := j) hp)
  have hr := A.innerRule.radius_ge
  exact ⟨by have := hv.1;omega,by have := hv.2;omega⟩

end ExceptionalOrigins.Parameters

namespace ObservedMain

open WordIntervals BoundarySnapshot SplitMetadata

variable {Alphabet : Type uAlphabet3} {M : Type uM} {S : Type uS} {K : Type uK} [Monoid M] [Field K] [AddCommGroup S] [Module K S]
    {g B : ℕ}
variable (T : FreeMonoid Alphabet →* M) (ρ : M → (S →ₗ[K] S))
    (β : M → M → (Fin g → M) → S)

structure PrefixRead (tag : MainTag M S g B) (f : ℤ → Alphabet) (s k : ℤ)
    (search : Fin (g+1) → Option ℤ) : Prop extends Prefix T ρ β tag f s search where
  bounds : ∀ i, i.val ≤ tag.j.val → s ≤ positions search i ∧ positions search i ≤ k
  ordered : ∀ i : Fin g, i < tag.j → positions search i.castSucc ≤ positions search i.succ

structure SuffixRead (tag : MainTag M S g B) (f : ℤ → Alphabet) (k b : ℤ)
    (search : Fin (g+1) → Option ℤ) : Prop extends Suffix T tag f b search where
  bounds : ∀ i, tag.j.val < i.val → k ≤ positions search i ∧ positions search i ≤ b
  ordered : ∀ i : Fin g, tag.j < i → positions search i.castSucc ≤ positions search i.succ

lemma PrefixRead.transfer {tag : MainTag M S g B} {f f' : ℤ → Alphabet} {s k : ℤ}
    {search search' : Fin (g+1) → Option ℤ}
    (hp : PrefixRead T ρ β tag f s k search) (he : LocalMarkers.AgreesOn f f' s k)
    (hs : ∀ i, i.val ≤ tag.j.val → search i = search' i) :
    PrefixRead T ρ β tag f' s k search' := by
  have hpos : ∀ i, i.val ≤ tag.j.val → positions search i = positions search' i := by
    intro i hi
    simp only [positions,hs i hi]
  have hzero : (0 : Fin (g+1)).val ≤ tag.j.val := by simp
  have hp0 := hp.bounds 0 hzero
  refine ⟨⟨?_,?_,?_,hp.certificate⟩,?_,?_⟩
  · intro i hi; rw [←hs i hi]; exact hp.present i hi
  · rw [←hpos 0 hzero,←hp.initial]
    symm
    apply product_congr T hp0.1
    intro z hz hz'
    exact he z hz (hz'.trans_le hp0.2)
  · intro i hi
    have h₁ : i.val.castSucc.val ≤ tag.j.val := Nat.le_of_lt hi
    have h₂ : i.val.succ.val ≤ tag.j.val := hi
    rw [←hpos _ h₁,←hpos _ h₂,←hp.earlier i hi]
    symm
    apply product_congr T (hp.ordered i.val hi)
    intro z hz hz'
    exact he z ((hp.bounds _ h₁).1.trans hz) (hz'.trans_le (hp.bounds _ h₂).2)
  · intro i hi; rw [←hpos i hi]; exact hp.bounds i hi
  · intro i hi
    rw [←hpos _ (Nat.le_of_lt hi),←hpos _ (show i.val+1 ≤ tag.j.val from hi)]
    exact hp.ordered i hi

omit [AddCommGroup S] in
lemma SuffixRead.transfer {tag : MainTag M S g B} {f f' : ℤ → Alphabet} {k b : ℤ}
    {search search' : Fin (g+1) → Option ℤ}
    (hq : SuffixRead T tag f k b search) (he : LocalMarkers.AgreesOn f f' k b)
    (hs : ∀ i, tag.j.val < i.val → search i = search' i) :
    SuffixRead T tag f' k b search' := by
  have hpos : ∀ i, tag.j.val < i.val → positions search i = positions search' i := by
    intro i hi
    simp only [positions,hs i hi]
  have hlast : tag.j.val < (Fin.last g).val := tag.j.isLt
  have hp0 := hq.bounds (Fin.last g) hlast
  refine ⟨⟨?_,?_,?_⟩,?_,?_⟩
  · intro i hi; rw [←hs i hi]; exact hq.present i hi
  · rw [←hpos _ hlast,←hq.final]
    symm
    apply product_congr T hp0.2
    intro z hz hz'
    exact he z (hp0.1.trans hz) hz'
  · intro i hi
    have h₁ : tag.j.val < i.val.castSucc.val := hi
    have h₂ : tag.j.val < i.val.succ.val := Nat.lt_succ_of_lt hi
    rw [←hpos _ h₁,←hpos _ h₂,←hq.later i hi]
    symm
    apply product_congr T (hq.ordered i.val hi)
    intro z hz hz'
    exact he z ((hq.bounds _ h₁).1.trans hz) (hz'.trans_le (hq.bounds _ h₂).2)
  · intro i hi; rw [←hpos i hi]; exact hq.bounds i hi
  · intro i hi
    rw [←hpos _ hi,←hpos _ (Nat.lt_succ_of_lt hi)]
    exact hq.ordered i hi

end ObservedMain

namespace OuterStream

open SplitMetadata WordIntervals LocalMarkers BoundarySnapshot
open scoped Classical

structure Cuts (g B : ℕ) where
  main : Fin g → ℤ
  periodic : Fin (g+1) → Fin B → ℤ
  R : ℕ
  N : ℕ
  R_pos : 0 < R
  N_pos : 0 < N

namespace Cuts

variable {g B : ℕ} (H : Cuts g B)

abbrev Role (_H : Cuts g B) := Fin g ⊕ (Fin (g+1) × Fin B)

def base : H.Role → ℤ
  | .inl j => H.main j
  | .inr (j,u) => H.periodic j u

def count : H.Role → ℕ
  | .inl _ => H.R
  | .inr _ => H.N

noncomputable def offsets : Finset ℤ :=
  Finset.univ.biUnion fun role : H.Role => (Finset.range (H.count role)).image
    (fun a : ℕ => H.base role + (a:ℤ)*(B:ℤ))

lemma offset_mem (role : H.Role) (a : ℕ) (ha : a < H.count role) :
    H.base role+a*B ∈ H.offsets := by
  exact Finset.mem_biUnion.mpr ⟨role,Finset.mem_univ _,Finset.mem_image.mpr
    ⟨a,Finset.mem_range.mpr ha,rfl⟩⟩

def tagRole (H : Cuts g B) {M : Type uM2} {S : Type uS2} : Tag M S g B → H.Role
  | .inl m => .inl m.j
  | .inr p => .inr (p.j,p.u)

noncomputable def origins (k : ℤ) : Finset ℤ := H.offsets.image (fun h => k-h)

lemma true_origin {M : Type uM3} {S : Type uS3} (tag : Tag M S g B) {t k : ℤ}
    (hcut : ∃ a : ℕ, a < H.count (H.tagRole tag) ∧ k=t+H.base (H.tagRole tag)+a*B) :
    t ∈ H.origins k := by
  obtain ⟨a,ha,hk⟩ := hcut
  apply Finset.mem_image.mpr
  exact ⟨_,H.offset_mem _ _ ha,by omega⟩

end Cuts

variable {Alphabet : Type uAlphabet4} {M : Type uM4} {V : Type uV} {K : Type uK2} {P : Type uP} {C : Type uC2} [Monoid M] [Field K] [AddCommGroup V] [Module K V]
    [Fintype M] [Fintype V] [Fintype P] [Fintype C] {g : ℕ}

variable (A : ExceptionalOrigins.Parameters Alphabet (Fin (g+1)) C)
    (H : Cuts g A.B) (clock : RobustClock.Specification (Tag M V g A.B) P C)
    (T : FreeMonoid Alphabet →* M) (ρ : M → (V →ₗ[K] V))
    (β : M → M → (Fin g → M) → V)

noncomputable def search (f : ℤ → Alphabet) (u : Fin A.B) (t : ℤ) : Fin (g+1) → Option ℤ :=
  fun i => A.inner f i u t

noncomputable def snapshot (f : ℤ → Alphabet) (s b t : ℤ) : ClockAffine.Snapshot M g :=
  actual T f s b (search A f (A.residue (A.anchor f (b-A.endRule.tail) t-t)) t)

noncomputable def update (f : ℤ → Alphabet) (s b t : ℤ) (x : V) : V :=
  ClockAffine.update clock ρ β Tag.input Tag.output
    (A.φ (A.anchor f (b-A.endRule.tail) t-t)) (snapshot A T f s b t) x

structure PrefixMain (tag : MainTag M V g A.B) (f : ℤ → Alphabet) (s t k : ℤ) : Prop where
  visible : ∀ i, i.val ≤ tag.j.val → A.InnerVisible s k t i tag.u
  observed : ObservedMain.PrefixRead T ρ β tag f s k (search A f tag.u t)

structure PrefixPeriodic (tag : PeriodicTag M V g A.B) (f : ℤ → Alphabet)
    (s t k : ℤ) : Prop where
  visible : A.InnerVisible s k t tag.j tag.u
  absent : A.inner f tag.j tag.u t = none
  product_eq : product T f s k = tag.prefixProduct

structure Prefix (tag : Tag M V g A.B) (f : ℤ → Alphabet) (s t k : ℤ) : Prop where
  positive : s < k
  cut : ∃ a : ℕ, a < H.count (H.tagRole tag) ∧ k=t+H.base (H.tagRole tag)+a*A.B
  clock_mem : A.φ (k-t) ∈ clock.I tag
  letter_test : match tag with
    | .inl tag => PrefixMain A T ρ β tag f s t k
    | .inr tag => PrefixPeriodic A T tag f s t k

structure SuffixMain (tag : MainTag M V g A.B) (f : ℤ → Alphabet) (k b : ℤ) : Prop where
  visible : ∀ a : ℕ, a < H.R → ∀ i, tag.j.val < i.val →
    A.InnerVisible k b (k-H.main tag.j-a*A.B) i tag.u
  stable : ∀ a : ℕ, a < H.R → ∀ i, tag.j.val < i.val →
    A.inner f i tag.u (k-H.main tag.j-a*A.B) = A.inner f i tag.u (k-H.main tag.j)
  observed : ObservedMain.SuffixRead T tag f k b (search A f tag.u (k-H.main tag.j))

noncomputable def suffixAnchor (reference k b : ℤ) (f : ℤ → Alphabet) : ℤ :=
  A.anchor f (b-A.endRule.tail) (k-reference)

structure Suffix (reference : ℤ) (tag : Tag M V g A.B) (f : ℤ → Alphabet)
    (k b : ℤ) : Prop where
  ordered : k ≤ b
  guard : A.endRule.Guard (H.origins k) (k-reference) k b f
  clock_mem : A.φ (suffixAnchor A reference k b f-k) ∈ clock.J tag
  residue_eq : A.residue (suffixAnchor A reference k b f-k) = tag.residue
  letter_test : match tag with
    | .inl tag => SuffixMain A H T tag f k b
    | .inr tag => tag.output = ρ (tag.prefixProduct * product T f k b) tag.input

end OuterStream

end GeneralizedStarHeight

end OAI