| import OAI.Probability.MatroidProphet.Reverse.Hazard |
| import OAI.Probability.MatroidProphet.ExitNumerics |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| open Finset |
| variable {α : Type*} [Fintype α] [DecidableEq α] |
| attribute [local instance] Classical.propDecidable |
|
|
| theorem bandNonexitCost_budget (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₀) (hp1 : p₀ ≤ 1) (m : ℕ) (k : ℤ) (S : ℕ → Set α) |
| (closed : ReverseClosed M hE κ D 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 |
| have hlog : 0 ≤ Real.log (1 / p₀) := Real.log_nonneg ((one_le_div hp).mpr hp1) |
| induction m generalizing k S with |
| | zero => simpa only [reverseMeanCost_zero] using hlog |
| | succ m ih => |
| by_cases hl : p₀ ≤ reverseHazard M hE κ D G q d h k S |
| · exact bandNonexitCost_budget_after_entry M hE κ D G n hG q hq0 hq1 d h p₀ upper hp (m+1) k S closed hl |
| · rw [reverseMeanCost_succ M hE κ D G n hG q _ m k S closed] |
| calc |
| _ ≤ bitsExpectation q univ (fun _ => Real.log (1 / p₀)) := by |
| apply bitsExpectation_mono q hq0 hq1 |
| intro C hC |
| simp only [bandNonexitCost, hl, false_and, ↓reduceIte, zero_add] |
| exact ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C) |
| _ = _ := bitsExpectation_const q univ _ |
|
|
| noncomputable def bandExitCost (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 ∧ d ∉ S' h then 1 else 0 |
|
|
| noncomputable def bandCountCost (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (q : α → ℝ) (d : α) (h : ℕ) |
| (p₀ upper : ℝ) (k : ℤ) (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 bandCountCost_step_split (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (d : α) (h : ℕ) (p₀ upper : ℝ) (k : ℤ) (S : ℕ → Set α) |
| (closed : ReverseClosed M hE κ D k S) (C : Finset α) : |
| bandCountCost M hE κ D G q d h p₀ upper k S ((reverseStepTree M hE κ k D S G n).run C) = |
| bandNonexitCost M hE κ D G q d h p₀ upper k S ((reverseStepTree M hE κ k D S G n).run C) + |
| bandExitCost M hE κ D G q d h p₀ upper k S ((reverseStepTree M hE κ k D S G n).run C) := by |
| have hc := reverseStepTree_contracts M hE κ k D S G n closed C h |
| unfold bandCountCost bandNonexitCost bandExitCost |
| by_cases hS : d ∈ S h <;> by_cases hN : d ∈ (reverseStepTree M hE κ k D S G n).run C h |
| · simp [hS, hN] |
| · simp [hS, hN] |
| · exact (hS (hc hN)).elim |
| · simp [hS, hN] |
|
|
| lemma bandCountCost_mean_split (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (d : α) (h : ℕ) (p₀ upper : ℝ) (m : ℕ) (k : ℤ) (S : ℕ → Set α) |
| (closed : ReverseClosed M hE κ D k S) : |
| reverseMeanCost M hE κ D G n q (bandCountCost M hE κ D G q d h p₀ upper) m k S = |
| reverseMeanCost M hE κ D G n q (bandNonexitCost M hE κ D G q d h p₀ upper) m k S + |
| reverseMeanCost M hE κ D G n q (bandExitCost M hE κ D G q d h p₀ upper) m k S := by |
| have hpoint (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) (C : Finset α) : |
| reverseCost M hE κ D G n (bandCountCost M hE κ D G q d h p₀ upper) m k S C = |
| reverseCost M hE κ D G n (bandNonexitCost M hE κ D G q d h p₀ upper) m k S C + |
| reverseCost M hE κ D G n (bandExitCost M hE κ D G q d h p₀ upper) m k S C := by |
| induction m generalizing k S with |
| | zero => simp only [reverseCost, add_zero] |
| | succ m ih => |
| rw [reverseCost, reverseCost, reverseCost, bandCountCost_step_split M hE κ D G n q d h p₀ upper k S closed C, |
| ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C)] |
| ring |
| unfold reverseMeanCost |
| rw [← bitsExpectation_add] |
| exact bitsExpectation_congr q univ (fun C _ => hpoint m k S closed C) |
|
|
| lemma bandExitCost_count_le_one (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ) |
| (d : α) (h : ℕ) (p₀ upper : ℝ) (m : ℕ) (k : ℤ) (S : ℕ → Set α) |
| (closed : ReverseClosed M hE κ D k S) (C : Finset α) : |
| reverseCost M hE κ D G n (bandExitCost M hE κ D G q d h p₀ upper) m k S C ≤ |
| if d ∈ S h then 1 else 0 := by |
| induction m generalizing k S with |
| | zero => simp only [reverseCost]; split_ifs <;> norm_num |
| | succ m ih => |
| have hi := ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C) |
| have hc := reverseStepTree_contracts M hE κ k D S G n closed C h |
| rw [reverseCost] |
| by_cases hS : d ∈ S h <;> by_cases hN : d ∈ (reverseStepTree M hE κ k D S G n).run C h |
| · simpa [bandExitCost, hS, hN] using hi |
| · simp only [hN, ite_false] at hi |
| have hb : bandExitCost M hE κ D G q d h p₀ upper k S ((reverseStepTree M hE κ k D S G n).run C) ≤ 1 := by |
| unfold bandExitCost |
| split_ifs <;> norm_num |
| simpa only [hS, ite_true, add_zero] using add_le_add hb hi |
| · exact (hS (hc hN)).elim |
| · simpa [bandExitCost, hS, hN] using hi |
|
|
| lemma bandExitCost_mean_le_one (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) : |
| reverseMeanCost M hE κ D G n q (bandExitCost M hE κ D G q d h p₀ upper) m k S ≤ 1 := by |
| unfold reverseMeanCost |
| calc |
| _ ≤ bitsExpectation q univ (fun _ => 1) := by |
| apply bitsExpectation_mono q hq0 hq1 |
| intro C hC |
| apply (bandExitCost_count_le_one M hE κ D G n q d h p₀ upper m k S closed C).trans |
| split_ifs <;> norm_num |
| _ = 1 := bitsExpectation_one q univ |
|
|
| lemma bandExitCost_le_upper_count (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 : ℕ) (hh : h ≤ n) (p₀ upper : ℝ) (m : ℕ) (k : ℤ) (S : ℕ → Set α) |
| (closed : ReverseClosed M hE κ D k S) : |
| reverseMeanCost M hE κ D G n q (bandExitCost M hE κ D G q d h p₀ upper) m k S ≤ |
| upper * reverseMeanCost M hE κ D G n q (bandCountCost M hE κ D G q d h p₀ upper) m k S := by |
| rw [← reverseMeanCost_mul] |
| apply reverseMeanCost_le_of_step M hE κ D G n hG q hq0 hq1 |
| · intro l R hR |
| by_cases hb : p₀ ≤ reverseHazard M hE κ D G q d h l R ∧ |
| reverseHazard M hE κ D G q d h l R < upper ∧ d ∈ R h |
| · have heq : bitsExpectation q univ (fun C => bandExitCost M hE κ D G q d h p₀ upper l R |
| ((reverseStepTree M hE κ l D R G n).run C)) = reverseHazard M hE κ D G q d h l R := by |
| rw [reverseHazard_eq_step M hE κ D G n hG q d h hh] |
| apply bitsExpectation_congr |
| intro C hC |
| simp only [bandExitCost, hb.1, hb.2.1, hb.2.2, true_and] |
| rw [heq] |
| simpa only [bandCountCost, hb.1, hb.2.1, hb.2.2, true_and, ite_true, mul_one, bitsExpectation_const] using hb.2.1.le |
| · have hz : ∀ C, bandExitCost M hE κ D G q d h p₀ upper l R |
| ((reverseStepTree M hE κ l D R G n).run C) = 0 := by |
| intro C |
| unfold bandExitCost |
| apply ite_eq_right |
| intro hc |
| exact hb ⟨hc.1, hc.2.1, hc.2.2.1⟩ |
| simp only [hz, bandCountCost, hb, ite_false, mul_zero, bitsExpectation_const, le_refl] |
| · exact closed |
|
|
| theorem reverse_exit_band_bound (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 : ℕ) (hh : h ≤ n) (p₀ upper : ℝ) (hp : 0 < p₀) (hp1 : p₀ ≤ 1) (hu : 0 ≤ upper) |
| (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) : |
| reverseMeanCost M hE κ D G n q (bandExitCost M hE κ D G q d h p₀ upper) m k S ≤ |
| upper * (Real.log (1 / p₀) + 1) := by |
| have he := bandExitCost_le_upper_count M hE κ D G n hG q hq0 hq1 d h hh p₀ upper m k S closed |
| rw [bandCountCost_mean_split M hE κ D G n q d h p₀ upper m k S closed] at he |
| apply he.trans |
| apply mul_le_mul_of_nonneg_left _ hu |
| exact add_le_add (bandNonexitCost_budget M hE κ D G n hG q hq0 hq1 d h p₀ upper hp hp1 m k S closed) |
| (bandExitCost_mean_le_one M hE κ D G n q hq0 hq1 d h p₀ upper m k S closed) |
|
|
| end MatroidProphet |
|
|
| end OAI |
|
|
