| import Mathlib.Data.Fintype.Pi |
| import Mathlib.Probability.Distributions.Uniform |
|
|
| namespace OAI |
|
|
| namespace Balanced.InjectionExposure |
|
|
| variable {I J : Type*} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] |
|
|
| noncomputable def completions (K : Finset I) (base : I ↪ J) : Finset (I ↪ J) := |
| Finset.univ.filter (fun e => ∀ j ∈ K, e j = base j) |
|
|
| def remaining (K : Finset I) (base : I ↪ J) : Finset J := |
| Finset.univ \ K.image base |
|
|
| @[simp] theorem mem_completions (K : Finset I) (base e : I ↪ J) : |
| e ∈ completions K base ↔ ∀ j ∈ K, e j = base j := by |
| simp [completions] |
|
|
| omit [Fintype I] [DecidableEq I] in |
| @[simp] theorem mem_remaining (K : Finset I) (base : I ↪ J) (a : J) : |
| a ∈ remaining K base ↔ a ∉ K.image base := by |
| simp [remaining] |
|
|
| theorem completions_nonempty (K : Finset I) (base : I ↪ J) : |
| (completions K base).Nonempty := by |
| exact ⟨base, by simp⟩ |
|
|
| theorem value_mem_remaining (K : Finset I) (base e : I ↪ J) |
| (he : e ∈ completions K base) (i : I) (hi : i ∉ K) : |
| e i ∈ remaining K base := by |
| rw [mem_remaining] |
| intro h |
| obtain ⟨j, hj, hji⟩ := Finset.mem_image.mp h |
| have hsame : e j = e i := (mem_completions K base e).mp he j hj |>.trans hji |
| exact hi (e.injective hsame ▸ hj) |
|
|
| theorem base_mem_remaining (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) : base i ∈ remaining K base := |
| value_mem_remaining K base base (by simp) i hi |
|
|
| omit [Fintype I] [DecidableEq I] in |
| theorem card_remaining (K : Finset I) (base : I ↪ J) : |
| (remaining K base).card = Fintype.card J - K.card := by |
| rw [remaining, Finset.card_sdiff, Finset.inter_univ, Finset.card_univ, |
| Finset.card_image_of_injective _ base.injective] |
|
|
| theorem swap_mem_completions (K : Finset I) (base e : I ↪ J) |
| (he : e ∈ completions K base) (a b : J) |
| (ha : a ∈ remaining K base) (hb : b ∈ remaining K base) : |
| e.trans (Equiv.swap a b).toEmbedding ∈ completions K base := by |
| rw [mem_completions] at he ⊢ |
| intro j hj |
| change Equiv.swap a b (e j) = base j |
| rw [he j hj] |
| apply Equiv.swap_apply_of_ne_of_ne |
| · intro h |
| exact (mem_remaining K base a).mp ha (Finset.mem_image.mpr ⟨j, hj, h⟩) |
| · intro h |
| exact (mem_remaining K base b).mp hb (Finset.mem_image.mpr ⟨j, hj, h⟩) |
|
|
| theorem fibre_card_eq (K : Finset I) (base : I ↪ J) (i : I) |
| (a b : J) (ha : a ∈ remaining K base) (hb : b ∈ remaining K base) : |
| ((completions K base).filter (fun e => e i = a)).card = |
| ((completions K base).filter (fun e => e i = b)).card := by |
| let swapOutput : (I ↪ J) → (I ↪ J) := |
| fun e => e.trans (Equiv.swap a b).toEmbedding |
| have hinv (e : I ↪ J) : swapOutput (swapOutput e) = e := by |
| ext j |
| exact Equiv.swap_apply_self a b (e j) |
| have hmap (e : I ↪ J) |
| (he : e ∈ (completions K base).filter (fun e => e i = a)) : |
| swapOutput e ∈ (completions K base).filter (fun e => e i = b) := by |
| obtain ⟨he, hei⟩ := Finset.mem_filter.mp he |
| refine Finset.mem_filter.mpr ⟨swap_mem_completions K base e he a b ha hb, ?_⟩ |
| change Equiv.swap a b (e i) = b |
| rw [hei, Equiv.swap_apply_left] |
| have hmap' (e : I ↪ J) |
| (he : e ∈ (completions K base).filter (fun e => e i = b)) : |
| swapOutput e ∈ (completions K base).filter (fun e => e i = a) := by |
| obtain ⟨he, hei⟩ := Finset.mem_filter.mp he |
| refine Finset.mem_filter.mpr ⟨swap_mem_completions K base e he a b ha hb, ?_⟩ |
| change Equiv.swap a b (e i) = a |
| rw [hei, Equiv.swap_apply_right] |
| exact Finset.card_bij' (fun e _ => swapOutput e) (fun e _ => swapOutput e) |
| hmap hmap' (fun e _ => hinv e) (fun e _ => hinv e) |
|
|
| theorem card_completions_eq (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (a : J) (ha : a ∈ remaining K base) : |
| (completions K base).card = (remaining K base).card * |
| ((completions K base).filter (fun e => e i = a)).card := by |
| calc |
| (completions K base).card = |
| ∑ b ∈ remaining K base, |
| ((completions K base).filter (fun e => e i = b)).card := |
| Finset.card_eq_sum_card_fiberwise (fun e he => |
| value_mem_remaining K base e he i hi) |
| _ = ∑ _b ∈ remaining K base, |
| ((completions K base).filter (fun e => e i = a)).card := by |
| apply Finset.sum_congr rfl |
| intro b hb |
| exact fibre_card_eq K base i b a hb ha |
| _ = _ := by simp |
|
|
| theorem next_value_probability (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (a : J) (ha : a ∈ remaining K base) : |
| ((PMF.uniformOfFinset (completions K base) (completions_nonempty K base)).toOuterMeasure |
| {e | e i = a}).toReal = 1 / ((remaining K base).card : ℝ) := by |
| classical |
| have hC : 0 < ((completions K base).card : ℝ) := by |
| exact_mod_cast Finset.card_pos.mpr (completions_nonempty K base) |
| have hR : 0 < ((remaining K base).card : ℝ) := by |
| exact_mod_cast Finset.card_pos.mpr (show (remaining K base).Nonempty from ⟨a, ha⟩) |
| have hfactor : ((completions K base).card : ℝ) = |
| ((remaining K base).card : ℝ) * |
| (((completions K base).filter (fun e => e i = a)).card : ℝ) := by |
| exact_mod_cast card_completions_eq K base i hi a ha |
| rw [PMF.toOuterMeasure_uniformOfFinset_apply] |
| simp only [ENNReal.toReal_div, ENNReal.toReal_natCast, Set.mem_ofPred_eq] |
| apply (div_eq_div_iff (ne_of_gt hC) (ne_of_gt hR)).mpr |
| nlinarith |
|
|
| theorem next_value_probability_card (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (a : J) (ha : a ∈ remaining K base) : |
| ((PMF.uniformOfFinset (completions K base) (completions_nonempty K base)).toOuterMeasure |
| {e | e i = a}).toReal = 1 / ((Fintype.card J - K.card : ℕ) : ℝ) := by |
| rw [next_value_probability K base i hi a ha, card_remaining] |
|
|
| theorem event_card_eq (K : Finset I) (base : I ↪ J) (i : I) (hi : i ∉ K) |
| (P : J → Prop) [DecidablePred P] : |
| ((completions K base).filter (fun e => P (e i))).card = |
| ((remaining K base).filter P).card * |
| ((completions K base).filter (fun e => e i = base i)).card := by |
| calc |
| ((completions K base).filter (fun e => P (e i))).card = |
| ∑ b ∈ (remaining K base).filter P, |
| (((completions K base).filter (fun e => P (e i))).filter |
| (fun e => e i = b)).card := by |
| apply Finset.card_eq_sum_card_fiberwise |
| intro e he |
| obtain ⟨he, hPe⟩ := Finset.mem_filter.mp he |
| exact Finset.mem_filter.mpr ⟨value_mem_remaining K base e he i hi, hPe⟩ |
| _ = ∑ _b ∈ (remaining K base).filter P, |
| ((completions K base).filter (fun e => e i = base i)).card := by |
| apply Finset.sum_congr rfl |
| intro b hb |
| obtain ⟨hb, hPb⟩ := Finset.mem_filter.mp hb |
| have hfibre : ((completions K base).filter (fun e => P (e i))).filter |
| (fun e => e i = b) = (completions K base).filter (fun e => e i = b) := by |
| ext e |
| simp only [Finset.mem_filter] |
| constructor |
| · exact fun h => ⟨h.1.1, h.2⟩ |
| · intro h |
| exact ⟨⟨h.1, h.2 ▸ hPb⟩, h.2⟩ |
| rw [hfibre] |
| exact fibre_card_eq K base i b (base i) hb (base_mem_remaining K base i hi) |
| _ = _ := by simp |
|
|
| theorem next_event_probability (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (P : J → Prop) [DecidablePred P] : |
| ((PMF.uniformOfFinset (completions K base) (completions_nonempty K base)).toOuterMeasure |
| {e | P (e i)}).toReal = |
| (((remaining K base).filter P).card : ℝ) / ((remaining K base).card : ℝ) := by |
| classical |
| have hC : 0 < ((completions K base).card : ℝ) := by |
| exact_mod_cast Finset.card_pos.mpr (completions_nonempty K base) |
| have hR : 0 < ((remaining K base).card : ℝ) := by |
| exact_mod_cast Finset.card_pos.mpr |
| (show (remaining K base).Nonempty from ⟨base i, base_mem_remaining K base i hi⟩) |
| have hfactor : ((completions K base).card : ℝ) = |
| ((remaining K base).card : ℝ) * |
| (((completions K base).filter (fun e => e i = base i)).card : ℝ) := by |
| exact_mod_cast card_completions_eq K base i hi (base i) (base_mem_remaining K base i hi) |
| have hevent : (((completions K base).filter (fun e => P (e i))).card : ℝ) = |
| (((remaining K base).filter P).card : ℝ) * |
| (((completions K base).filter (fun e => e i = base i)).card : ℝ) := by |
| exact_mod_cast event_card_eq K base i hi P |
| rw [PMF.toOuterMeasure_uniformOfFinset_apply] |
| simp only [ENNReal.toReal_div, ENNReal.toReal_natCast, Set.mem_ofPred_eq] |
| apply (div_eq_div_iff (ne_of_gt hC) (ne_of_gt hR)).mpr |
| rw [hfactor, hevent] |
| ring |
|
|
| theorem next_event_probability_le (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (P : J → Prop) [DecidablePred P] |
| (hP : ((remaining K base).filter P).card ≤ 1) : |
| ((PMF.uniformOfFinset (completions K base) (completions_nonempty K base)).toOuterMeasure |
| {e | P (e i)}).toReal ≤ 1 / ((remaining K base).card : ℝ) := by |
| rw [next_event_probability K base i hi P] |
| exact div_le_div_of_nonneg_right (by exact_mod_cast hP) (Nat.cast_nonneg _) |
|
|
| theorem next_event_probability_le_budget (K : Finset I) (base : I ↪ J) |
| (i : I) (hi : i ∉ K) (P : J → Prop) [DecidablePred P] |
| (hP : ((remaining K base).filter P).card ≤ 1) |
| (N : ℕ) (hK : K.card ≤ N) (hN : N < Fintype.card J) : |
| ((PMF.uniformOfFinset (completions K base) (completions_nonempty K base)).toOuterMeasure |
| {e | P (e i)}).toReal ≤ 1 / ((Fintype.card J - N : ℕ) : ℝ) := by |
| apply (next_event_probability_le K base i hi P hP).trans |
| rw [card_remaining] |
| apply one_div_le_one_div_of_le |
| · exact_mod_cast Nat.sub_pos_of_lt hN |
| · exact_mod_cast Nat.sub_le_sub_left hK (Fintype.card J) |
|
|
| end Balanced.InjectionExposure |
|
|
| end OAI |
|
|
