| import OAI.Computability.Scheduling.GlobalBoundaries |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace ThreeMachine.Structure |
| namespace GlobalList |
| variable {J : Type} |
|
|
| noncomputable def append (K : GlobalList J) (A : Set J) : GlobalList J := by |
| classical |
| exact ⟨insert (max 1 (K.indices.sup id) + 1) K.indices, |
| fun i => if i = max 1 (K.indices.sup id) + 1 then A else K.entry i⟩ |
|
|
| def nextIndex (K : GlobalList J) : ℕ := max 1 (K.indices.sup id) + 1 |
|
|
| theorem lt_nextIndex {K : GlobalList J} {i : ℕ} (hi : i ∈ K.indices) : |
| i < K.nextIndex := by |
| have h := Finset.le_sup (f := id) hi |
| change i ≤ K.indices.sup id at h |
| dsimp [nextIndex] |
| omega |
|
|
| theorem nextIndex_not_mem (K : GlobalList J) : K.nextIndex ∉ K.indices := by |
| intro hi |
| exact (lt_irrefl _ (lt_nextIndex hi)).elim |
|
|
| theorem append_membership (K : GlobalList J) (A : Set J) (i : ℕ) (x : J) : |
| i ∈ (K.append A).memberships x ↔ |
| (i = K.nextIndex ∧ x ∈ A) ∨ (i ∈ K.indices ∧ x ∈ K.entry i) := by |
| classical |
| rw [mem_memberships] |
| change (i ∈ insert K.nextIndex K.indices ∧ |
| x ∈ (if i = K.nextIndex then A else K.entry i)) ↔ _ |
| by_cases hi : i = K.nextIndex |
| · subst i |
| simp [nextIndex_not_mem] |
| · simp [hi] |
|
|
| theorem append_qual (K : GlobalList J) (A : Set J) : |
| (K.append A).Qual = K.Qual ∪ A := by |
| ext x |
| constructor |
| · rintro ⟨i, hi, hx⟩ |
| rcases (append_membership K A i x).mp ((mem_memberships _ _ _).mpr ⟨hi, hx⟩) |
| with ⟨_, hx⟩ | ⟨hi, hx⟩ |
| · exact Or.inr hx |
| · exact Or.inl ⟨i, hi, hx⟩ |
| · rintro (⟨i, hi, hx⟩ | hx) |
| · exact ⟨i, (mem_memberships _ _ _).mp |
| ((append_membership K A i x).mpr (Or.inr ⟨hi, hx⟩))⟩ |
| · exact ⟨K.nextIndex, (mem_memberships _ _ _).mp |
| ((append_membership K A _ x).mpr (Or.inl ⟨rfl, hx⟩))⟩ |
|
|
| theorem append_upsets {K : GlobalList J} {A : Set J} {r : J → J → Prop} |
| (hK : K.Upsets r) (hA : GlobalUpset r A) : (K.append A).Upsets r := by |
| classical |
| intro i hi |
| change i ∈ insert K.nextIndex K.indices at hi |
| rcases Finset.mem_insert.mp hi with hi | hi |
| · subst i |
| simpa [append, nextIndex] using hA |
| · have hn : i ≠ K.nextIndex := (lt_nextIndex hi).ne |
| change GlobalUpset r (if i = K.nextIndex then A else K.entry i) |
| simpa [hn] using hK i hi |
|
|
| theorem append_lastIndex_of_mem {K : GlobalList J} {A : Set J} {x : J} |
| (hx : x ∈ A) : (K.append A).lastIndex x = K.nextIndex := by |
| apply le_antisymm |
| · apply Finset.sup_le |
| intro i hi |
| rcases (append_membership K A i x).mp hi with ⟨hi, _⟩ | ⟨hi, _⟩ |
| · exact hi.le |
| · exact (lt_nextIndex hi).le |
| · apply Finset.le_sup (f := id) (b := K.nextIndex) |
| exact (append_membership K A _ x).mpr (Or.inl ⟨rfl, hx⟩) |
|
|
| theorem append_lastIndex_of_not_mem {K : GlobalList J} {A : Set J} {x : J} |
| (hx : x ∉ A) : (K.append A).lastIndex x = K.lastIndex x := by |
| apply congrArg (fun s : Finset ℕ => s.sup id) |
| ext i |
| rw [append_membership, mem_memberships] |
| simp [hx] |
|
|
| theorem append_key_of_not_mem {K : GlobalList J} {A : Set J} {rank : J → ℕ} |
| {x y : J} (hx : x ∉ A) (hy : y ∉ A) : |
| (K.append A).KeyLT rank x y ↔ K.KeyLT rank x y := by |
| simp only [KeyLT, append_lastIndex_of_not_mem hx, append_lastIndex_of_not_mem hy] |
|
|
| theorem append_old_before_new {K : GlobalList J} {A : Set J} {rank : J → ℕ} |
| {x y : J} (hx : x ∈ K.Qual) (hxA : x ∉ A) (hy : y ∈ A) : |
| (K.append A).KeyLT rank x y := by |
| apply Or.inl |
| rw [append_lastIndex_of_not_mem hxA, append_lastIndex_of_mem hy] |
| exact lt_nextIndex (lastIndex_mem hx).1 |
|
|
| theorem injection_card_bound {K : GlobalList J} {r : J → J → Prop} |
| {W W' : Set J} {B : Finset J} {I : Finset ℕ} |
| (hI : I ⊆ K.indices) (hK : K.Upsets r) |
| (hB : (B : Set J) ⊆ W) |
| (hdisj : ∀ i ∈ I, ∀ j ∈ I, i ≠ j → |
| ∀ x ∈ W, x ∈ K.entry i → x ∉ K.entry j) |
| (hmeet : ∀ i ∈ I, (K.entry i ∩ W').Nonempty) |
| (hpred : ∀ x ∈ W', x ∈ K.Qual → ∃ z ∈ B, r x z) : I.card ≤ B.card := by |
| classical |
| have hex : ∀ i ∈ I, ∃ z ∈ B, z ∈ K.entry i := by |
| intro i hi |
| obtain ⟨x, hxi, hxW⟩ := hmeet i hi |
| obtain ⟨z, hz, hxz⟩ := hpred x hxW ⟨i, hI hi, hxi⟩ |
| exact ⟨z, hz, hK i (hI hi) hxz hxi⟩ |
| let f : ↥I → ↥B := fun i => |
| ⟨Classical.choose (hex i.val i.property), (Classical.choose_spec (hex i.val i.property)).1⟩ |
| have hf : ∀ i : ↥I, (f i).val ∈ K.entry i.val := fun i => |
| (Classical.choose_spec (hex i.val i.property)).2 |
| have hinj : Function.Injective f := by |
| intro i j he |
| apply Subtype.ext |
| by_contra hne |
| have e : (f i).val = (f j).val := congrArg Subtype.val he |
| exact hdisj i.val i.property j.val j.property hne (f i).val |
| (hB (f i).property) (hf i) (e ▸ hf j) |
| simpa using Fintype.card_le_of_injective f hinj |
|
|
| end GlobalList |
| end ThreeMachine.Structure |
|
|
| namespace ThreeMachine.Structure |
| variable {J : Type} |
|
|
| def Window (time : J → ℕ) (a b : ℕ) : Set J := {x | a < time x ∧ time x < b} |
|
|
| namespace Boundary |
|
|
| theorem pred_subset_weakPred (r : J → J → Prop) (B : Boundary J) : |
| B.pred r ⊆ B.weakPred r := by |
| cases B with |
| | left => exact Set.Subset.rfl |
| | right => exact Set.Subset.rfl |
| | actual Z => exact Set.subset_union_left |
|
|
| theorem desc_subset_weakDesc (r : J → J → Prop) (B : Boundary J) : |
| B.desc r ⊆ B.weakDesc r := by |
| cases B with |
| | left => exact Set.Subset.rfl |
| | right => exact Set.Subset.rfl |
| | actual Z => exact Set.subset_union_left |
|
|
| def Separates (B : Boundary J) (r : J → J → Prop) (time : J → ℕ) |
| (W S : Set J) (s : ℕ) : Prop := |
| (∀ x ∈ W, time x < s → x ∉ S → x ∈ B.pred r) ∧ |
| (∀ x ∈ W, s < time x → x ∈ S → x ∈ B.desc r) |
|
|
| def before (B : Boundary J) (r : J → J → Prop) (H : Set J) : Set J := |
| B.pred r ∪ (H \ B.weakDesc r) |
|
|
| theorem separates_description {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} |
| {B : Boundary J} {W S H : Set J} |
| (hrespect : ∀ u v, r u v → time u < time v) |
| (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s) |
| (hsep : B.Separates r time W S s) (hagree : ∀ x ∈ W, x ∈ H ↔ x ∈ S) : |
| ∀ x ∈ W, x ∈ B.before r H ↔ time x < s := by |
| intro x hx |
| constructor |
| · rintro (hP | ⟨hH, hnD⟩) |
| · exact pred_time hrespect hbound hB hP |
| · have hS := (hagree x hx).mp hH |
| by_contra hn |
| have hle : s ≤ time x := by omega |
| rcases hle.eq_or_lt with he | hl |
| · exact hnD (mem_weak_at_time hbound hB he.symm).2 |
| · exact hnD (desc_subset_weakDesc r B (hsep.2 x hx hl hS)) |
| · intro hlt |
| by_cases hS : x ∈ S |
| · refine Or.inr ⟨(hagree x hx).mpr hS, ?_⟩ |
| intro hD |
| have := weakDesc_time hrespect hbound hB hD |
| omega |
| · exact Or.inl (hsep.1 x hx hlt hS) |
|
|
| theorem separates_congr {r : J → J → Prop} {time : J → ℕ} |
| {B : Boundary J} {W S S' : Set J} {s : ℕ} |
| (h : ∀ x ∈ W, x ∈ S ↔ x ∈ S') : |
| B.Separates r time W S s ↔ B.Separates r time W S' s := by |
| unfold Separates |
| constructor <;> rintro ⟨hp, hd⟩ |
| · exact ⟨fun x hx ht hn => hp x hx ht (fun hs => hn ((h x hx).mp hs)), |
| fun x hx ht hs => hd x hx ht ((h x hx).mpr hs)⟩ |
| · exact ⟨fun x hx ht hn => hp x hx ht (fun hs => hn ((h x hx).mpr hs)), |
| fun x hx ht hs => hd x hx ht ((h x hx).mp hs)⟩ |
| |
| theorem left_separates {r : J → J → Prop} {time : J → ℕ} {W S : Set J} : |
| (Boundary.left : Boundary J).Separates r time W S 0 := by |
| exact ⟨fun _ _ h _ => (Nat.not_lt_zero _ h).elim, fun _ _ _ _ => trivial⟩ |
|
|
| theorem right_separates {r : J → J → Prop} {time : J → ℕ} {T : ℕ} |
| {W S : Set J} (hbound : ∀ x ∈ W, time x ≤ T) : |
| (Boundary.right : Boundary J).Separates r time W S (T + 1) := by |
| refine ⟨fun _ _ _ _ => trivial, ?_⟩ |
| intro x hx h _ |
| have := hbound x hx |
| omega |
|
|
| theorem actual_separates {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} |
| {Z : Triple J} {W : Finset J} {S : Set J} |
| (hZ : (Boundary.actual Z).At time T s) : |
| (Boundary.actual Z).Separates r time W S s ↔ Separator W r time S s := by |
| unfold Separates Separator EarlierHigh LaterLow |
| rw [actual_pred_eq hZ, actual_desc_eq hZ] |
| rfl |
|
|
| end Boundary |
|
|
| def PastInvariant (r : J → J → Prop) (time : J → ℕ) |
| (K : GlobalList J) (A : Boundary J) (a : ℕ) : Prop := |
| ∀ x ∈ K.Qual, time x ≤ a → x ∈ A.weakPred r |
|
|
| theorem past_prune {r : J → J → Prop} {time : J → ℕ} |
| {K : GlobalList J} {A : Boundary J} {a : ℕ} {W : Set J} |
| (h : PastInvariant r time K A a) : PastInvariant r time (K.prune W) A a := by |
| intro x hx ht |
| exact h x (K.prune_qual_subset W hx) ht |
|
|
| theorem global_high_identity {r : J → J → Prop} {time : J → ℕ} {T a b : ℕ} |
| {A B : Boundary J} {K : GlobalList J} {S : Set J} |
| (hrespect : ∀ u v, r u v → time u < time v) |
| (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) |
| (hA : A.At time T a) (hB : B.At time T b) |
| (hlabels : ∀ x ∈ Window time a b, x ∈ K.Qual ↔ x ∉ S) |
| (hhigh : ∀ x ∈ Window time a b, x ∉ S → x ∈ B.pred r) |
| (hpast : PastInvariant r time K A a) : |
| Window time a b \ S = K.Qual ∩ B.pred r ∩ (A.weakPred r)ᶜ := by |
| ext x |
| constructor |
| · rintro ⟨hx, hS⟩ |
| refine ⟨⟨(hlabels x hx).mpr hS, hhigh x hx hS⟩, ?_⟩ |
| intro hbad |
| have ht := A.weakPred_time hrespect hbound hA hbad |
| exact (not_le_of_gt hx.1) ht |
| · rintro ⟨⟨hq, hP⟩, hnP⟩ |
| have hxb := B.pred_time hrespect hbound hB hP |
| have hax : a < time x := by |
| by_contra h |
| exact hnP (hpast x hq (by omega)) |
| exact ⟨⟨hax, hxb⟩, (hlabels x ⟨hax, hxb⟩).mp hq⟩ |
|
|
| theorem global_low_identity {r : J → J → Prop} {time : J → ℕ} |
| {T a b ap bp v : ℕ} {A' B B' V : Boundary J} {S Sstar H : Set J} |
| (hrespect : ∀ u z, r u z → time u < time z) |
| (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) |
| (hA' : A'.At time T ap) (hB : B.At time T b) |
| (hB' : B'.At time T bp) (hV : V.At time T v) |
| (ha : a ≤ ap) (_hap : ap < bp) (hbp : bp ≤ v) (hvb : v < b) |
| (hagree : ∀ x ∈ Window time a b, x ∈ H ↔ x ∈ S) |
| (hsub : ∀ x ∈ Window time a b, x ∈ S → x ∈ Sstar) |
| (hcenter : V.Separates r time (Window time a b) Sstar v) |
| (hend : B'.Separates r time (Window time a v) S bp) |
| (hlow : ∀ x ∈ Window time ap bp, x ∈ S → x ∈ A'.desc r ∩ B.pred r) : |
| Window time ap bp ∩ S = |
| A'.desc r ∩ B.pred r ∩ (B'.weakDesc r)ᶜ ∩ (V.weakDesc r)ᶜ ∩ H := by |
| ext x |
| constructor |
| · rintro ⟨hx, hS⟩ |
| have hxW : x ∈ Window time a b := ⟨by have := hx.1; omega, by have := hx.2; omega⟩ |
| refine ⟨⟨⟨hlow x hx hS, ?_⟩, ?_⟩, (hagree x hxW).mpr hS⟩ |
| · intro hbad |
| have := B'.weakDesc_time hrespect hbound hB' hbad |
| have := hx.2 |
| omega |
| · intro hbad |
| have := V.weakDesc_time hrespect hbound hV hbad |
| have := hx.2 |
| omega |
| · rintro ⟨⟨⟨⟨hD, hP⟩, hnB⟩, hnV⟩, hH⟩ |
| have hapx := A'.desc_time hrespect hbound hA' hD |
| have hxb := B.pred_time hrespect hbound hB hP |
| have hxW : x ∈ Window time a b := ⟨by omega, hxb⟩ |
| have hS := (hagree x hxW).mp hH |
| have hxv : time x < v := by |
| by_contra h |
| have hle : v ≤ time x := by omega |
| rcases hle.eq_or_lt with he | hl |
| · exact hnV (Boundary.mem_weak_at_time hbound hV he.symm).2 |
| · exact hnV (V.desc_subset_weakDesc r (hcenter.2 x hxW hl (hsub x hxW hS))) |
| have hxbp : time x < bp := by |
| by_contra h |
| have hle : bp ≤ time x := by omega |
| rcases hle.eq_or_lt with he | hl |
| · exact hnB (Boundary.mem_weak_at_time hbound hB' he.symm).2 |
| · have hxE : x ∈ Window time a v := ⟨by omega, hxv⟩ |
| exact hnB (B'.desc_subset_weakDesc r (hend.2 x hxE hl hS)) |
| exact ⟨⟨hapx, hxbp⟩, hS⟩ |
|
|
| end ThreeMachine.Structure |
|
|
| namespace ThreeMachine.Structure |
| variable {J : Type} |
|
|
| def SwitchSet (r : J → J → Prop) (A₀ A V : Boundary J) (Hext : Set J) : Set J := |
| A₀.desc r ∩ (A.weakPred r)ᶜ ∩ (V.weakPred r)ᶜ ∩ Hext |
|
|
| theorem switchSet_upset {r : J → J → Prop} |
| (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z) |
| (A₀ A V : Boundary J) {Hext : Set J} (hH : GlobalUpset r Hext) : |
| GlobalUpset r (SwitchSet r A₀ A V Hext) := by |
| exact (((A₀.desc_upset htrans).inter (A.weakPred_downset htrans).compl).inter |
| (V.weakPred_downset htrans).compl).inter hH |
|
|
| theorem switchSet_properties {r : J → J → Prop} {time : J → ℕ} |
| {T a₀ b₀ v₀ a b : ℕ} {A₀ A V : Boundary J} {H Hstar Hext : Set J} |
| (hrespect : ∀ x y, r x y → time x < time y) |
| (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) |
| (hA₀ : A₀.At time T a₀) (hA : A.At time T a) (hV : V.At time T v₀) |
| (ha₀v : a₀ < v₀) (hva : v₀ ≤ a) (hab : a < b) (hbb₀ : b ≤ b₀) |
| (hagree : ∀ x ∈ Window time a₀ b₀, x ∈ Hext ↔ x ∈ H) |
| (hsub : ∀ x ∈ Window time a₀ b₀, x ∈ H → x ∈ Hstar) |
| (hdesc : ∀ x ∈ Window time a₀ b₀, x ∈ H → x ∈ A₀.desc r) |
| (holdHigh : ∀ x ∈ Window time a b, x ∉ H → x ∈ A.desc r) |
| (hcenter : V.Separates r time (Window time a₀ b₀) Hstarᶜ v₀) |
| (hend : A.Separates r time (Window time v₀ b₀) Hᶜ a) : |
| (Window time a b \ A.desc r ⊆ SwitchSet r A₀ A V Hext) ∧ |
| (∀ x ∈ SwitchSet r A₀ A V Hext, a < time x) := by |
| constructor |
| · rintro x ⟨hxW, hnD⟩ |
| have hxU : x ∈ Window time a₀ b₀ := |
| ⟨by have := hxW.1; omega, by have := hxW.2; omega⟩ |
| have hxH : x ∈ H := by |
| by_contra hnH |
| exact hnD (holdHigh x hxW hnH) |
| refine ⟨⟨⟨hdesc x hxU hxH, ?_⟩, ?_⟩, (hagree x hxU).mpr hxH⟩ |
| · intro hP |
| have := A.weakPred_time hrespect hbound hA hP |
| have := hxW.1 |
| omega |
| · intro hP |
| have := V.weakPred_time hrespect hbound hV hP |
| have := hxW.1 |
| omega |
| · rintro x ⟨⟨⟨hD, hnA⟩, hnV⟩, hHext⟩ |
| by_contra h |
| have hxa : time x ≤ a := by omega |
| have ha₀x := A₀.desc_time hrespect hbound hA₀ hD |
| have hxU : x ∈ Window time a₀ b₀ := ⟨ha₀x, by omega⟩ |
| have hxH := (hagree x hxU).mp hHext |
| by_cases hxv : time x ≤ v₀ |
| · rcases hxv.eq_or_lt with he | hl |
| · exact hnV (Boundary.mem_weak_at_time hbound hV he).1 |
| · have hnHS : x ∉ Hstarᶜ := fun hn => hn (hsub x hxU hxH) |
| exact hnV (V.pred_subset_weakPred r (hcenter.1 x hxU hl hnHS)) |
| · have hvx : v₀ < time x := by omega |
| rcases hxa.eq_or_lt with he | hl |
| · exact hnA (Boundary.mem_weak_at_time hbound hA he).1 |
| · have hxSide : x ∈ Window time v₀ b₀ := ⟨hvx, hxU.2⟩ |
| exact hnA (A.pred_subset_weakPred r (hend.1 x hxSide hl (fun hn => hn hxH))) |
|
|
| theorem flatten_pair {Q₀ U D G B : Set J} {rank : J → ℕ} {k : ℕ} |
| (hU : U ⊆ Q₀) (hG : Q₀ \ D ⊆ G) |
| (hB : ∀ x ∈ U, x ∈ B ↔ x ∈ D) : |
| ∀ x ∈ U, x ∈ (G ∩ {z | k ≤ rank z}) ∪ B ↔ x ∈ D ∪ {z | k ≤ rank z} := by |
| intro x hxU |
| constructor |
| · rintro (⟨_, hk⟩ | hxB) |
| · exact Or.inr hk |
| · exact Or.inl ((hB x hxU).mp hxB) |
| · rintro (hxD | hk) |
| · exact Or.inr ((hB x hxU).mpr hxD) |
| · by_cases hxD : x ∈ D |
| · exact Or.inr ((hB x hxU).mpr hxD) |
| · exact Or.inl ⟨hG ⟨hU hxU, hxD⟩, hk⟩ |
|
|
| end ThreeMachine.Structure |
|
|
| end |
|
|
| end OAI |
|
|
