| import OAI.Probability.MatroidProphet.RankAccounting |
| import Mathlib.Data.Finset.Max |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| open Set Finset |
| variable {α : Type*} [DecidableEq α] |
|
|
| noncomputable def layerPrior (E : Finset α) (layer : α → ℤ) (time : α → ℕ) |
| (b : ℤ) (k : ℕ) : Set α := {e | e ∈ E ∧ layer e = b ∧ time e < k} |
|
|
| noncomputable def layerGreedy (M : Matroid α) (E : Finset α) |
| (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ) : Finset α := by |
| classical |
| exact E.filter fun e => e ∉ M.closure (base (layer e) ∪ layerPrior E layer time (layer e) (time e)) |
|
|
| omit [DecidableEq α] in |
| lemma layerGreedy_subset (M : Matroid α) (E : Finset α) |
| (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ) : |
| layerGreedy M E base layer time ⊆ E := by |
| classical |
| exact filter_subset _ _ |
|
|
| omit [DecidableEq α] in |
| lemma layerPrior_mono (E : Finset α) (layer : α → ℤ) (time : α → ℕ) |
| (b : ℤ) {k k' : ℕ} (h : k ≤ k') : |
| layerPrior E layer time b k ⊆ layerPrior E layer time b k' := by |
| rintro e ⟨he, hb, ht⟩ |
| exact ⟨he, hb, lt_of_lt_of_le ht h⟩ |
|
|
| lemma layerGreedy_spans_prefix (M : Matroid α) (E : Finset α) |
| (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ) |
| (hE : M.E = Set.univ) (e : α) (he : e ∈ E) : |
| e ∈ M.closure (base (layer e) ∪ |
| {f | f ∈ layerGreedy M E base layer time ∧ layer f = layer e ∧ time f ≤ time e}) := by |
| have aux : ∀ k, ∀ e ∈ E, time e = k → |
| e ∈ M.closure (base (layer e) ∪ |
| {f | f ∈ layerGreedy M E base layer time ∧ layer f = layer e ∧ time f ≤ k}) := by |
| intro k |
| induction k using Nat.strong_induction_on with |
| | h k ih => |
| intro e he htime |
| by_cases hkeep : e ∈ layerGreedy M E base layer time |
| · exact M.mem_closure_of_mem' (Or.inr ⟨hkeep, rfl, htime.le⟩) (by simp [hE]) |
| have hdep : e ∈ M.closure (base (layer e) ∪ layerPrior E layer time (layer e) (time e)) := by |
| simpa only [layerGreedy, mem_filter, he, true_and, not_not] using hkeep |
| apply M.closure_subset_closure_of_subset_closure ?_ hdep |
| rintro f (hf | ⟨hf, hl, ht⟩) |
| · exact M.mem_closure_of_mem' (Or.inl hf) (by simp [hE]) |
| · have hfk : time f < k := by simpa [htime] using ht |
| have hrec := ih (time f) hfk f hf rfl |
| apply M.closure_subset_closure ?_ hrec |
| rintro g (hg | ⟨hg, hgl, hgt⟩) |
| · exact Or.inl (by simpa [hl] using hg) |
| · exact Or.inr ⟨hg, hgl.trans hl, hgt.trans hfk.le⟩ |
| exact aux (time e) e he rfl |
|
|
| theorem layerGreedy_indep (M : Matroid α) (E : Finset α) |
| (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ) |
| (hE : M.E = Set.univ) (htime : Function.Injective time) |
| (hlower : ∀ e ∈ E, ∀ f ∈ E, layer e < layer f → e ∈ base (layer f)) : |
| M.Indep (layerGreedy M E base layer time : Set α) := by |
| classical |
| suffices aux : ∀ A : Finset α, A ⊆ layerGreedy M E base layer time → |
| M.Indep (A : Set α) from aux _ Finset.Subset.rfl |
| intro A |
| induction A using Finset.strongInductionOn with |
| | _ A ih => |
| intro hA |
| by_cases hne : A.Nonempty |
| · obtain ⟨p₀, hp₀, hmaxLayer⟩ := exists_max_image A layer hne |
| have htne : (A.filter (fun e => layer e = layer p₀)).Nonempty := |
| ⟨p₀, mem_filter.mpr ⟨hp₀, rfl⟩⟩ |
| obtain ⟨p, hpt, hmaxTime⟩ := exists_max_image |
| (A.filter (fun e => layer e = layer p₀)) time htne |
| have hp : p ∈ A := (mem_filter.mp hpt).1 |
| have hpl : layer p = layer p₀ := (mem_filter.mp hpt).2 |
| have hpE := layerGreedy_subset M E base layer time (hA hp) |
| have hI := ih (A.erase p) (erase_ssubset hp) |
| (fun e he => hA (mem_of_mem_erase he)) |
| have hnot : p ∉ M.closure (A.erase p : Set α) := by |
| intro hmem |
| have hpnot := (mem_filter.mp (hA hp)).2 |
| apply hpnot |
| apply M.closure_subset_closure ?_ hmem |
| intro q hq |
| have hqA := mem_of_mem_erase hq |
| have hqE := layerGreedy_subset M E base layer time (hA hqA) |
| have hqle : layer q ≤ layer p := by simpa [hpl] using hmaxLayer q hqA |
| rcases lt_or_eq_of_le hqle with hqlt | hqeq |
| · exact Or.inl (hlower q hqE p hpE hqlt) |
| · refine Or.inr ⟨hqE, hqeq, ?_⟩ |
| have hqt : q ∈ A.filter (fun e => layer e = layer p₀) := |
| mem_filter.mpr ⟨hqA, hqeq.trans hpl⟩ |
| exact lt_of_le_of_ne (hmaxTime q hqt) (fun h => (ne_of_mem_erase hq) (htime h)) |
| have hins := hI.insert_indep_iff.mpr (Or.inl ⟨by simp [hE], hnot⟩) |
| simpa only [← Finset.coe_insert, insert_erase hp] using hins |
| · have hzero := Finset.not_nonempty_iff_eq_empty.mp hne |
| simp [hzero] |
|
|
| lemma layerGreedy_spans (M : Matroid α) (E : Finset α) |
| (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ) |
| (hE : M.E = Set.univ) (b : ℤ) : |
| {e | e ∈ E ∧ layer e = b} ⊆ |
| M.closure (base b ∪ {e | e ∈ layerGreedy M E base layer time ∧ layer e = b}) := by |
| rintro e ⟨he, hb⟩ |
| have h := layerGreedy_spans_prefix M E base layer time hE e he |
| apply M.closure_subset_closure ?_ h |
| rintro f (hf | ⟨hf, hfb, _⟩) |
| · exact Or.inl (by simpa [hb] using hf) |
| · exact Or.inr ⟨hf, hfb.trans hb⟩ |
|
|
| end MatroidProphet |
|
|
| end OAI |
|
|
