| import OAI.Probability.MatroidProphet.Reverse.Cost |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| open Finset |
| variable {α : Type*} [Fintype α] [DecidableEq α] |
| attribute [local instance] Classical.propDecidable |
|
|
| noncomputable def reverseHazard (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) (d : α) (h : ℕ) |
| (k : ℤ) (S : ℕ → Set α) : ℝ := |
| bitsFailure (reverseStayEvent M hE κ D S G k d h) q univ ∅ |
|
|
| lemma reverseHazard_eq (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) (d : α) (h : ℕ) |
| (k : ℤ) (S : ℕ → Set α) : |
| reverseHazard M hE κ D G q d h k S = bitsExpectation q univ (fun C => |
| if d ∉ reverseNominal M hE κ D (fun i => (C : Set α) ∩ (G i : Set α)) S k h then 1 else 0) := by |
| unfold reverseHazard bitsFailure reverseStayEvent |
| apply bitsExpectation_congr |
| intro C hC |
| simp only [empty_union] |
| split_ifs <;> simp_all |
|
|
| lemma reverseHazard_nonneg (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) |
| (k : ℤ) (S : ℕ → Set α) : 0 ≤ reverseHazard M hE κ D G q d h k S := |
| bitsFailure_nonneg _ q hq0 hq1 _ _ |
|
|
| lemma reverseHazard_le_one (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) |
| (k : ℤ) (S : ℕ → Set α) : reverseHazard M hE κ D G q d h k S ≤ 1 := |
| bitsFailure_le_one _ q hq0 hq1 _ _ |
|
|
| lemma reverseHazard_mono (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) |
| {k l : ℤ} (hlk : l ≤ k) (S S' : ℕ → Set α) (hS : ∀ j, S' j ⊆ S j) : |
| reverseHazard M hE κ D G q d h k S ≤ reverseHazard M hE κ D G q d h l S' := by |
| rw [reverseHazard_eq, reverseHazard_eq] |
| apply bitsExpectation_mono q hq0 hq1 |
| intro C hC |
| have hn := reverseNominal_mono M hE κ D |
| (fun i => (C : Set α) ∩ (G i : Set α)) _ S' S hlk (fun _ => Set.Subset.rfl) hS h |
| by_cases he : d ∈ reverseNominal M hE κ D (fun i => (C : Set α) ∩ (G i : Set α)) S' l h |
| · simp [he, hn he] |
| · simp [he] |
| split_ifs <;> norm_num |
|
|
| lemma reverseHazard_step_mono (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) |
| (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) (C : Finset α) : |
| reverseHazard M hE κ D G q d h k S ≤ |
| reverseHazard M hE κ D G q d h (k-1) ((reverseStepTree M hE κ k D S G n).run C) := |
| reverseHazard_mono M hE κ D G q hq0 hq1 d h (by omega) S _ |
| (reverseStepTree_contracts M hE κ k D S G n closed C) |
|
|
| lemma reverseHazard_eq_step (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) |
| (hG : Pairwise (fun i j => Disjoint (G i) (G j))) (q : α → ℝ) (d : α) (h : ℕ) (hh : h ≤ n) |
| (k : ℤ) (S : ℕ → Set α) : |
| reverseHazard M hE κ D G q d h k S = bitsExpectation q univ (fun C => |
| if d ∉ (reverseStepTree M hE κ k D S G n).run C h then 1 else 0) := by |
| rw [reverseHazard_eq] |
| apply bitsExpectation_congr |
| intro C hC |
| rw [reverseStepTree_run_coordinate M hE κ k D S G n hG C hh] |
|
|
| noncomputable def bandNonexitCost (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) (d : α) (h : ℕ) |
| (p₀ upper : ℝ) (k : ℤ) (S S' : ℕ → Set α) : ℝ := |
| if p₀ ≤ reverseHazard M hE κ D G q d h k S ∧ |
| reverseHazard M hE κ D G q d h k S < upper ∧ d ∈ S' h then 1 else 0 |
|
|
| lemma bandNonexitCost_zero_above (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) (p₀ upper : ℝ) |
| (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) |
| (hu : upper ≤ reverseHazard M hE κ D G q d h k S) (C : Finset α) : |
| reverseCost M hE κ D G n (bandNonexitCost M hE κ D G q d h p₀ upper) m k S C = 0 := by |
| induction m generalizing k S with |
| | zero => rfl |
| | succ m ih => |
| rw [reverseCost, bandNonexitCost, ite_eq_right (fun hc => (not_lt_of_ge hu) hc.2.1)] |
| have hm := reverseHazard_step_mono M hE κ D G n q hq0 hq1 d h k S closed C |
| rw [ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C) (hu.trans hm)] |
| exact zero_add 0 |
|
|
| lemma bandNonexitCost_eq_count (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) (p₀ upper : ℝ) |
| (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) |
| (hl : p₀ ≤ reverseHazard M hE κ D G q d h k S) (C : Finset α) : |
| reverseCost M hE κ D G n (bandNonexitCost M hE κ D G q d h p₀ upper) m k S C = |
| reverseNonexitCount M hE κ D G n |
| (fun k S => upper ≤ reverseHazard M hE κ D G q d h k S) d h m k S C := by |
| induction m generalizing k S with |
| | zero => rfl |
| | succ m ih => |
| by_cases hu : upper ≤ reverseHazard M hE κ D G q d h k S |
| · rw [bandNonexitCost_zero_above M hE κ D G n q hq0 hq1 d h p₀ upper (m+1) k S closed hu C, |
| reverseNonexitCount, ite_eq_left hu] |
| · have hlt := lt_of_not_ge hu |
| rw [reverseCost, reverseNonexitCount, ite_eq_right hu] |
| simp only [bandNonexitCost, hl, hlt, true_and] |
| congr 1 |
| exact ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C) |
| (hl.trans (reverseHazard_step_mono M hE κ D G n q hq0 hq1 d h k S closed C)) |
|
|
| theorem bandNonexitCost_budget_after_entry (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) |
| (hG : Pairwise (fun i j => Disjoint (G i) (G j))) (q : α → ℝ) |
| (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) (d : α) (h : ℕ) (p₀ upper : ℝ) |
| (hp : 0 < p₀) (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) |
| (hl : p₀ ≤ reverseHazard M hE κ D G q d h k S) : |
| reverseMeanCost M hE κ D G n q (bandNonexitCost M hE κ D G q d h p₀ upper) m k S ≤ |
| Real.log (1 / p₀) := by |
| unfold reverseMeanCost |
| have heq : bitsExpectation q univ |
| (reverseCost M hE κ D G n (bandNonexitCost M hE κ D G q d h p₀ upper) m k S) = |
| bitsExpectation q univ (reverseNonexitCount M hE κ D G n |
| (fun k S => upper ≤ reverseHazard M hE κ D G q d h k S) d h m k S) := by |
| apply bitsExpectation_congr |
| intro C hC |
| exact bandNonexitCost_eq_count M hE κ D G n q hq0 hq1 d h p₀ upper m k S closed hl C |
| rw [heq] |
| apply (reverse_nonexit_budget M hE κ D G n hG _ d h m k S closed q hq0 hq1 (hp.trans_le hl)).trans |
| apply Real.log_le_log |
| · exact one_div_pos.mpr (hp.trans_le hl) |
| · exact one_div_le_one_div_of_le hp hl |
|
|
| end MatroidProphet |
|
|
| end OAI |
|
|
