| import OAI.Computability.StarHeight.LateSchedule |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uAlphabet uM uV uK uP uC uAlphabet2 uM2 |
| universe uV2 uK2 uP2 uC2 uAlphabet3 uM3 uV3 uK3 |
| universe uP3 uC3 uAlphabet4 uJ uC4 uAlphabet5 uT uP4 |
| universe uC5 |
|
|
| namespace OuterStream |
|
|
| open SplitMetadata WordIntervals LocalMarkers BoundarySnapshot |
| open scoped Classical |
|
|
| variable {Alphabet : Type uAlphabet} {M : Type uM} {V : Type uV} {K : Type uK} {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 [Monoid M] [AddCommGroup V] [Fintype M] [Fintype V] [Fintype C] in |
| lemma Cuts.multiple (G : Geometry A H) {h : ℤ} (hh : h ∈ H.offsets) : (A.B:ℤ) ∣ h := by |
| obtain ⟨role,_,hh⟩ := Finset.mem_biUnion.mp hh |
| obtain ⟨n,_,rfl⟩ := Finset.mem_image.mp hh |
| exact dvd_add (G.multiple role) (dvd_mul_left _ _) |
|
|
| omit [Monoid M] [AddCommGroup V] [Fintype M] [Fintype V] [Fintype C] in |
| lemma available_guard (G : Geometry A H) |
| (hwidth : ∀ h ∈ H.offsets, ∀ h' ∈ H.offsets, |h-h'| ≤ A.w) |
| {t k b Q reference : ℤ} {f : ℤ → Alphabet} {tag : Tag M V g A.B} |
| (hc : ∃ a : ℕ, a < H.count (H.tagRole tag) ∧ k=t+H.base (H.tagRole tag)+a*A.B) |
| (hr : reference ∈ H.offsets) (hn : ¬A.Failed f t Q) |
| (he : EpisodeEnd.EndAt A.endRule.d A.endRule.K A.endRule.tail f (t+A.endRule.offset) |
| (A.endRule.small f (t+A.endRule.offset)) b) : |
| A.endRule.Guard (H.origins k) (k-reference) k b f ∧ |
| suffixAnchor A reference k b f = A.anchor f (b-A.endRule.tail) t := by |
| have hm : k-reference ∈ H.origins k := Finset.mem_image.mpr ⟨reference,hr,rfl⟩ |
| have hstable : ∀ o ∈ H.origins k, |
| A.endRule.small f (o+A.endRule.offset) = A.endRule.small f (t+A.endRule.offset) ∧ |
| A.endRule.large f (o+A.endRule.offset) = A.endRule.large f (t+A.endRule.offset) := by |
| intro o ho |
| obtain ⟨a,ha,hk⟩ := hc |
| obtain ⟨h,hh,rfl⟩ := Finset.mem_image.mp ho |
| have hmem := H.offset_mem (H.tagRole tag) a ha |
| have heq : k-h = t+(H.base (H.tagRole tag)+a*A.B-h) := by omega |
| rw [heq] |
| exact A.not_failed_end hn (hwidth _ hmem h hh) |
| (dvd_sub (H.multiple A G hmem) (H.multiple A G hh)) |
| have hover := G.origin_overlap hc hm |
| refine ⟨A.endRule.guard_available hm (G.actual_visibility hc he) hstable hover.1 hover.2 he,?_⟩ |
| simp only [suffixAnchor,ExceptionalOrigins.Parameters.anchor,(hstable _ hm).2] |
|
|
| end OuterStream |
|
|
| namespace OuterStream |
|
|
| open SplitMetadata WordIntervals LocalMarkers BoundarySnapshot |
| open scoped Classical |
|
|
| variable {Alphabet : Type uAlphabet2} {M : Type uM2} {V : Type uV2} {K : Type uK2} {P : Type uP2} {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) |
|
|
| lemma net_displacement {B R a a' : ℕ} (ha : a<R) (ha' : a'<R) : |
| |(a:ℤ)*B-a'*B| ≤ (B*R:ℕ) := by |
| have haB := Nat.mul_le_mul_right B ha.le |
| have haB' := Nat.mul_le_mul_right B ha'.le |
| have h₁ : (a:ℤ)*B ≤ (R:ℤ)*B := by exact_mod_cast haB |
| have h₂ : (a':ℤ)*B ≤ (R:ℤ)*B := by exact_mod_cast haB' |
| have hp : 0 ≤ (a:ℤ)*B := mul_nonneg (Int.natCast_nonneg _) (Int.natCast_nonneg _) |
| have hp' : 0 ≤ (a':ℤ)*B := mul_nonneg (Int.natCast_nonneg _) (Int.natCast_nonneg _) |
| rw [abs_le,Nat.cast_mul,mul_comm (B:ℤ)] |
| omega |
|
|
| lemma available_main (G : Geometry A H) (hW : A.W=clock.W) |
| (hnet : ∀ v : C → RobustClock.Circle, ∃ a : ℕ, a<H.R ∧ dist (A.φ (a*A.B)) v < clock.ρ) |
| (hw₀ : (A.B*H.R:ℕ) ≤ A.w₀) |
| (hwidth : ∀ h ∈ H.offsets, ∀ h' ∈ H.offsets, |h-h'| ≤ A.w) |
| (hβ : ∀ a c, ShiftTableProperty g (ClockAffine.productTable ρ a c) (β a c)) |
| {s t b reference : ℤ} {f : ℤ → Alphabet} |
| (hr : reference ∈ H.offsets) |
| (he : EpisodeEnd.EndAt A.endRule.d A.endRule.K A.endRule.tail f (t+A.endRule.offset) |
| (A.endRule.small f (t+A.endRule.offset)) b) |
| (hn : ¬A.Failed f t (A.anchor f (b-A.endRule.tail) t)) |
| (hpos : ∀ (j : Fin g) (a : ℕ), a<H.R → s<t+H.main j+a*A.B ∧ t+H.main j+a*A.B≤b) |
| (hpre : ∀ (j : Fin g) (a : ℕ), a<H.R → ∀ (i : Fin (g+1)), i.val≤j.val → |
| A.InnerVisible s (t+H.main j+a*A.B) t i (A.residue (A.anchor f (b-A.endRule.tail) t-t))) |
| (hpost : ∀ (j : Fin g) (a : ℕ), a<H.R → ∀ a', a'<H.R → ∀ (i : Fin (g+1)), j.val < i.val → |
| A.InnerVisible (t+H.main j+a*A.B) b (t+(a*A.B-a'*A.B)) i |
| (A.residue (A.anchor f (b-A.endRule.tail) t-t))) |
| (hv : ∀ i, A.InnerVisible s b t i (A.residue (A.anchor f (b-A.endRule.tail) t-t))) |
| (hp : ∀ i, A.inner f i (A.residue (A.anchor f (b-A.endRule.tail) t-t)) t ≠ none) |
| (x : V) : |
| ∃ (tag : MainTag M V g A.B) (k : ℤ), tag.input=x ∧ |
| Prefix A H clock T ρ β (.inl tag) f s t k ∧ |
| Suffix A H clock T ρ reference (.inl tag) f k b ∧ |
| tag.output=update A clock T ρ β f s b t x := by |
| let q := A.anchor f (b-A.endRule.tail) t |
| let u := A.residue (q-t) |
| have hz : A.φ (q-t) ∉ clock.W := by rw [←hW]; exact A.not_failed_clock hn |
| have hpres := G.present hv hp |
| obtain ⟨tag,hu,hx,hp',hq',hout⟩ := ObservedMain.available T ρ β f s b (search A f u t) hpres u x hβ |
| obtain ⟨a,ha,hi,hj⟩ := ClockAffine.net_cut clock A.φ A.B hnet hz (.inl tag) (H.main tag.j) |
| let k := t+H.main tag.j+a*A.B |
| have hc : ∃ a : ℕ, a<H.count (H.tagRole (.inl tag)) ∧ k=t+H.base (H.tagRole (.inl tag))+a*A.B := |
| ⟨a,ha,rfl⟩ |
| have hst : ∀ a', a'<H.R → ∀ i, |
| A.inner f i u (t+(a*A.B-a'*A.B)) = A.inner f i u t := by |
| intro a' ha' i |
| exact A.not_failed_inner hn ((net_displacement ha ha').trans hw₀) i |
| have hsref : ∀ i, A.inner f i u (k-H.main tag.j) = A.inner f i u t := by |
| intro i |
| convert hst 0 H.R_pos i using 1; dsimp [k]; congr 1; ring |
| have hmpos : Monotone (positions (search A f u t)) := by |
| obtain ⟨pos,hpos,hm,_,_⟩ := hpres |
| change ∀ i, search A f u t i=some (pos i) at hpos |
| have heq : positions (search A f u t)=pos := by |
| funext i |
| simp only [positions,hpos,Option.getD_some] |
| rw [heq] |
| exact hm |
| have hprefix : Prefix A H clock T ρ β (.inl tag) f s t k := by |
| refine ⟨(hpos tag.j a ha).1,hc,?_,?_⟩ |
| · convert hi using 1; dsimp [k]; congr 1; ring |
| · change PrefixMain A T ρ β tag f s t k |
| refine ⟨?_,?_⟩ |
| · simpa only [hu] using hpre tag.j a ha |
| · rw [hu] |
| refine ⟨hp',?_,?_⟩ |
| · intro i hii |
| exact A.inner_position_bounds (hpre tag.j a ha i hii) (hp i) |
| · intro i _ |
| exact hmpos (Fin.castSucc_le_succ i) |
| obtain ⟨hguard,hanchor⟩ := available_guard A H G hwidth hc hr hn he |
| have hsuffix : Suffix A H clock T ρ reference (.inl tag) f k b := by |
| refine ⟨(hpos tag.j a ha).2,hguard,?_,?_,?_⟩ |
| · rw [hanchor] |
| convert hj using 1 |
| rw [←map_sub] |
| congr 1 |
| dsimp [q,k] |
| ring |
| · rw [hanchor] |
| change A.residue (q-k)=tag.u |
| exact (residue_shift (A := A) (G.cut_multiple hc)).symm.trans hu.symm |
| · change SuffixMain A H T tag f k b |
| refine ⟨?_,?_,?_⟩ |
| · rw [hu] |
| intro a' ha' i hii |
| convert hpost tag.j a ha a' ha' i hii using 1; dsimp [k]; ring |
| · rw [hu] |
| intro a' ha' i _ |
| rw [hsref] |
| convert hst a' ha' i using 1; dsimp [k]; congr 1; ring |
| · rw [hu] |
| have hread : ObservedMain.SuffixRead T tag f k b (search A f u t) := by |
| refine ⟨hq',?_,?_⟩ |
| · intro i hii |
| have hvis := hpost tag.j a ha a ha i hii |
| rw [sub_self,add_zero] at hvis |
| exact A.inner_position_bounds hvis (hp i) |
| · intro i _; exact hmpos (Fin.castSucc_le_succ i) |
| apply hread.transfer T (fun _ _ _ => rfl) |
| intro i _ |
| exact (hsref i).symm |
| refine ⟨tag,k,hx,hprefix,hsuffix,?_⟩ |
| change tag.output = ClockAffine.update clock ρ β Tag.input Tag.output |
| (A.φ (q-t)) (actual T f s b (search A f u t)) x |
| simp only [ClockAffine.update,ClockAffine.shift,ClockAffine.no_off_outside clock hz] |
| cases hboundaries : (actual T f s b (search A f u t)).boundaries <;> |
| simpa only [hboundaries] using hout |
| |
| end OuterStream |
| |
| namespace OuterStream |
| |
| open SplitMetadata WordIntervals LocalMarkers BoundarySnapshot |
| open scoped Classical |
| |
| variable {Alphabet : Type uAlphabet3} {M : Type uM3} {V : Type uV3} {K : Type uK3} {P : Type uP3} {C : Type uC3} [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) |
|
|
| lemma available_periodic (G : Geometry A H) (hW : A.W=clock.W) |
| (hnet : ∀ v : C → RobustClock.Circle, ∃ a : ℕ, a<H.R ∧ dist (A.φ (a*A.B)) v < clock.ρ) |
| (hwidth : ∀ h ∈ H.offsets, ∀ h' ∈ H.offsets, |h-h'| ≤ A.w) |
| {s t b reference : ℤ} {f : ℤ → Alphabet} |
| (hr : reference ∈ H.offsets) |
| (he : EpisodeEnd.EndAt A.endRule.d A.endRule.K A.endRule.tail f (t+A.endRule.offset) |
| (A.endRule.small f (t+A.endRule.offset)) b) |
| (hn : ¬A.Failed f t (A.anchor f (b-A.endRule.tail) t)) |
| (hpos : ∀ (j : Fin (g+1)) (u : Fin A.B) (a : ℕ), a<H.N → |
| s<t+H.periodic j u+a*A.B ∧ t+H.periodic j u+a*A.B≤b) |
| (hpre : ∀ (j : Fin (g+1)) (a : ℕ), a<H.N → |
| A.InnerVisible s (t+H.periodic j (A.residue (A.anchor f (b-A.endRule.tail) t-t))+a*A.B) |
| t j (A.residue (A.anchor f (b-A.endRule.tail) t-t))) |
| (j : Fin (g+1)) |
| (hp : A.inner f j (A.residue (A.anchor f (b-A.endRule.tail) t-t)) t = none) |
| {n step : ℕ} (hnpos : 0<n) (hnperiod : A.φ n=0) |
| (hcop : Nat.Coprime (step*A.B) n) |
| (hprog : ∀ a : ℕ, a<n → a*step<H.N ∧ |
| product T f s (t+H.periodic j (A.residue (A.anchor f (b-A.endRule.tail) t-t))+a*step*A.B) = |
| product T f s (t+H.periodic j (A.residue (A.anchor f (b-A.endRule.tail) t-t)))) |
| (x : V) : |
| ∃ (tag : PeriodicTag M V g A.B) (k : ℤ), tag.input=x ∧ |
| Prefix A H clock T ρ β (.inr tag) f s t k ∧ |
| Suffix A H clock T ρ reference (.inr tag) f k b ∧ |
| tag.output=update A clock T ρ β f s b t x := by |
| let q := A.anchor f (b-A.endRule.tail) t |
| let u := A.residue (q-t) |
| let tag : PeriodicTag M V g A.B := ⟨j,u,product T f s (t+H.periodic j u),x,ρ (product T f s b) x⟩ |
| have hz : A.φ (q-t) ∉ clock.W := by rw [←hW]; exact A.not_failed_clock hn |
| obtain ⟨a₀,_,hi,hj⟩ := ClockAffine.net_cut clock A.φ A.B hnet hz (.inr tag) (H.periodic j u) |
| obtain ⟨a,ha,hclock⟩ := PeriodicClock.sweep A.φ hnpos hnperiod hcop (H.periodic j u) (a₀*A.B) |
| have hindex := (hprog a ha).1 |
| let k := t+H.periodic j u+(a*step:ℕ)*A.B |
| have hkeq : k-t=H.periodic j u+(a:ℤ)*(step*A.B:ℕ) := by |
| dsimp [k] |
| ring |
| have hpreclock : A.φ (k-t) ∈ clock.I (.inr tag) := by rw [hkeq,hclock];exact hi |
| have hpostclock : A.φ (q-k) ∈ clock.J (.inr tag) := by |
| rw [show q-k=(q-t)-(k-t) by ring,map_sub,hkeq,hclock] |
| exact hj |
| have hc : ∃ a' : ℕ, a'<H.count (H.tagRole (.inr tag)) ∧ |
| k=t+H.base (H.tagRole (.inr tag))+a'*A.B := ⟨a*step,hindex,rfl⟩ |
| have hprod : product T f s k=tag.prefixProduct := by |
| simpa only [k, Nat.cast_mul] using (hprog a ha).2 |
| have hk := hpos j u (a*step) hindex |
| have hprefix : Prefix A H clock T ρ β (.inr tag) f s t k := |
| ⟨hk.1,hc,hpreclock,⟨hpre j (a*step) hindex,hp,hprod⟩⟩ |
| obtain ⟨hguard,hanchor⟩ := available_guard A H G hwidth hc hr hn he |
| have hsuffix : Suffix A H clock T ρ reference (.inr tag) f k b := by |
| refine ⟨hk.2,hguard,?_,?_,?_⟩ |
| · rw [hanchor];exact hpostclock |
| · rw [hanchor] |
| exact (residue_shift (A := A) (G.cut_multiple hc)).symm |
| · change ρ (product T f s b) x = ρ (tag.prefixProduct*product T f k b) x |
| rw [←hprod,←product_append T f hk.1.le hk.2] |
| refine ⟨tag,k,rfl,hprefix,hsuffix,?_⟩ |
| have hnone := factors_absent T f (s := s) (b := b) (search := search A f u t) (i := j) hp |
| change ρ (product T f s b) x = ClockAffine.update clock ρ β Tag.input Tag.output |
| (A.φ (q-t)) (actual T f s b (search A f u t)) x |
| rw [ClockAffine.update_periodic clock ρ β Tag.input Tag.output _ |
| (ClockAffine.no_off_outside clock hz) hnone] |
| rfl |
|
|
| end OuterStream |
|
|
| namespace ExceptionalOrigins.Parameters |
|
|
| variable {Alphabet : Type uAlphabet4} {J : Type uJ} {C : Type uC4} (A : Parameters Alphabet J C) |
|
|
| lemma residue_cast (u : Fin A.B) : A.residue u=u := by |
| apply Fin.ext |
| apply Int.ofNat_inj.mp |
| rw [residue_val,Int.emod_eq_of_lt (Int.natCast_nonneg _) (by exact_mod_cast u.isLt)] |
|
|
| end ExceptionalOrigins.Parameters |
|
|
| namespace SourceSchedule.Early |
|
|
| open WordIntervals LocalMarkers SplitMetadata BoundarySnapshot |
| open scoped Classical BigOperators |
|
|
| variable {Alphabet : Type uAlphabet5} {T : Type uT} {P : Type uP4} {C : Type uC5} [Fintype T] [Fintype P] [Fintype C] |
| {g' B size : ℕ} {clock : RobustClock.Specification T P C} |
| {label : P → Fin g'} {reserved : P → ℤ} |
| (S : Early (Alphabet := Alphabet) clock B size label reserved) |
| (g : ℕ) (L : Late Alphabet B S.diameter (S.sweepWidth g) (S.envelope g) (S.β (Fin.last g'))) |
|
|
| lemma earlyLast_nonneg : 0 ≤ S.β (Fin.last g') := by |
| rw [←S.β_zero] |
| exact S.β_strict.monotone (Fin.zero_le _) |
|
|
| lemma offset_envelope {a : ℤ} (ha : a ∈ (S.cuts g).offsets) : |a| ≤ S.envelope g := by |
| have hh := abs_le_finiteBound ha |
| have hw' := S.sweepWidth_pos g |
| have hrest : 0 ≤ 2*|((B*S.R:ℕ):ℤ)|+|S.rule.r|+ |
| (absoluteBound (fun j : Fin (g+1) => S.inner.boundary j.val):ℤ)+ |
| (absoluteBound S.inner.H:ℤ)+|S.inner.extension|+ |
| (3*(innerD S.p (B*S.R))^2+1:ℕ)+(size*innerD S.p (B*S.R):ℕ) := by positivity |
| dsimp only [envelope] |
| omega |
|
|
| lemma cut_bounds {f : ℤ → Alphabet} {s b a : ℤ} (ha : a ∈ (S.cuts g).offsets) |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) : |
| s<s+L.lag+a ∧ s+L.lag+a<b := by |
| have hbound := abs_le.mp (S.offset_envelope g ha) |
| have hlag := L.lag_margin |
| have hlast := S.earlyLast_nonneg |
| have hoff := L.offset_margin |
| have hb := L.complete_lower he |
| have hw := (S.sweepWidth_pos g).le |
| have hwidth := L.endRule.width_nonneg |
| have hr := L.radius_nonneg |
| have hK : (0:ℤ) ≤ L.endRule.K := Int.natCast_nonneg _ |
| constructor <;> omega |
| |
| lemma shifted_inner_visible (hB : 0<B) {f : ℤ → Alphabet} {s b δ : ℤ} |
| (hδ : |δ| ≤ S.sweepWidth g) |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) |
| (j : Fin (g+1)) (u : Fin B) : |
| (S.parameters g L hB).InnerVisible (s+S.β (Fin.last g')) b (s+L.lag+δ) j u := by |
| let A := S.parameters g L hB |
| have hh := S.actual_visible g L hB (Q := s+L.lag+δ+u) hδ he |
| have hw : 0 ≤ A.w₀ := Int.natCast_nonneg _ |
| have hv := ExceptionalOrigins.Parameters.Visible.innerVisible A hh hw j |
| rw [show s+L.lag+δ+(u:ℤ)-(s+L.lag+δ)=(u:ℤ) by ring] at hv |
| have hres : A.residue (u:ℤ)=u := A.residue_cast u |
| rw [hres] at hv |
| exact hv |
|
|
| lemma main_prefix_visible (hB : 0<B) {f : ℤ → Alphabet} {s b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) |
| (j : Fin g) (a : ℕ) (i : Fin (g+1)) (hi : i.val≤j.val) (u : Fin B) : |
| (S.parameters g L hB).InnerVisible s (s+L.lag+(S.cuts g).main j+a*B) (s+L.lag) i u := by |
| have hw : |(0:ℤ)|≤S.sweepWidth g := by simpa using (S.sweepWidth_pos g).le |
| have hv := S.shifted_inner_visible g L hB hw he i u |
| have hm := S.inner.main_before hB (by have := S.rule.radius_ge;omega) i.val j.val a u hi |
| have hlast := S.earlyLast_nonneg |
| constructor |
| · have hh := hv.1 |
| change s + S.β (Fin.last g') ≤ s + L.lag + 0 + S.inner.boundary i.val - S.rule.r at hh |
| change s ≤ s + L.lag + S.inner.boundary i.val - S.rule.r |
| omega |
| · change s+L.lag+S.inner.boundary i.val+S.inner.H u+S.rule.r ≤ |
| s+L.lag+S.inner.mainBase j.val+a*B |
| change S.inner.boundary i.val+S.inner.H u+S.rule.r < S.inner.mainBase j.val+a*B at hm |
| omega |
|
|
| lemma main_suffix_visible (hB : 0<B) {f : ℤ → Alphabet} {s b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) |
| (j : Fin g) (a a' : ℕ) (ha : a<S.R) (ha' : a'<S.R) |
| (i : Fin (g+1)) (hi : j.val < i.val) (u : Fin B) : |
| (S.parameters g L hB).InnerVisible (s+L.lag+(S.cuts g).main j+a*B) b |
| (s+L.lag+(a*B-a'*B)) i u := by |
| have hδ : |(a:ℤ)*B-a'*B|≤S.sweepWidth g := by |
| have hh := S.offsets_difference g ((S.cuts g).offset_mem (.inl j) a ha) |
| ((S.cuts g).offset_mem (.inl j) a' ha') |
| change |(S.cuts g).main j+a*B-((S.cuts g).main j+a'*B)|<S.sweepWidth g at hh |
| rw [show (S.cuts g).main j+(a:ℤ)*B-((S.cuts g).main j+a'*B)=a*B-a'*B by ring] at hh |
| exact hh.le |
| have hv := S.shifted_inner_visible g L hB hδ he i u |
| have hm := S.inner.main_after hB (by have := S.rule.radius_ge;omega) |
| i.val j.val a' (s+L.lag+S.inner.mainBase j.val+a*B) hi ha' |
| constructor |
| · change s+L.lag+S.inner.mainBase j.val+a*B ≤ |
| s+L.lag+(a*B-a'*B)+S.inner.boundary i.val-S.rule.r |
| omega |
| · exact hv.2 |
| |
| lemma periodic_prefix_visible (hB : 0<B) {f : ℤ → Alphabet} {s b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (s+L.lag+L.endRule.offset) (L.endRule.small f (s+L.lag+L.endRule.offset)) b) |
| (j : Fin (g+1)) (u : Fin B) (a : ℕ) : |
| (S.parameters g L hB).InnerVisible s (s+L.lag+(S.cuts g).periodic j u+a*B) (s+L.lag) j u := by |
| have hw : |(0:ℤ)|≤S.sweepWidth g := by simpa using (S.sweepWidth_pos g).le |
| have hv := S.shifted_inner_visible g L hB hw he j u |
| have hm := S.inner.periodic_before j.val a u |
| have hlast := S.earlyLast_nonneg |
| constructor |
| · have hh := hv.1 |
| change s + S.β (Fin.last g') ≤ s + L.lag + 0 + S.inner.boundary j.val - S.rule.r at hh |
| change s ≤ s + L.lag + S.inner.boundary j.val - S.rule.r |
| omega |
| · change s+L.lag+S.inner.boundary j.val+S.inner.H u+S.rule.r ≤ |
| s+L.lag+(S.inner.boundary j.val+S.inner.H u+S.inner.lag+0*B)+a*B |
| change S.inner.boundary j.val+S.inner.H u+S.rule.r < |
| S.inner.boundary j.val+S.inner.H u+S.inner.lag+a*B at hm |
| omega |
|
|
| end SourceSchedule.Early |
|
|
| end GeneralizedStarHeight |
|
|
| end OAI |
|
|
