| import OAI.Combinatorics.ListHadwiger.FractionalSampling |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger.Sampling |
| open scoped BigOperators |
| variable {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V] |
| [DecidableEq ι] [DecidableEq V] |
|
|
| noncomputable def remainder (E : ι → Finset V) (I : Ω → Finset V) |
| (x : ι → Ω) : Finset V := |
| Finset.univ \ Finset.univ.biUnion (fun j => I (x j) ∩ E j) |
|
|
| lemma mem_remainder {ι Ω V : Type} [Fintype ι] [Fintype Ω] [Fintype V] [DecidableEq ι] [DecidableEq V] (E : ι → Finset V) (I : Ω → Finset V) (x : ι → Ω) (v : V) : |
| v ∈ remainder E I x ↔ ∀ j, v ∈ E j → v ∉ I (x j) := by |
| classical |
| simp only [remainder,Finset.mem_sdiff,Finset.mem_univ,true_and, |
| Finset.mem_biUnion,Finset.mem_inter] |
| push Not |
| constructor |
| · intro h j he hi |
| exact h j hi he |
| · intro h j hi he |
| exact h j he hi |
|
|
| lemma probability_not {μ : Ω → ℝ} (hs : ∑ ω, μ ω = 1) (A : Ω → Prop) : |
| probability μ (fun ω => ¬ A ω) = 1 - probability μ A := by |
| classical |
| have he : probability μ (fun ω => ¬ A ω) + probability μ A = ∑ ω, μ ω := by |
| unfold probability |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| by_cases h : A ω <;> simp [h] |
| linarith |
|
|
| lemma remainder_survival_eq {μ : ι → Ω → ℝ} (hs : ∀ j, ∑ ω, μ j ω = 1) |
| (E : ι → Finset V) (I : Ω → Finset V) (v : V) : |
| probability (productMass μ) (fun x => v ∈ remainder E I x) = |
| ∏ j, if v ∈ E j then 1 - probability (μ j) (fun ω => v ∈ I ω) else 1 := by |
| classical |
| let f : ι → Ω → ℝ := fun j ω => if v ∈ E j ∧ v ∈ I ω then 0 else 1 |
| have hprod (x : ι → Ω) : |
| (if v ∈ remainder E I x then (1 : ℝ) else 0) = ∏ j, f j (x j) := by |
| by_cases hv : v ∈ remainder E I x |
| · rw [ite_eq_left hv] |
| symm |
| apply Finset.prod_eq_one |
| intro j _ |
| simp only [f] |
| exact ite_eq_right (fun hh => (mem_remainder E I x v).mp hv j hh.1 hh.2) |
| · rw [ite_eq_right hv] |
| have hnot : ¬ ∀ j, v ∈ E j → v ∉ I (x j) := mt (mem_remainder E I x v).mpr hv |
| push Not at hnot |
| obtain ⟨j,hE,hI⟩ := hnot |
| symm |
| apply Finset.prod_eq_zero (Finset.mem_univ j) |
| simp [f,hE,hI] |
| rw [probability_eq_expectation] |
| simp_rw [hprod] |
| rw [expectation_product] |
| apply Finset.prod_congr rfl |
| intro j _ |
| by_cases he : v ∈ E j |
| · simp only [ite_eq_left he] |
| have hf : f j = fun ω => if v ∉ I ω then 1 else 0 := by |
| funext ω |
| by_cases hi : v ∈ I ω <;> simp [f,he,hi] |
| rw [hf,← probability_eq_expectation,probability_not (hs j)] |
| · simp only [ite_eq_right he] |
| have hf : f j = fun _ => 1 := by funext ω; simp [f,he] |
| rw [hf,expectation_const (hs j)] |
|
|
| lemma remainder_survival_power {μ : ι → Ω → ℝ} (hs : ∀ j, ∑ ω, μ j ω = 1) |
| (E : ι → Finset V) (I : Ω → Finset V) {p : ℝ} |
| (hmarg : ∀ j v, probability (μ j) (fun ω => v ∈ I ω) = p) (v : V) : |
| probability (productMass μ) (fun x => v ∈ remainder E I x) = |
| (1 - p) ^ (Finset.univ.filter (fun j => v ∈ E j)).card := by |
| classical |
| rw [remainder_survival_eq hs E I v] |
| simp_rw [hmarg] |
| rw [← Finset.prod_filter] |
| simp |
|
|
| theorem remainder_survival_bound {μ : ι → Ω → ℝ} (hs : ∀ j, ∑ ω, μ j ω = 1) |
| (E : ι → Finset V) (I : Ω → Finset V) {r : ℝ} (hr : 1 ≤ r) |
| (hmarg : ∀ j v, probability (μ j) (fun ω => v ∈ I ω) = 1 / (2*r)) |
| (hE : ∀ v, (Fintype.card ι : ℝ)/2 ≤ (Finset.univ.filter (fun j => v ∈ E j)).card) |
| (v : V) : |
| probability (productMass μ) (fun x => v ∈ remainder E I x) ≤ |
| Real.exp (-(Fintype.card ι : ℝ)/(4*r)) := by |
| classical |
| rw [remainder_survival_power hs E I hmarg v] |
| have hp : 0 ≤ 1 - 1/(2*r) := by |
| have hh : 1/(2*r) ≤ 1 := (div_le_one (by linarith)).mpr (by linarith) |
| linarith |
| have hex : 1 - 1/(2*r) ≤ Real.exp (-(1/(2*r))) := by |
| have h := Real.add_one_le_exp (-(1/(2*r))) |
| linarith |
| calc |
| _ ≤ (Real.exp (-(1/(2*r)))) ^ (Finset.univ.filter (fun j => v ∈ E j)).card := |
| pow_le_pow_left₀ hp hex _ |
| _ = Real.exp (-((Finset.univ.filter (fun j => v ∈ E j)).card : ℝ)/(2*r)) := by |
| rw [← Real.exp_nat_mul] |
| congr 1 |
| ring |
| _ ≤ _ := by |
| apply Real.exp_le_exp.mpr |
| have hh := hE v |
| have hpos : 0 < 2*r := by linarith |
| apply (div_le_div_iff₀ hpos (by linarith : 0 < 4*r)).mpr |
| nlinarith |
|
|
| lemma remainder_sdiff_subset (E : ι → Finset V) (I : Ω → Finset V) |
| {i : ι} {x y : ι → Ω} (hxy : ∀ j, j ≠ i → x j = y j) : |
| remainder E I x \ remainder E I y ⊆ I (y i) := by |
| classical |
| intro v hv |
| obtain ⟨hx,hy⟩ := Finset.mem_sdiff.mp hv |
| by_contra hn |
| apply hy |
| apply (mem_remainder E I y v).mpr |
| intro j he |
| by_cases hj : j = i |
| · simpa [hj] using hn |
| · rw [← hxy j hj] |
| exact (mem_remainder E I x v).mp hx j he |
|
|
| lemma inter_sdiff_subset_left {V : Type} [Fintype V] [DecidableEq V] (A S T : Finset V) : |
| (A ∩ S) \ (A ∩ T) ⊆ S \ T := by |
| intro v hv |
| simp only [Finset.mem_sdiff,Finset.mem_inter] at hv ⊢ |
| tauto |
|
|
| lemma inter_remainder_difference_bound (E : ι → Finset V) (I : Ω → Finset V) |
| {M : ℕ} (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) |
| {i : ι} {x y : ι → Ω} (hxy : ∀ j, j ≠ i → x j = y j) : |
| (((A ∩ remainder E I x) \ (A ∩ remainder E I y)).card : ℝ) + |
| ((A ∩ remainder E I y) \ (A ∩ remainder E I x)).card ≤ 2 * (M : ℝ) := by |
| have h₁ := (Finset.card_le_card ((inter_sdiff_subset_left A _ _).trans |
| (remainder_sdiff_subset E I hxy))).trans (hI (y i)) |
| have h₂ := (Finset.card_le_card ((inter_sdiff_subset_left A _ _).trans |
| (remainder_sdiff_subset E I (fun j hj => (hxy j hj).symm)))).trans (hI (x i)) |
| exact_mod_cast (by omega : ((A ∩ remainder E I x) \ (A ∩ remainder E I y)).card + |
| ((A ∩ remainder E I y) \ (A ∩ remainder E I x)).card ≤ 2*M) |
|
|
| lemma card_abs_sub_le_differences {V : Type} [Fintype V] [DecidableEq V] (S T : Finset V) : |
| |(S.card : ℝ)-T.card| ≤ (S \ T).card + (T \ S).card := by |
| have hS := Finset.card_sdiff_add_card_inter S T |
| have hT := Finset.card_sdiff_add_card_inter T S |
| rw [Finset.inter_comm T S] at hT |
| have hSr : ((S \ T).card : ℝ) + (S ∩ T).card = S.card := by exact_mod_cast hS |
| have hTr : ((T \ S).card : ℝ) + (S ∩ T).card = T.card := by exact_mod_cast hT |
| rw [abs_le] |
| constructor <;> linarith [Nat.cast_nonneg (α := ℝ) (S \ T).card, |
| Nat.cast_nonneg (α := ℝ) (T \ S).card] |
|
|
| lemma remainder_card_bounded_changes {N : ℕ} (E : Fin N → Finset V) (I : Ω → Finset V) |
| {M : ℕ} (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) : |
| FiniteConcentration.BoundedChanges (fun x => ((A ∩ remainder E I x).card : ℝ)) (2*M) := by |
| intro i x y hxy |
| exact (card_abs_sub_le_differences _ _).trans (inter_remainder_difference_bound E I hI A hxy) |
|
|
| lemma remainder_fractional_bounded_changes {N : ℕ} (G : SimpleGraph V) |
| (E : Fin N → Finset V) (I : Ω → Finset V) |
| {M : ℕ} (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) : |
| FiniteConcentration.BoundedChanges |
| (fun x => Fractional.number (G.induce (↑(A ∩ remainder E I x) : Set V))) (2*M) := by |
| intro i x y hxy |
| exact (Fractional.induced_number_abs_sub_le G _ _).trans |
| (inter_remainder_difference_bound E I hI A hxy) |
|
|
| theorem remainder_fractional_concentration {N M : ℕ} (hN : 1 ≤ N) (hM : 1 ≤ M) |
| (G : SimpleGraph V) (μ : Fin N → Ω → ℝ) (hμ : ∀ j ω, 0 ≤ μ j ω) |
| (hs : ∀ j, ∑ ω, μ j ω = 1) (E : Fin N → Finset V) (I : Ω → Finset V) |
| (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) {u : ℝ} (hu : 0 < u) : |
| probability (productMass μ) |
| (fun x => u ≤ |Fractional.number (G.induce (↑(A ∩ remainder E I x) : Set V)) - |
| expectation (productMass μ) (fun y => Fractional.number |
| (G.induce (↑(A ∩ remainder E I y) : Set V)))|) ≤ |
| 2 * Real.exp (-u^2/(2*N*(2*(M : ℝ))^2)) := by |
| have hb : 0 < 2*(M : ℝ) := by exact_mod_cast (by omega : 0 < 2*M) |
| exact FiniteConcentration.bounded_differences hN μ hμ hs _ hb hu |
| (remainder_fractional_bounded_changes G E I hI A) |
|
|
| end LinearListHadwiger.Sampling |
|
|
| namespace LinearListHadwiger.Sampling |
| open scoped BigOperators |
| variable {ι Ω : Type} [Fintype ι] [Fintype Ω] [DecidableEq ι] |
|
|
| theorem bounded_differences_general (hn : 1 ≤ Fintype.card ι) |
| (μ : ι → Ω → ℝ) (hμ : ∀ i ω, 0 ≤ μ i ω) (hs : ∀ i, ∑ ω, μ i ω = 1) |
| (f : (ι → Ω) → ℝ) {b u : ℝ} (hb : 0 < b) (hu : 0 < u) |
| (hf : ∀ i x y, (∀ j, j ≠ i → x j = y j) → |f x-f y| ≤ b) : |
| probability (productMass μ) (fun x => u ≤ |f x-expectation (productMass μ) f|) ≤ |
| 2 * Real.exp (-u^2/(2*Fintype.card ι*b^2)) := by |
| classical |
| let e : Fin (Fintype.card ι) ≃ ι := (Fintype.equivFin ι).symm |
| let E : (Fin (Fintype.card ι) → Ω) ≃ (ι → Ω) := Equiv.arrowCongr e (Equiv.refl Ω) |
| let μ' : Fin (Fintype.card ι) → Ω → ℝ := fun i => μ (e i) |
| have hm (x : Fin (Fintype.card ι) → Ω) : |
| productMass μ' x = productMass μ (E x) := by |
| apply Fintype.prod_equiv e |
| intro i |
| simp [μ',E,Equiv.arrowCongr] |
| have he : expectation (productMass μ) f = |
| expectation (productMass μ') (fun x => f (E x)) := by |
| unfold expectation |
| rw [← E.sum_comp] |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [hm] |
| have hc : FiniteConcentration.BoundedChanges (fun x => f (E x)) b := by |
| intro i x y hxy |
| apply hf (e i) |
| intro j hj |
| change x (e.symm j) = y (e.symm j) |
| apply hxy |
| intro heq |
| apply hj |
| rw [← e.apply_symm_apply j,heq] |
| have hh := FiniteConcentration.bounded_differences hn μ' (fun i => hμ (e i)) |
| (fun i => hs (e i)) (fun x => f (E x)) hb hu hc |
| change probability (productMass μ') |
| (fun x => u ≤ |f (E x) - expectation (productMass μ') (fun y => f (E y))|) ≤ _ at hh |
| rw [← he] at hh |
| convert hh using 1 |
| unfold probability |
| rw [← E.sum_comp] |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [hm] |
| |
| variable {κ V : Type} [Fintype κ] [Fintype V] [DecidableEq κ] [DecidableEq V] |
| |
| noncomputable def unionRemainders (E : ι → Finset V) (I : Ω → Finset V) |
| (x : κ × ι → Ω) : Finset V := |
| Finset.univ.biUnion (fun k => remainder E I (fun i => x (k,i))) |
| |
| lemma unionRemainders_sdiff_subset (E : ι → Finset V) (I : Ω → Finset V) |
| {k : κ × ι} {x y : κ × ι → Ω} (hxy : ∀ j, j ≠ k → x j = y j) : |
| unionRemainders E I x \ unionRemainders E I y ⊆ I (y k) := by |
| classical |
| intro v hv |
| obtain ⟨hx,hy⟩ := Finset.mem_sdiff.mp hv |
| obtain ⟨c,_,hvc⟩ := Finset.mem_biUnion.mp hx |
| have hn : v ∉ remainder E I (fun i => y (c,i)) := by |
| intro h |
| exact hy (Finset.mem_biUnion.mpr ⟨c,Finset.mem_univ _,h⟩) |
| have hck : c = k.1 := by |
| by_contra hne |
| apply hn |
| have he : (fun i => y (c,i)) = (fun i => x (c,i)) := by |
| funext i |
| exact (hxy (c,i) (fun h => hne (congrArg Prod.fst h))).symm |
| rw [he] |
| exact hvc |
| subst c |
| have hdiff := remainder_sdiff_subset E I |
| (i := k.2) (x := fun i => x (k.1,i)) (y := fun i => y (k.1,i)) |
| (fun j hj => hxy (k.1,j) (fun h => hj (congrArg Prod.snd h))) |
| exact hdiff (Finset.mem_sdiff.mpr ⟨hvc,hn⟩) |
| |
| lemma unionRemainders_card_bounded_changes (E : ι → Finset V) (I : Ω → Finset V) |
| {M : ℕ} (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) |
| {k : κ × ι} {x y : κ × ι → Ω} (hxy : ∀ j, j ≠ k → x j = y j) : |
| |((A ∩ unionRemainders E I x).card : ℝ) - (A ∩ unionRemainders E I y).card| ≤ 2*M := by |
| have h₁ := (Finset.card_le_card ((inter_sdiff_subset_left A _ _).trans |
| (unionRemainders_sdiff_subset E I hxy))).trans (hI (y k)) |
| have h₂ := (Finset.card_le_card ((inter_sdiff_subset_left A _ _).trans |
| (unionRemainders_sdiff_subset E I (fun j hj => (hxy j hj).symm)))).trans (hI (x k)) |
| apply (card_abs_sub_le_differences _ _).trans |
| exact_mod_cast (by omega : ((A ∩ unionRemainders E I x) \ (A ∩ unionRemainders E I y)).card + |
| ((A ∩ unionRemainders E I y) \ (A ∩ unionRemainders E I x)).card ≤ 2*M) |
| |
| theorem unionRemainders_concentration (hn : 1 ≤ Fintype.card ι) (hq : 1 ≤ Fintype.card κ) |
| {M : ℕ} (hM : 1 ≤ M) (μ : κ × ι → Ω → ℝ) (hμ : ∀ j ω, 0 ≤ μ j ω) |
| (hs : ∀ j, ∑ ω, μ j ω = 1) (E : ι → Finset V) (I : Ω → Finset V) |
| (hI : ∀ ω, (I ω).card ≤ M) (A : Finset V) {u : ℝ} (hu : 0 < u) : |
| probability (productMass μ) |
| (fun x => u ≤ |((A ∩ unionRemainders E I x).card : ℝ) - |
| expectation (productMass μ) (fun y => ((A ∩ unionRemainders E I y).card : ℝ))|) ≤ |
| 2 * Real.exp (-u^2/(2*(Fintype.card κ * Fintype.card ι : ℕ)*(2*(M : ℝ))^2)) := by |
| have hb : 0 < 2*(M : ℝ) := by exact_mod_cast (by omega : 0 < 2*M) |
| have hqn : 1 ≤ Fintype.card (κ × ι) := by |
| rw [Fintype.card_prod] |
| have := Nat.mul_pos (by omega : 0 < Fintype.card κ) (by omega : 0 < Fintype.card ι) |
| omega |
| have hh := bounded_differences_general hqn μ hμ hs |
| (fun x => ((A ∩ unionRemainders E I x).card : ℝ)) hb hu |
| (fun k x y hxy => unionRemainders_card_bounded_changes E I hI A hxy) |
| simpa only [Fintype.card_prod] using hh |
| |
| end LinearListHadwiger.Sampling |
| |
| end OAI |
| |
