| import OAI.Computability.StarHeight.SplitLanguages |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uAlphabet uT uP uC uAlphabet2 uM uV uK |
| universe uC2 uAlphabet3 uM2 uAlphabet4 uM3 uV2 uK2 |
|
|
| namespace SourceSchedule.Early |
|
|
| open WordIntervals SplitMetadata LocalMarkers |
| variable {Alphabet : Type uAlphabet} {T : Type uT} {P : Type uP} {C : Type uC} [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'))) |
| (hB : 0<B) |
|
|
| lemma clock_period : (S.parameters g L hB).φ (S.period:ℤ)=0 := |
| PeriodicClock.period S.denominator S.numerator (fun c => (S.prime c).pos) |
|
|
| lemma episode_last {f : ℤ → Alphabet} {b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (L.lag+L.endRule.offset) (L.endRule.small f (L.lag+L.endRule.offset)) b) : |
| S.β (Fin.last g')≤b := by |
| have hb := L.complete_lower (s := 0) (by simpa only [zero_add] using he) |
| have hlag := L.lag_margin |
| have hoff := L.offset_margin |
| have hE := (S.envelope_pos g).le |
| have hw := (S.sweepWidth_pos g).le |
| have hr := L.radius_nonneg |
| have hwidth := L.endRule.width_nonneg |
| have hK : (0:ℤ)≤L.endRule.K := Int.natCast_nonneg _ |
| omega |
|
|
| lemma episode_visible {f : ℤ → Alphabet} {b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (L.lag+L.endRule.offset) (L.endRule.small f (L.lag+L.endRule.offset)) b) : |
| (S.parameters g L hB).Visible 0 b L.lag |
| ((S.parameters g L hB).anchor f (b-L.endRule.tail) L.lag) := by |
| have hh := S.actual_visible g L hB (s := 0) (δ := 0) |
| (Q := (S.parameters g L hB).anchor f (b-L.endRule.tail) L.lag) |
| (by simpa only [abs_zero] using (S.sweepWidth_pos g).le) |
| (by simpa only [zero_add] using he) |
| simp only [zero_add,add_zero] at hh |
| exact hh.mono _ S.earlyLast_nonneg (le_refl b) |
|
|
| lemma episode_inner_start {f : ℤ → Alphabet} {b : ℤ} |
| (he : EpisodeEnd.EndAt L.endRule.d L.endRule.K L.endRule.tail f |
| (L.lag+L.endRule.offset) (L.endRule.small f (L.lag+L.endRule.offset)) b) |
| (i : Fin (g+1)) (q : ℤ) |
| (hq : (S.parameters g L hB).inner f i |
| ((S.parameters g L hB).residue ((S.parameters g L hB).anchor f (b-L.endRule.tail) L.lag-L.lag)) |
| L.lag=some q) : S.β (Fin.last g')≤q := by |
| have hv := S.actual_visible g L hB (s := 0) (δ := 0) |
| (Q := (S.parameters g L hB).anchor f (b-L.endRule.tail) L.lag) |
| (by simpa only [abs_zero] using (S.sweepWidth_pos g).le) |
| (by simpa only [zero_add] using he) |
| have hh := (hv.inner i).1 |
| have hq' := (S.parameters g L hB).inner_bounds hq |
| have hr : 0≤(S.parameters g L hB).innerRule.r := |
| (Int.natCast_nonneg _).trans (S.parameters g L hB).innerRule.radius_ge |
| have hw : 0≤(S.parameters g L hB).w₀ := Int.natCast_nonneg _ |
| simp only [zero_add,add_zero] at hh |
| omega |
|
|
| end SourceSchedule.Early |
| namespace SourceSchedule.Early |
|
|
| open WordIntervals SplitMetadata LocalMarkers EpisodeAlgebra |
| variable {Alphabet : Type uAlphabet2} {M : Type uM} {V : Type uV} {K : Type uK} {C : Type uC2} [Monoid M] [Field K] [AddCommGroup V] [Module K V] |
| [Fintype M] [Fintype V] [Fintype K] [Fintype C] [Finite Alphabet] [Nonempty Alphabet] |
| {g g' μ B : ℕ} |
| {clock : RobustClock.Specification (Tag M V g B) (Roster M (V × K) K g' μ) C} |
| {reserved : Roster M (V × K) K g' μ → ℤ} |
| (S : Early (Alphabet := Alphabet) clock B (Fintype.card M) (fun i => i.1.j) reserved) |
| (L : Late Alphabet B S.diameter (S.sweepWidth g) (S.envelope g) (S.β (Fin.last g'))) |
| (hB : 0<B) (T : FreeMonoid Alphabet →* M) (ρ : M → (V →ₗ[K] V)) |
| (β : M → M → (Fin g → M) → V) |
| (γ : (M → (V × K →ₗ[K] V × K)) → (Fin g' → M) → V × K) |
|
|
| lemma inner_graph_height |
| (hmod : ∀ i j i' j', i ≠ j → i' ≠ j' → (i,j) ≠ (i',j') → |
| (reserved i-reserved j)%B ≠ (reserved i'-reserved j')%B) |
| (hμ : 20*(10000000*Real.log (2*Fintype.card (Tag M V g B))+4*(g+1))+10<μ) |
| (hγ : ∀ ψ, ShiftTableProperty g' (ObservedInner.table ψ) (γ ψ)) |
| (reference : Roster M (V × K) K g' μ) (x y : V × K) : |
| HasHeightAtMost (graph ((S.parameters g L hB).failedDomain L.lag) |
| (InnerStream.wordUpdate (S.parameters g L hB) clock T ρ β S.β γ L.lag) x y) 2 := by |
| let A := S.parameters g L hB |
| have hw₀ : 0≤A.w₀ := Int.natCast_nonneg _ |
| have hm := L.decoder_margins hB S.diameter_pos.le (S.sweepWidth_pos g).le |
| have hs : SplitSound (A.failedDomain L.lag) (InnerStream.wordUpdate A clock T ρ β S.β γ L.lag) |
| (InnerStream.prefixLanguage T S.β γ S.p) |
| (InnerStream.suffixLanguage A clock T ρ β S.β S.p L.lag reference) := by |
| apply InnerStream.word_sound A clock T ρ β S.β γ S.p L.lag reference |
| S.β_strict S.β_zero S.block hw₀ (fun f b he => S.episode_visible g L hB he) |
| · intro f b he a i |
| have hh := S.roster_visible L hB (s := 0) (by simpa only [A,parameters,zero_add] using he) a i |
| convert hh using 1 <;> simp only [SuffixDecoder.origin,zero_add] <;> congr 1 <;> ring |
| · intro a |
| have hh := difference_bound S.p a reference |
| change |S.p a-S.p reference|≤S.diameter at hh |
| change (L.endRule.d:ℤ)^2≤L.endRule.K-_ |
| omega |
| · intro a |
| exact (difference_bound S.p a reference).trans_lt hm.2.2 |
| · exact fun f b he => S.episode_last g L he |
| have ha : SplitAvailable (A.failedDomain L.lag) 0 (InnerStream.wordUpdate A clock T ρ β S.β γ L.lag) |
| (InnerStream.prefixLanguage T S.β γ S.p) |
| (InnerStream.suffixLanguage A clock T ρ β S.β S.p L.lag reference) := by |
| apply InnerStream.word_available A clock T ρ β S.β γ S.p L.lag reference |
| S.β_strict.monotone S.β_zero S.block hw₀ (fun f b he => S.episode_visible g L hB he) (fun f b he => S.episode_last g L he) |
| intro f b he hf x |
| simpa only [zero_add] using S.inner_available L hB T ρ β γ hmod hμ hγ reference |
| (s := 0) (by simpa only [A,parameters,zero_add] using he) (by simpa only [A,parameters,zero_add] using hf) x |
| exact split_height (L.endRule.prefix_code L.lag) (A.failedDomain_subset L.lag) bot_le |
| (InnerStream.wordUpdate A clock T ρ β S.β γ L.lag) |
| (InnerStream.prefixLanguage T S.β γ S.p) |
| (InnerStream.suffixLanguage A clock T ρ β S.β S.p L.lag reference) hs ha 0 |
| (A.failedDomain_height S.period S.period_pos (S.clock_period g L hB) hw₀ L.lag) |
| (fun x => (InnerStream.prefix_height T S.β γ S.p x).mono (by decide)) |
| (InnerStream.suffix_height A clock T ρ β S.β S.p L.lag S.period S.period_pos |
| (S.clock_period g L hB) hw₀ reference) |
| (empty_skip_height _) x y |
|
|
| lemma failed_outer_graph_height |
| (hmod : ∀ i j i' j', i ≠ j → i' ≠ j' → (i,j) ≠ (i',j') → |
| (reserved i-reserved j)%B ≠ (reserved i'-reserved j')%B) |
| (hμ : 20*(10000000*Real.log (2*Fintype.card (Tag M V g B))+4*(g+1))+10<μ) |
| (hγ : ∀ ψ, ShiftTableProperty g' (ObservedInner.table ψ) (γ ψ)) |
| (reference : Roster M (V × K) K g' μ) (x y : V) : |
| HasHeightAtMost (graph ((S.parameters g L hB).failedDomain L.lag) |
| (OuterStream.wordUpdate (S.parameters g L hB) clock T ρ β L.lag) x y) 2 := by |
| let A := S.parameters g L hB |
| have hG := S.inner_graph_height L hB T ρ β γ hmod hμ hγ reference |
| have hlin := AffineRecovery.recovery_height (L.endRule.prefix_code L.lag) |
| (A.failedDomain_subset L.lag) |
| (fun w => (InnerStream.wordLinear A clock T ρ β S.β L.lag w).toAddMonoidHom) |
| (InnerStream.wordShift A clock T ρ β S.β γ L.lag) 2 (fun x y => by |
| rw [←InnerStream.wordUpdate_affine A clock T ρ β S.β γ L.lag] |
| exact hG x y) |
| apply InnerStream.linear_graph_recovery A clock T ρ β S.β S.β_strict.monotone S.β_zero L.lag 2 |
| (fun w hw => S.episode_last g L (A.endRule.complete_realizes hw.1 (stream_realizes w)).2) |
| (fun w hw => S.episode_inner_start g L hB (A.endRule.complete_realizes hw.1 (stream_realizes w)).2) |
| hlin x y |
|
|
| lemma outer_graph_height |
| (hmod : ∀ i j i' j', i ≠ j → i' ≠ j' → (i,j) ≠ (i',j') → |
| (reserved i-reserved j)%B ≠ (reserved i'-reserved j')%B) |
| (hμ : 20*(10000000*Real.log (2*Fintype.card (Tag M V g B))+4*(g+1))+10<μ) |
| (hβ : ∀ a c, ShiftTableProperty g (ClockAffine.productTable ρ a c) (β a c)) |
| (hγ : ∀ ψ, ShiftTableProperty g' (ObservedInner.table ψ) (γ ψ)) |
| (innerReference : Roster M (V × K) K g' μ) (outerReference : ℤ) |
| (hr : outerReference∈(S.cuts g).offsets) (x y : V) : |
| HasHeightAtMost (graph (L.endRule.complete L.lag) |
| (OuterStream.wordUpdate (S.parameters g L hB) clock T ρ β L.lag) x y) 3 := by |
| let A := S.parameters g L hB |
| have hw₀ : 0≤A.w₀ := Int.natCast_nonneg _ |
| have hs := OuterStream.word_sound A (S.cuts g) clock T ρ β (S.geometry g L hB) |
| L.lag outerReference hw₀ (fun f b he => S.episode_visible g L hB he) |
| have ha : SplitAvailable (L.endRule.complete L.lag) (A.failedDomain L.lag) |
| (OuterStream.wordUpdate A clock T ρ β L.lag) |
| (OuterStream.prefixLanguage A (S.cuts g) clock T ρ β L.lag) |
| (OuterStream.suffixLanguage A (S.cuts g) clock T ρ outerReference) := by |
| apply OuterStream.word_available A (S.cuts g) clock T ρ β L.lag outerReference hw₀ |
| (fun f b he => S.episode_visible g L hB he) |
| intro f b he hn x |
| simpa only [A,parameters,zero_add] using S.outer_available L hB T ρ β hβ hr |
| (s := 0) (by simpa only [A,parameters,zero_add] using he) (by simpa only [A,parameters,zero_add] using hn) x |
| exact split_height (L.endRule.prefix_code L.lag) le_rfl (A.failedDomain_subset L.lag) |
| (OuterStream.wordUpdate A clock T ρ β L.lag) |
| (OuterStream.prefixLanguage A (S.cuts g) clock T ρ β L.lag) |
| (OuterStream.suffixLanguage A (S.cuts g) clock T ρ outerReference) hs ha 2 |
| (L.endRule.complete_height L.lag) |
| (fun x => (OuterStream.prefix_height A (S.cuts g) clock T ρ β L.lag x).mono (by decide)) |
| (OuterStream.suffix_height A (S.cuts g) clock T ρ S.period S.period_pos |
| (S.clock_period g L hB) outerReference) |
| (S.failed_outer_graph_height L hB T ρ β γ hmod hμ hγ innerReference) x y |
|
|
| end SourceSchedule.Early |
| namespace CanonicalEpisodes.Parameters |
|
|
| open LocalMarkers WordIntervals EpisodeEnd EpisodeAlgebra |
| variable {Alphabet : Type uAlphabet3} (C : CanonicalEpisodes.Parameters Alphabet) |
|
|
| lemma remainder_fiber_height [Finite Alphabet] [Nonempty Alphabet] {M : Type uM2} |
| [Monoid M] [Fintype M] (T : FreeMonoid Alphabet →* M) (d : M) (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 ({w | w∈remainder (C.complete lag) ∧ T (FreeMonoid.ofList w)=d} : Language Alphabet) 1 := by |
| obtain ⟨N,hN⟩ := C.remainder_middle lag hvisible |
| have hreg : Language.IsRegular |
| ({w | w∈remainder (C.complete lag) ∧ T (FreeMonoid.ofList w)=d} : Language Alphabet) := |
| (C.remainder_regular lag).inf (FiniteRecognition.regular_recognized T {d}) |
| exact PeriodicTemplates.regular_middle_height _ hreg |
| (N+C.tail.toNat) N C.tail.toNat C.d (fun w hw => hN w hw.1) |
|
|
| end CanonicalEpisodes.Parameters |
|
|
| namespace SourceSchedule |
|
|
| open SplitMetadata EpisodeAlgebra |
|
|
| theorem episode_linear_graphs {Alphabet : Type uAlphabet4} {M : Type uM3} {V : Type uV2} {K : Type uK2} |
| [Finite Alphabet] [Nonempty Alphabet] [Monoid M] [Fintype M] |
| [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] |
| (T : FreeMonoid Alphabet →* M) (ρ : M → (V →ₗ[K] V)) : |
| ∃ E : Language Alphabet, PrefixCode E ∧ |
| (∀ d : M, HasHeightAtMost ({w | w∈remainder E ∧ T (FreeMonoid.ofList w)=d} : Language Alphabet) 1) ∧ |
| ∀ x y : V, HasHeightAtMost (graph E (fun w => ρ (T (FreeMonoid.ofList w))) x y) 3 := by |
| classical |
| let : Fintype Alphabet := Fintype.ofFinite Alphabet |
| obtain ⟨g,hg,hs₁⟩ := exists_shift_table (A := M) (K := K) (S := V) |
| let β : M → M → (Fin g → M) → V := fun a c => (hs₁ (ClockAffine.productTable ρ a c)).choose |
| have hβ : ∀ a c, ShiftTableProperty g (ClockAffine.productTable ρ a c) (β a c) := |
| fun a c => (hs₁ (ClockAffine.productTable ρ a c)).choose_spec |
| obtain ⟨g',hg',hs₂⟩ := exists_shift_table (A := M) (K := K) (S := V × K) |
| let γ : (M → (V × K →ₗ[K] V × K)) → (Fin g' → M) → V × K := |
| fun ψ => (hs₂ (ObservedInner.table ψ)).choose |
| have hγ : ∀ ψ, ShiftTableProperty g' (ObservedInner.table ψ) (γ ψ) := |
| fun ψ => (hs₂ (ObservedInner.table ψ)).choose_spec |
| let κ := Fintype.card (Kind M (V × K) K g') |
| obtain ⟨μ,hμpos,hμ⟩ := exists_copies (M := M) (S := V) g κ (by omega) |
| let P := Roster M (V × K) K g' μ |
| let B := SlotResidues.slotModulus P |
| have hB : 0<B := SlotResidues.slotModulus_pos P |
| have hμ' : 20*(10000000*Real.log (2*Fintype.card (Tag M V g B))+4*(g+1))+10<μ := by |
| simpa only [B,SlotResidues.slotModulus,P,Fintype.card_prod,Fintype.card_fin,κ] using hμ |
| let : Nonempty (Tag M V g B) := ⟨Sum.inr ⟨0,⟨0,hB⟩,1,0,0⟩⟩ |
| obtain ⟨clock⟩ := RobustClock.exists_clock (Tag M V g B) P |
| have honto : Function.Surjective (fun i : P => i.1.j) := by |
| intro j |
| exact ⟨(⟨j,0,0,fun _ => 1,fun _ => 0⟩,⟨0,hμpos⟩),rfl⟩ |
| let reference : P := (⟨⟨0,by omega⟩,0,0,fun _ => 1,fun _ => 0⟩,⟨0,hμpos⟩) |
| obtain ⟨S⟩ := exists_early (Alphabet := Alphabet) clock B (Fintype.card M) hB |
| (fun i : P => i.1.j) honto (SlotResidues.reserved P) |
| obtain ⟨L⟩ := S.exists_full_late hB g |
| let A := S.parameters g L hB |
| let j : Fin g := ⟨0,by omega⟩ |
| have hr : (S.cuts g).main j∈(S.cuts g).offsets := by |
| simpa only [OuterStream.Cuts.base,Nat.cast_zero,zero_mul,add_zero] using |
| (S.cuts g).offset_mem (.inl j) 0 S.R_pos |
| have hG := S.outer_graph_height L hB T ρ β γ |
| (SlotResidues.reserved_distinct P) hμ' hβ hγ reference ((S.cuts g).main j) hr |
| have hlin := AffineRecovery.recovery_height (L.endRule.prefix_code L.lag) le_rfl |
| (fun w => (ρ (T w)).toAddMonoidHom) (OuterStream.wordShift A clock T ρ β L.lag) 3 |
| (fun x y => by |
| rw [←OuterStream.wordUpdate_affine A clock T ρ β L.lag] |
| exact hG x y) |
| refine ⟨L.endRule.complete L.lag,L.endRule.prefix_code L.lag,?_,hlin⟩ |
| intro d |
| exact L.endRule.remainder_fiber_height T d L.lag |
| (fun f b he => (S.episode_visible g L hB he).base) |
|
|
| end SourceSchedule |
|
|
| end GeneralizedStarHeight |
|
|
| end OAI |
|
|
