| import OAI.Computability.StarHeight.OriginBounds |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uAlphabet uM uV uK uP uC uAlphabet2 uM2 |
| universe uV2 uK2 uP2 uC2 uAlphabet3 uAlphabet4 uT uP3 |
| universe uC3 uAlphabet5 uM3 uV3 uK3 uC4 uP4 |
|
|
| namespace SourceSchedule.Early |
|
|
| open SplitMetadata WordIntervals LocalMarkers BoundarySnapshot |
| open scoped Classical BigOperators |
|
|
| 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 g' B : ℕ} {clock : RobustClock.Specification (Tag M V g B) P C} |
| {label : P → Fin g'} {reserved : P → ℤ} |
| (S : Early (Alphabet := Alphabet) clock B (Fintype.card M) label 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) |
|
|
| lemma outer_available |
| (hβ : ∀ a c, ShiftTableProperty g (ClockAffine.productTable ρ a c) (β a c)) |
| {f : ℤ → Alphabet} {s b reference : ℤ} |
| (hr : reference ∈ (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) |
| (hn : ¬(S.parameters g L hB).Failed f (s+L.lag) |
| ((S.parameters g L hB).anchor f (b-L.endRule.tail) (s+L.lag))) (x : V) : |
| ∃ (tag : Tag M V g B) (k : ℤ), tag.input=x ∧ |
| OuterStream.Prefix (S.parameters g L hB) (S.cuts g) clock T ρ β tag f s (s+L.lag) k ∧ |
| OuterStream.Suffix (S.parameters g L hB) (S.cuts g) clock T ρ reference tag f k b ∧ |
| tag.output=OuterStream.update (S.parameters g L hB) clock T ρ β f s b (s+L.lag) x := by |
| let A := S.parameters g L hB |
| let H := S.cuts g |
| let t := s+L.lag |
| let q := A.anchor f (b-A.endRule.tail) t |
| let u := A.residue (q-t) |
| have hpos : ∀ (role : H.Role) (a : ℕ), a<H.count role → |
| s<t+H.base role+a*B ∧ t+H.base role+a*B ≤ b := by |
| intro role a ha |
| have hh := S.cut_bounds g L (H.offset_mem role a ha) he |
| dsimp only [t] |
| exact ⟨by omega,by omega⟩ |
| have hvis : ∀ i, A.InnerVisible s b t i u := by |
| intro i |
| have hh := S.shifted_inner_visible g L hB |
| (δ := 0) (by simpa using (S.sweepWidth_pos g).le) he i u |
| simp only [add_zero] at hh |
| have hlast := S.earlyLast_nonneg |
| exact ⟨by have := hh.1;dsimp only [A,t] at *;omega,hh.2⟩ |
| have hwidth : ∀ a ∈ H.offsets, ∀ a' ∈ H.offsets, |a-a'| ≤ A.w := by |
| intro a ha a' ha' |
| exact (S.offsets_difference g ha ha').le |
| by_cases hp : ∀ i, A.inner f i u t ≠ none |
| · obtain ⟨tag,k,hx,hpre,hsuf,hout⟩ := OuterStream.available_main A H clock T ρ β |
| (S.geometry g L hB) rfl S.net (le_refl _) hwidth hβ hr he hn |
| (fun j a ha => hpos (.inl j) a ha) |
| (fun j a _ i hi => S.main_prefix_visible g L hB he j a i hi u) |
| (fun j a ha a' ha' i hi => S.main_suffix_visible g L hB he j a a' ha ha' i hi u) |
| hvis hp x |
| exact ⟨.inl tag,k,hx,hpre,hsuf,hout⟩ |
| · push Not at hp |
| obtain ⟨j,hj⟩ := hp |
| let z := t+S.inner.boundary j.val |
| have hboundary : 0 ≤ S.inner.boundary j.val := by |
| exact mul_nonneg (Int.natCast_nonneg _) (by have := S.inner.gap_pos;omega) |
| have hs : s ≤ z+innerD S.p (B*S.R) := by |
| have hl := L.lag_pos |
| have hd : (0:ℤ) ≤ innerD S.p (B*S.R) := Int.natCast_nonneg _ |
| dsimp [z,t] |
| omega |
| have hnomarker : ∀ y, z ≤ y → y ≤ z+S.inner.H u+S.inner.extension → y∉S.rule.markers f := |
| A.not_failed_absent hn j hj |
| obtain ⟨p,hp,hpd,hprogress⟩ := PeriodicCuts.progression S.inner S.rule |
| (innerD_ge S.p (B*S.R)) (by omega) (by have := S.rule.radius_ge;omega) |
| hB S.period_pos T f s z u hs hnomarker |
| have hcop : Nat.Coprime (p*(Fintype.card M).factorial*B) S.period := by |
| apply PeriodicClock.progression_coprime S.denominator S.prime hp hpd |
| (Nat.factorial_pos _) hB |
| intro c |
| have hh := S.den_large c |
| exact ⟨(le_max_left _ _).trans_lt ((le_max_right _ _).trans_lt hh), |
| (le_max_right _ _).trans_lt ((le_max_right _ _).trans_lt hh), |
| (le_max_left _ _).trans_lt hh⟩ |
| have hprog : ∀ a : ℕ, a<S.period → a*(p*(Fintype.card M).factorial)<H.N ∧ |
| product T f s (t+H.periodic j u+(a:ℤ)*(p*(Fintype.card M).factorial:ℕ)*B) = |
| product T f s (t+H.periodic j u) := by |
| intro a ha |
| obtain ⟨ha',hprod⟩ := hprogress a ha |
| refine ⟨by simpa only [H,cuts,period,Nat.mul_assoc] using ha',?_⟩ |
| have h₁ : t+H.periodic j u+(a:ℤ)*(p*(Fintype.card M).factorial:ℕ)*B = |
| z+S.inner.H u+S.inner.lag+(a*p*(Fintype.card M).factorial*B:ℕ) := by |
| dsimp only [H,cuts,IntegerSchedules.Inner.periodicOffset,z] |
| push_cast |
| ring |
| have h₂ : t+H.periodic j u=z+S.inner.H u+S.inner.lag := by |
| dsimp only [H,cuts,IntegerSchedules.Inner.periodicOffset,z] |
| ring |
| rw [h₁,h₂] |
| exact hprod |
| obtain ⟨tag,k,hx,hpre,hsuf,hout⟩ := OuterStream.available_periodic A H clock T ρ β |
| (S.geometry g L hB) rfl S.net hwidth hr he hn |
| (fun j u a ha => hpos (.inr (j,u)) a ha) |
| (fun j a _ => S.periodic_prefix_visible g L hB he j u a) j hj S.period_pos |
| (PeriodicClock.period S.denominator S.numerator (fun c => (S.prime c).pos)) hcop hprog x |
| exact ⟨.inr tag,k,hx,hpre,hsuf,hout⟩ |
|
|
| end SourceSchedule.Early |
|
|
| namespace InnerStream |
|
|
| open WordIntervals SplitMetadata LocalMarkers |
|
|
| 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 K] [Fintype P] [Fintype C] {g g' μ : ℕ} |
| (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 available |
| (hγ : ∀ ψ, ShiftTableProperty g' (ObservedInner.table ψ) (γ ψ)) |
| {s b H : ℤ} {f : ℤ → Alphabet} (reference : Roster M (V × K) K g' μ) |
| (hbad : (A.bad p f (s+lag) (b-A.endRule.tail)).card < μ) |
| (hvis : ∀ a i, A.Visible (s+p a) b (s+lag+(p a-p i)) |
| (A.anchor f (b-A.endRule.tail) (s+lag+(p a-p i)))) |
| (hnear : ∀ i j, |p i-p j| ≤ H) |
| (hnest : (A.endRule.d : ℤ)+(A.endRule.B-1)*A.endRule.S+H ≤ 3*A.endRule.d) |
| (hover : (A.endRule.d : ℤ)^2 ≤ A.endRule.K-H) (hover' : H<A.endRule.K) |
| (hend : EpisodeEnd.EndAt A.endRule.d A.endRule.K A.endRule.tail f |
| (s+lag+A.endRule.offset) (A.endRule.small f (s+lag+A.endRule.offset)) b) |
| (hfailed : A.Failed f (s+lag) (A.anchor f (b-A.endRule.tail) (s+lag))) (x : V × K) : |
| ∃ (slot : Roster M (V × K) K g' μ) (k : ℤ), slot.1.input=x ∧ |
| Prefix T early γ p slot f s k ∧ |
| Suffix A clock T ρ β early p lag reference slot f k b ∧ |
| slot.1.output=update A clock T ρ β early γ f s b (s+lag) x := by |
| let ψ := hypothetical A clock T ρ β early f s b (s+lag) |
| obtain ⟨kind,hx,hp,hq,hout⟩ := ObservedInner.available T γ f (fun i => s+early i) ψ x (hγ ψ) |
| obtain ⟨copy,hcopy⟩ := SuffixDecoder.available_copy A p lag s b H f reference kind |
| hbad hvis hnear hnest hover hover' hend hfailed |
| let slot : Roster M (V × K) K g' μ := (kind,copy) |
| have hs : s+p slot-p slot=s := by ring |
| refine ⟨slot,s+p slot,hx,⟨rfl,hp⟩,⟨hcopy,?_⟩,hout⟩ |
| simpa only [hs] using hq |
|
|
| end InnerStream |
|
|
| namespace SourceSchedule.Late |
|
|
| variable {Alphabet : Type uAlphabet3} {B : ℕ} {h w E earlyLast : ℤ} |
| (L : Late Alphabet B h w E earlyLast) |
|
|
| lemma count_margins (hB : 0<B) (hh : 0 ≤ h) (hw : 0 ≤ w) : |
| 2*h+2*w<L.endRule.S ∧ |
| 2*h+((B:ℤ)-1)*L.endRule.S+2*w<L.endRule.d ∧ |
| 2*h+2*((B:ℤ)-1)*L.endRule.S<L.endRule.d := by |
| have hS := L.endRule.S_nonneg |
| have hBi : (1:ℤ) ≤ B := by exact_mod_cast hB |
| have hBS : 0 ≤ (B:ℤ)*L.endRule.S := mul_nonneg (by omega) hS |
| have hs := L.spacing |
| have hd := L.separation |
| constructor |
| · omega |
| constructor <;> nlinarith |
| |
| lemma decoder_margins (hB : 0<B) (hh : 0 ≤ h) (hw : 0 ≤ w) : |
| (L.endRule.d:ℤ)+(L.endRule.B-1)*L.endRule.S+h ≤ 3*L.endRule.d ∧ |
| (L.endRule.d:ℤ)^2 ≤ L.endRule.K-h ∧ h<L.endRule.K := by |
| have hBi : (1:ℤ) ≤ B := by exact_mod_cast hB |
| have hS := L.endRule.S_nonneg |
| have hBS : 0 ≤ (B:ℤ)*L.endRule.S := mul_nonneg (by omega) hS |
| have hd := L.separation |
| have hd₂ : (2:ℤ) ≤ L.endRule.d := by exact_mod_cast L.endRule.d_ge |
| have hK := L.endRule.seed_long |
| have hK' : 3*(L.endRule.d:ℤ)^2<L.endRule.K := by exact_mod_cast hK |
| rw [L.modulus] |
| have hh' : h<L.endRule.d := by nlinarith |
| refine ⟨?_,?_,?_⟩ <;> nlinarith [sq_nonneg (L.endRule.d:ℤ)] |
|
|
| end SourceSchedule.Late |
|
|
| namespace SourceSchedule.Early |
|
|
| open scoped Classical |
|
|
| variable {Alphabet : Type uAlphabet4} {T : Type uT} {P : Type uP3} {C : Type uC3} [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 full_bad_card |
| (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 T)+4*(g+1))+10<μ) |
| (f : ℤ → Alphabet) (t q₀ : ℤ) : |
| ((S.parameters g L hB).bad S.p f t q₀).card<μ := by |
| have hm : ∀ i j, (S.p i-S.p j)%B=(reserved i-reserved j)%B := by |
| intro i j |
| rw [Int.sub_emod,S.reserved_eq,S.reserved_eq,←Int.sub_emod] |
| have hmar := L.count_margins hB S.diameter_pos.le (S.sweepWidth_pos g).le |
| have hmod' : ∀ i j i' j', i ≠ j → i' ≠ j' → (i,j) ≠ (i',j') → |
| (S.p i-S.p j)%(S.parameters g L hB).B ≠ |
| (S.p i'-S.p j')%(S.parameters g L hB).B := by |
| intro i j i' j' hij hij' hn |
| change (S.p i-S.p j)%B ≠ (S.p i'-S.p j')%B |
| rw [hm,hm] |
| exact hmod i j i' j' hij hij' hn |
| have hgap₀ : 2*(S.parameters g L hB).w₀ ≤ 2*(B*S.R:ℕ)+2 := by |
| change 2*((B*S.R:ℕ):ℤ) ≤ 2*((B*S.R:ℕ):ℤ)+2 |
| omega |
| have hinner : 2*S.diameter+2*(S.parameters g L hB).w₀ < (S.parameters g L hB).d := by |
| have hh := innerD_bound S.p (B*S.R) |
| change 2*S.diameter+2*(B*S.R:ℕ)<(innerD S.p (B*S.R):ℤ) |
| have hpos := S.diameter_pos |
| have hBR : (0:ℤ) ≤ (B*S.R:ℕ) := Int.natCast_nonneg _ |
| change 10*(2*S.diameter+2*(B*S.R:ℕ)+5)<(innerD S.p (B*S.R):ℤ) at hh |
| omega |
| have hwidth : ∀ u v, u ≠ v → 2*S.diameter+ |
| 2*max (S.parameters g L hB).ext (S.parameters g L hB).w₀ < |
| |(S.parameters g L hB).H u-(S.parameters g L hB).H v| := by |
| intro u v huv |
| have hh := S.inner.H_separated u v huv |
| change 2*S.diameter+2*max S.inner.extension (B*S.R:ℕ) < |S.inner.H u-S.inner.H v| |
| change 2*S.diameter+2*max S.inner.extension (B*S.R:ℕ)+2 < |S.inner.H u-S.inner.H v| at hh |
| omega |
| exact ExceptionalOrigins.Parameters.bad_card (S.parameters g L hB) clock S.p S.diameter |
| (2*(B*S.R)+2) rfl S.approximate |
| (fun i j => difference_bound S.p i j) hmod' S.separated (Int.natCast_nonneg _) |
| hgap₀ hinner hwidth hmar.1 hmar.2.1 hmar.2.2 μ |
| (by simpa only [Fintype.card_fin,Nat.cast_add,Nat.cast_one] using hμ) f t q₀ |
|
|
| end SourceSchedule.Early |
|
|
| namespace SourceSchedule.Early |
|
|
| open WordIntervals SplitMetadata LocalMarkers |
|
|
| variable {Alphabet : Type uAlphabet5} {M : Type uM3} {V : Type uV3} {K : Type uK3} {C : Type uC4} [Monoid M] [Field K] [AddCommGroup V] [Module K V] |
| [Fintype M] [Fintype V] [Fintype K] [Fintype C] |
| {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) |
|
|
| omit [Monoid M] in |
| lemma roster_visible {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) |
| (a i : Roster M (V × K) K g' μ) : |
| (S.parameters g L hB).Visible (s+S.p a) b (s+L.lag+(S.p a-S.p i)) |
| ((S.parameters g L hB).anchor f (b-L.endRule.tail) (s+L.lag+(S.p a-S.p i))) := by |
| apply ExceptionalOrigins.Parameters.Visible.mono _ |
| (S.actual_visible g L hB (S.stencil_difference g a i).le he) _ (le_refl _) |
| have hb := (S.block a).2.trans_le (S.β_strict.monotone (Fin.le_last _)) |
| omega |
|
|
| lemma inner_available |
| (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 ψ) (γ ψ)) |
| {f : ℤ → Alphabet} {s b : ℤ} (reference : Roster M (V × K) K 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) |
| (hf : (S.parameters g L hB).Failed f (s+L.lag) |
| ((S.parameters g L hB).anchor f (b-L.endRule.tail) (s+L.lag))) (x : V × K) : |
| ∃ (slot : Roster M (V × K) K g' μ) (k : ℤ), slot.1.input=x ∧ |
| InnerStream.Prefix T S.β γ S.p slot f s k ∧ |
| InnerStream.Suffix (S.parameters g L hB) clock T ρ β S.β S.p L.lag reference slot f k b ∧ |
| slot.1.output=InnerStream.update (S.parameters g L hB) clock T ρ β S.β γ f s b (s+L.lag) x := by |
| have hm := L.decoder_margins hB S.diameter_pos.le (S.sweepWidth_pos g).le |
| exact InnerStream.available (S.parameters g L hB) clock T ρ β S.β γ S.p L.lag hγ reference |
| (S.full_bad_card g L hB hmod μ hμ f (s+L.lag) (b-L.endRule.tail)) |
| (S.roster_visible L hB he) (difference_bound S.p) hm.1 hm.2.1 hm.2.2 he hf x |
|
|
| end SourceSchedule.Early |
|
|
| namespace SlotResidues |
|
|
| variable (P : Type uP4) [Fintype P] |
|
|
| noncomputable def slotIndex (p : P) : ℤ := ((Fintype.equivFin P) p).val+1 |
| noncomputable def reserved (p : P) : ℤ := representative (Fintype.card P) (slotIndex P p) |
| noncomputable def slotModulus : ℕ := 20*(Fintype.card P+1)^3 |
|
|
| lemma slotIndex_bounds (p : P) : 1 ≤ slotIndex P p ∧ slotIndex P p ≤ Fintype.card P := by |
| have hh := ((Fintype.equivFin P) p).isLt |
| dsimp [slotIndex] |
| omega |
|
|
| lemma slotIndex_injective : Function.Injective (slotIndex P) := by |
| intro a b hh |
| apply (Fintype.equivFin P).injective |
| apply Fin.ext |
| dsimp [slotIndex] at hh |
| omega |
|
|
| lemma reserved_distinct (i j i' j' : P) (hij : i ≠ j) (hij' : i' ≠ j') |
| (hn : (i,j) ≠ (i',j')) : |
| (reserved P i-reserved P j)%slotModulus P ≠ |
| (reserved P i'-reserved P j')%slotModulus P := by |
| have hi := slotIndex_bounds P i |
| have hj := slotIndex_bounds P j |
| have hi' := slotIndex_bounds P i' |
| have hj' := slotIndex_bounds P j' |
| have hN : (0:ℤ)<Fintype.card P := by omega |
| intro hh |
| have hB : (slotModulus P:ℤ)=modulus (Fintype.card P) := by |
| simp only [slotModulus,modulus,Nat.cast_mul,Nat.cast_add,Nat.cast_pow,Nat.cast_ofNat,Nat.cast_one] |
| rw [hB] at hh |
| obtain ⟨h₁,h₂⟩ := distinct_differences hN hi.1 hi.2 hj.1 hj.2 hi'.1 hi'.2 hj'.1 hj'.2 |
| ((slotIndex_injective P).ne hij) ((slotIndex_injective P).ne hij') hh |
| exact hn (Prod.ext ((slotIndex_injective P) h₁) ((slotIndex_injective P) h₂)) |
|
|
| lemma slotModulus_pos : 0<slotModulus P := by dsimp [slotModulus];positivity |
| |
| end SlotResidues |
| |
| end GeneralizedStarHeight |
| |
| end OAI |
| |
