lean/OAI/Computability/StarHeight/StreamTranslation.lean

import OAI.Computability.StarHeight.Translation

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uAlphabet uM uS uK uAlphabet2 uM2 uV uK2
universe uP uC uAlphabet3 uM3 uV2 uK3 uP2 uC2
universe uAlphabet4

namespace ObservedMain

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

lemma prefix_shift {tag : SplitMetadata.MainTag M S g B} {f : ℤ → Alphabet} {s k : ℤ}
    {search : Fin (g+1) → Option ℤ} (hp : PrefixRead T ρ β tag f s k search) (a : ℤ) :
    PrefixRead T ρ β tag (shift f a) (s+a) (k+a) (translated search a) := by
  have hpos (i : Fin (g+1)) (hi : i.val≤tag.j.val) := translated_position (hp.present i hi) a
  have hz : (0 : Fin (g+1)).val≤tag.j.val := Nat.zero_le _
  refine ⟨⟨fun i hi h => hp.present i hi ((translated_none search a i).mp h),?_,?_,hp.certificate⟩,?_,?_⟩
  · rw [hpos 0 hz,StreamShift.product]
    exact hp.initial
  · intro i hi
    rw [hpos i.val.castSucc (by exact hi.le),hpos i.val.succ (by exact hi),StreamShift.product]
    exact hp.earlier i hi
  · intro i hi
    rw [hpos i hi]
    have := hp.bounds i hi
    constructor <;> omega
  · intro i hi
    rw [hpos i.castSucc (by exact hi.le),hpos i.succ (by exact hi)]
    have := hp.ordered i hi
    omega

omit [Field K] [AddCommGroup S] [Module K S] in
lemma suffix_shift {tag : SplitMetadata.MainTag M S g B} {f : ℤ → Alphabet} {k b : ℤ}
    {search : Fin (g+1) → Option ℤ} (hq : SuffixRead T tag f k b search) (a : ℤ) :
    SuffixRead T tag (shift f a) (k+a) (b+a) (translated search a) := by
  have hpos (i : Fin (g+1)) (hi : tag.j.val < i.val) := translated_position (hq.present i hi) a
  have hg : tag.j.val < (Fin.last g).val := tag.j.isLt
  refine ⟨⟨fun i hi h => hq.present i hi ((translated_none search a i).mp h),?_,?_⟩,?_,?_⟩
  · rw [hpos _ hg,StreamShift.product]
    exact hq.final
  · intro i hi
    rw [hpos i.val.castSucc hi,hpos i.val.succ (by exact Nat.lt_succ_of_lt hi),StreamShift.product]
    exact hq.later i hi
  · intro i hi
    rw [hpos i hi]
    have := hq.bounds i hi
    constructor <;> omega
  · intro i hi
    rw [hpos i.castSucc hi,hpos i.succ (by exact Nat.lt_succ_of_lt hi)]
    have := hq.ordered i hi
    omega

end ObservedMain

namespace OuterStream

open StreamShift BoundarySnapshot SplitMetadata
variable {Alphabet : Type uAlphabet2} {M : Type uM2} {V : Type uV} {K : Type uK2} {P : Type uP} {C : Type uC} [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)

omit [Fintype C] in
lemma search_shift (f : ℤ → Alphabet) (u : Fin A.B) (t a : ℤ) :
    search A (shift f a) u (t+a)=translated (search A f u t) a := by
  funext i
  exact A.inner_shift f i u t a

omit [Fintype M] [Fintype C] in
lemma snapshot_shift (f : ℤ → Alphabet) (s b t a : ℤ) :
    snapshot A T (shift f a) (s+a) (b+a) (t+a)=snapshot A T f s b t := by
  unfold snapshot
  rw [show b+a-A.endRule.tail=(b-A.endRule.tail)+a by ring,A.anchor_shift,
    add_sub_add_right_eq_sub,search_shift,actual_shift]

lemma update_shift (f : ℤ → Alphabet) (s b t a : ℤ) (x : V) :
    update A clock T ρ β (shift f a) (s+a) (b+a) (t+a) x=update A clock T ρ β f s b t x := by
  unfold update
  rw [show b+a-A.endRule.tail=(b-A.endRule.tail)+a by ring,A.anchor_shift,
    add_sub_add_right_eq_sub,snapshot_shift]

lemma prefix_shift {tag : Tag M V g A.B} {f : ℤ → Alphabet} {s t k : ℤ}
    (hp : Prefix A H clock T ρ β tag f s t k) (a : ℤ) :
    Prefix A H clock T ρ β tag (shift f a) (s+a) (t+a) (k+a) := by
  refine ⟨by have := hp.positive;omega,?_,?_,?_⟩
  · obtain ⟨i,hi,hcut⟩ := hp.cut
    exact ⟨i,hi,by omega⟩
  · simpa only [add_sub_add_right_eq_sub] using hp.clock_mem
  · cases tag with
    | inl tag =>
      have hm : PrefixMain A T ρ β tag f s t k := hp.letter_test
      refine ⟨fun i hi => A.innerVisible_shift (hm.visible i hi) a,?_⟩
      rw [search_shift]
      exact ObservedMain.prefix_shift T ρ β hm.observed a
    | inr tag =>
      have hm : PrefixPeriodic A T tag f s t k := hp.letter_test
      refine ⟨A.innerVisible_shift hm.visible a,?_,?_⟩
      · rw [A.inner_shift,hm.absent,Option.map_none]
      · rw [StreamShift.product]
        exact hm.product_eq

omit [Monoid M] [Field K] [AddCommGroup V] [Module K V] [Fintype M] [Fintype V]
  [Fintype P] [Fintype C] in
lemma origins_shift (k a : ℤ) : H.origins (k+a)=(H.origins k).image (fun x => x+a) := by
  simp only [Cuts.origins,Finset.image_image]
  congr 1
  funext h
  dsimp
  ring

omit [Fintype C] in
lemma suffixAnchor_shift (f : ℤ → Alphabet) (reference k b a : ℤ) :
    suffixAnchor A reference (k+a) (b+a) (shift f a)=suffixAnchor A reference k b f+a := by
  unfold suffixAnchor
  rw [show b+a-A.endRule.tail=(b-A.endRule.tail)+a by ring,
    show k+a-reference=(k-reference)+a by ring,A.anchor_shift]

lemma suffix_shift {tag : Tag M V g A.B} {f : ℤ → Alphabet} {reference k b : ℤ}
    (hq : Suffix A H clock T ρ reference tag f k b) (a : ℤ) :
    Suffix A H clock T ρ reference tag (shift f a) (k+a) (b+a) := by
  refine ⟨by have := hq.ordered;omega,?_,?_,?_,?_⟩
  · rw [origins_shift,show k+a-reference=(k-reference)+a by ring]
    exact A.endRule.guard_shift hq.guard a
  · rw [suffixAnchor_shift,add_sub_add_right_eq_sub]
    exact hq.clock_mem
  · rw [suffixAnchor_shift,add_sub_add_right_eq_sub]
    exact hq.residue_eq
  · cases tag with
    | inr tag =>
      change tag.output=ρ (tag.prefixProduct*WordIntervals.product T (shift f a) (k+a) (b+a)) tag.input
      rw [StreamShift.product]
      exact hq.letter_test
    | inl tag =>
      have hm : SuffixMain A H T tag f k b := hq.letter_test
      refine ⟨?_,?_,?_⟩
      · intro i hi j hj
        simpa only [show k-H.main tag.j-(i:ℤ)*A.B+a=k+a-H.main tag.j-i*A.B by ring]
          using A.innerVisible_shift (hm.visible i hi j hj) a
      · intro i hi j hj
        rw [show k+a-H.main tag.j-(i:ℤ)*A.B=(k-H.main tag.j-i*A.B)+a by ring,
          show k+a-H.main tag.j=(k-H.main tag.j)+a by ring,A.inner_shift,A.inner_shift,hm.stable i hi j hj]
      · rw [show k+a-H.main tag.j=(k-H.main tag.j)+a by ring,search_shift]
        exact ObservedMain.suffix_shift T hm.observed a

end OuterStream

namespace InnerStream

open StreamShift BoundarySnapshot SplitMetadata
variable {Alphabet : Type uAlphabet3} {M : Type uM3} {V : Type uV2} {K : Type uK3} {P : Type uP2} {C : Type uC2} [Monoid M] [Field K] [AddCommGroup V] [Module K V]
    [Fintype M] [Fintype V] [Fintype P] [Fintype C] {g g' μ : ℕ}
variable (A : ExceptionalOrigins.Parameters Alphabet (Fin (g+1)) C)
    (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) (early : Fin (g'+1) → ℤ)
    (γ : (M → (V × K →ₗ[K] V × K)) → (Fin g' → M) → V × K)
    (p : Roster M (V × K) K g' μ → ℤ) (lag : ℤ)

lemma hypothetical_shift (f : ℤ → Alphabet) (s b t a : ℤ) :
    hypothetical A clock T ρ β early (shift f a) (s+a) (b+a) (t+a)=
      hypothetical A clock T ρ β early f s b t := by
  unfold hypothetical
  rw [show b+a-A.endRule.tail=(b-A.endRule.tail)+a by ring,A.anchor_shift]
  dsimp only
  rw [add_sub_add_right_eq_sub,OuterStream.search_shift,
    show s+a+early (Fin.last g')=(s+early (Fin.last g'))+a by ring,later_shift]

lemma update_shift (f : ℤ → Alphabet) (s b t a : ℤ) (x : V × K) :
    update A clock T ρ β early γ (shift f a) (s+a) (b+a) (t+a) x=
      update A clock T ρ β early γ f s b t x := by
  have hd (i : Fin g') :
      WordIntervals.product T (shift f a) (s+a+early i.castSucc) (s+a+early i.succ)=
      WordIntervals.product T f (s+early i.castSucc) (s+early i.succ) := by
    rw [show s+a+early i.castSucc=(s+early i.castSucc)+a by ring,
      show s+a+early i.succ=(s+early i.succ)+a by ring,StreamShift.product]
  simp only [update,hypothetical_shift,hd]

omit [Fintype M] [Fintype V] in
lemma prefix_shift {slot : Roster M (V × K) K g' μ} {f : ℤ → Alphabet} {s k : ℤ}
    (hp : Prefix T early γ p slot f s k) (a : ℤ) :
    Prefix T early γ p slot (shift f a) (s+a) (k+a) := by
  refine ⟨by have := hp.cut;omega,⟨?_,hp.observed.certificate⟩⟩
  intro i hi
  rw [show s+a+early i.val.castSucc=(s+early i.val.castSucc)+a by ring,
    show s+a+early i.val.succ=(s+early i.val.succ)+a by ring,StreamShift.product]
  exact hp.observed.earlier i hi

lemma suffix_shift {reference slot : Roster M (V × K) K g' μ} {f : ℤ → Alphabet} {k b : ℤ}
    (hq : Suffix A clock T ρ β early p lag reference slot f k b) (a : ℤ) :
    Suffix A clock T ρ β early p lag reference slot (shift f a) (k+a) (b+a) := by
  refine ⟨?_,⟨?_,?_⟩⟩
  · have he : SuffixDecoder.origin p lag (k+a)=fun i => SuffixDecoder.origin p lag k i+a := by
      funext i
      dsimp [SuffixDecoder.origin]
      ring
    rw [he]
    exact SuffixDecoder.test_shift A hq.decoder a
  · intro i hi
    rw [show k+a-p slot+early i.val.castSucc=(k-p slot+early i.val.castSucc)+a by ring,
      show k+a-p slot+early i.val.succ=(k-p slot+early i.val.succ)+a by ring,StreamShift.product]
    exact hq.observed.later i hi
  · rw [show k+a-p slot+lag=(k-p slot+lag)+a by ring,
      show k+a-p slot=(k-p slot)+a by ring,hypothetical_shift]
    exact hq.observed.hypothetical_eq

end InnerStream

namespace WordIntervals

variable {Alphabet : Type uAlphabet4}

noncomputable def stream [Nonempty Alphabet] (w : List Alphabet) : ℤ → Alphabet :=
  Classical.choose (realizes_exists w 0)

lemma stream_realizes [Nonempty Alphabet] (w : List Alphabet) : Realizes w 0 (stream w) :=
  Classical.choose_spec (realizes_exists w 0)

lemma Realizes.same {w : List Alphabet} {f g : ℤ → Alphabet} {s : ℤ}
    (hf : Realizes w s f) (hg : Realizes w s g) : LocalMarkers.AgreesOn f g s (s+w.length) :=
  hf.agrees hg List.prefix_rfl

lemma Realizes.pair_prefix {u v w : List Alphabet} {f : ℤ → Alphabet}
    (hf : Realizes w 0 f) (hpair : u++v <+: w) : Realizes u 0 f :=
  (hf.prefix hpair).append_left

end WordIntervals

end GeneralizedStarHeight

end OAI