Download data/lean/OAI/Combinatorics/PlanarL1/Probability.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/PlanarL1/Probability.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/PlanarL1/Probability.lean
-
curl -L -o Probability.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/PlanarL1/Probability.lean
13.2 kB
| import Mathlib | |
| namespace OAI | |
| section | |
| namespace PlanarL1.FiniteRandom | |
| attribute [local instance] Classical.propDecidable | |
| noncomputable def event {Ξ© : Type*} [Fintype Ξ©] (P : Ξ© β Prop) : Finset Ξ© := by | |
| classical | |
| exact Finset.univ.filter P | |
| lemma mem_event {Ξ© : Type*} [Fintype Ξ©] (P : Ξ© β Prop) (w : Ξ©) : w β event P β P w := by | |
| classical | |
| simp [event] | |
| noncomputable def prob {Ξ© : Type*} [Fintype Ξ©] (P : Ξ© β Prop) : β := by | |
| classical | |
| exact ((event P).card : β) / Fintype.card Ξ© | |
| lemma prob_nonneg {Ξ© : Type*} [Fintype Ξ©] (P : Ξ© β Prop) : 0 β€ prob P := by | |
| unfold prob | |
| positivity | |
| lemma prob_eq_sum {Ξ© : Type*} [Fintype Ξ©] (P : Ξ© β Prop) : | |
| prob P = (β w, if P w then (1 : β) else 0) / Fintype.card Ξ© := by | |
| classical | |
| simp [prob, event, Finset.sum_boole] | |
| lemma prob_mono {Ξ© : Type*} [Fintype Ξ©] {P Q : Ξ© β Prop} (h : β w, P w β Q w) : | |
| prob P β€ prob Q := by | |
| classical | |
| apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _) | |
| exact_mod_cast Finset.card_le_card (show event P β event Q from | |
| fun w hw => (mem_event Q w).mpr (h w ((mem_event P w).mp hw))) | |
| lemma prob_equiv {Ξ© Ξ : Type*} [Fintype Ξ©] [Fintype Ξ] (e : Ξ© β Ξ) (P : Ξ β Prop) : | |
| prob (fun w => P (e w)) = prob P := by | |
| classical | |
| rw [prob_eq_sum, prob_eq_sum, Fintype.card_congr e] | |
| exact congrArg (fun z : β => z / Fintype.card Ξ) | |
| (e.sum_comp (fun z : Ξ => if P z then (1 : β) else 0)) | |
| lemma prob_prod {Ξ© Ξ : Type*} [Fintype Ξ©] [Fintype Ξ] (P : Ξ© Γ Ξ β Prop) : | |
| prob P = (β w : Ξ©, prob (fun z : Ξ => P (w,z))) / Fintype.card Ξ© := by | |
| classical | |
| simp only [prob_eq_sum, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul] | |
| rw [β Finset.sum_div] | |
| ring | |
| lemma prob_prod_bound {Ξ© Ξ : Type*} [Fintype Ξ©] [Nonempty Ξ©] [Fintype Ξ] | |
| (P : Ξ© Γ Ξ β Prop) {b : β} (h : β w, prob (fun z : Ξ => P (w,z)) β€ b) : | |
| prob P β€ b := by | |
| rw [prob_prod] | |
| have hc : (0 : β) < Fintype.card Ξ© := by exact_mod_cast Fintype.card_pos | |
| apply (div_le_iffβ hc).mpr | |
| calc | |
| β w : Ξ©, prob (fun z : Ξ => P (w,z)) β€ β _w : Ξ©, b := Finset.sum_le_sum (fun w _ => h w) | |
| _ = b * Fintype.card Ξ© := by simp [mul_comm] | |
| lemma prob_union_bound {Ξ© ΞΉ : Type*} [Fintype Ξ©] (S : Finset ΞΉ) (P : ΞΉ β Ξ© β Prop) : | |
| prob (fun w => β i β S, P i w) β€ β i β S, prob (P i) := by | |
| classical | |
| unfold prob | |
| rw [β Finset.sum_div] | |
| apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _) | |
| have he : event (fun w => β i β S, P i w) = | |
| S.biUnion (fun i => event (P i)) := by | |
| ext w | |
| simp [mem_event] | |
| rw [he] | |
| exact_mod_cast (Finset.card_biUnion_le : | |
| (S.biUnion (fun i => event (P i))).card β€ | |
| β i β S, (event (P i)).card) | |
| /-- Cardinality of a grid subset is controlled by the span of its indices. -/ | |
| lemma grid_card_span (s : Finset β) {a b : β} (h : β i β s, a β€ i β§ i β€ b) : | |
| s.card β€ b + 1 - a := by | |
| have hs : s β Finset.Icc a b := fun i hi => Finset.mem_Icc.mpr (h i hi) | |
| simpa using Finset.card_le_card hs | |
| /-- An interval of radius t meets at most 2t/step+1 equally spaced points. | |
| This argument is exact and includes both endpoints of the grid. -/ | |
| lemma grid_count (m : β) {step t : β} (hstep : 0 < step) (ht : 0 β€ t) (c : β) : | |
| ((event (fun i : Fin (m + 1) => |c + step * i.val| β€ t)).card : β) * step β€ | |
| 2 * t + step := by | |
| classical | |
| let A := event (fun i : Fin (m + 1) => |c + step * i.val| β€ t) | |
| by_cases hA : A.Nonempty | |
| Β· let a := A.min' hA | |
| let b := A.max' hA | |
| have ha : a β A := A.min'_mem hA | |
| have hb : b β A := A.max'_mem hA | |
| have hab : a.val β€ b.val := A.min'_le b hb | |
| have hsub : A.image Fin.val β Finset.Icc a.val b.val := by | |
| rintro i hi | |
| obtain β¨z, hz, rflβ© := Finset.mem_image.mp hi | |
| exact Finset.mem_Icc.mpr β¨A.min'_le z hz, A.le_max' z hzβ© | |
| have hcard : A.card β€ b.val + 1 - a.val := by | |
| have hc := Finset.card_le_card hsub | |
| simpa only [Finset.card_image_of_injective _ Fin.val_injective, Nat.card_Icc] using hc | |
| have hcard' : (A.card : β) β€ (b.val : β) - a.val + 1 := by | |
| have he : b.val + 1 - a.val + a.val = b.val + 1 := Nat.sub_add_cancel (by omega) | |
| have hh : (b.val + 1 - a.val : β) + a.val β€ b.val + 1 := he.le | |
| have hi : A.card + a.val β€ b.val + 1 := by omega | |
| have hir : (A.card : β) + a.val β€ (b.val : β) + 1 := by exact_mod_cast hi | |
| linarith | |
| have ham : |c + step * a.val| β€ t := (mem_event _ a).mp ha | |
| have hbm : |c + step * b.val| β€ t := (mem_event _ b).mp hb | |
| have ha' := (abs_le.mp ham).1 | |
| have hb' := (abs_le.mp hbm).2 | |
| have hm := mul_le_mul_of_nonneg_right hcard' hstep.le | |
| change (A.card : β) * step β€ 2 * t + step | |
| nlinarith | |
| Β· have he : A = β := Finset.not_nonempty_iff_eq_empty.mp hA | |
| change (A.card : β) * step β€ 2 * t + step | |
| rw [he] | |
| simp only [Finset.card_empty, Nat.cast_zero, zero_mul] | |
| linarith | |
| /-- Uniform endpoint grid estimate in the normalization used by the paper. -/ | |
| lemma grid_probability (m : β) (hm : 0 < m) {q t : β} (hq : 0 < q) (ht : 0 β€ t) (c : β) : | |
| prob (fun i : Fin (m + 1) => |c + q / m * i.val| β€ t) β€ (2 * t + q / m) / q := by | |
| have hm' : (0 : β) < m := by exact_mod_cast hm | |
| have hs : 0 < q / m := div_pos hq hm' | |
| have hcount := grid_count m hs ht c | |
| have hc : (0 : β) < (m + 1 : β) := by positivity | |
| unfold prob | |
| rw [Fintype.card_fin] | |
| apply (div_le_iffβ hc).mpr | |
| rw [div_mul_eq_mul_div] | |
| apply (le_div_iffβ hq).mpr | |
| have hn : (0 : β) β€ (event (fun i : Fin (m + 1) => |c + q / m * i.val| β€ t)).card := | |
| Nat.cast_nonneg _ | |
| have hh := mul_le_mul_of_nonneg_right hcount hm'.le | |
| have hmul : q / (m : β) * m = q := div_mul_cancelβ q (ne_of_gt hm') | |
| rw [mul_assoc, hmul] at hh | |
| push_cast | |
| nlinarith | |
| end PlanarL1.FiniteRandom | |
| namespace PlanarL1.FiniteRandom | |
| attribute [local instance] Classical.propDecidable | |
| /-- Independent uniform grid coordinates can be exposed one at a time by an | |
| actual equivalence of finite sample spaces. -/ | |
| lemma coordinate_probability {I : Type*} [Fintype I] [DecidableEq I] | |
| (i : I) (m : β) (hm : 0 < m) {q t : β} (hq : 0 < q) (ht : 0 β€ t) | |
| (F : (I β Fin (m + 1)) β β) | |
| (hF : β Ξ± : I β Fin (m + 1), β c : β, | |
| (β r : Fin (m + 1), F (Function.update Ξ± i r) = c + q / m * r.val) β¨ | |
| (β r : Fin (m + 1), F (Function.update Ξ± i r) = c - q / m * r.val)) : | |
| prob (fun Ξ± => |F Ξ±| β€ t) β€ (2 * t + q / m) / q := by | |
| classical | |
| let e : (I β Fin (m + 1)) β ({j : I // j β i} β Fin (m + 1)) Γ Fin (m + 1) := | |
| (Equiv.funSplitAt i (Fin (m + 1))).trans (Equiv.prodComm _ _) | |
| have he := prob_equiv e.symm (fun Ξ± => |F Ξ±| β€ t) | |
| rw [β he] | |
| apply prob_prod_bound | |
| intro rest | |
| let Ξ± : I β Fin (m + 1) := e.symm (rest, 0) | |
| have hu (r : Fin (m + 1)) : e.symm (rest,r) = Function.update Ξ± i r := by | |
| funext j | |
| by_cases hj : j = i | |
| Β· subst j | |
| simp [e, Ξ±, Equiv.funSplitAt_symm_apply] | |
| Β· simp [e, Ξ±, Equiv.funSplitAt_symm_apply, hj] | |
| obtain β¨c, hcβ© := hF Ξ± | |
| rcases hc with hc | hc | |
| Β· have hp := prob_mono (fun r (hr : |F (e.symm (rest,r))| β€ t) => | |
| (show |c + q / m * r.val| β€ t by simpa only [hu r, hc r] using hr)) | |
| exact hp.trans (grid_probability m hm hq ht c) | |
| Β· have hp := prob_mono (fun r (hr : |F (e.symm (rest,r))| β€ t) => | |
| (show |-c + q / m * r.val| β€ t by | |
| rw [hu r, hc r] at hr | |
| rw [show -c + q / m * r.val = -(c - q / m * r.val) by ring, abs_neg] | |
| exact hr)) | |
| exact hp.trans (grid_probability m hm hq ht (-c)) | |
| lemma prob_false {Ξ© : Type*} [Fintype Ξ©] : prob (fun _ : Ξ© => False) = 0 := by | |
| simp [prob, event] | |
| lemma prob_pair_bound {Ξ© ΞΉ : Type*} [Fintype Ξ©] [DecidableEq ΞΉ] | |
| (S : Finset ΞΉ) (P : ΞΉ β ΞΉ β Ξ© β Prop) {b : β} (hb : 0 β€ b) | |
| (h : β i β S, β j β S, i β j β prob (P i j) β€ b) : | |
| prob (fun w => β i β S, β j β S, i β j β§ P i j w) β€ (S.card : β)^2 * b := by | |
| classical | |
| have he : (fun w => β i β S, β j β S, i β j β§ P i j w) = | |
| (fun w => β ij β S ΓΛ’ S, ij.1 β ij.2 β§ P ij.1 ij.2 w) := by | |
| funext w | |
| simp only [Finset.mem_product, Prod.exists] | |
| aesop | |
| rw [he] | |
| calc | |
| prob (fun w => β ij β S ΓΛ’ S, ij.1 β ij.2 β§ P ij.1 ij.2 w) β€ | |
| β ij β S ΓΛ’ S, prob (fun w => ij.1 β ij.2 β§ P ij.1 ij.2 w) := prob_union_bound _ _ | |
| _ β€ β _ij β S ΓΛ’ S, b := by | |
| apply Finset.sum_le_sum | |
| intro ij hij | |
| by_cases heq : ij.1 = ij.2 | |
| Β· have hz : prob (fun w => ij.1 β ij.2 β§ P ij.1 ij.2 w) = 0 := by | |
| simpa only [heq, ne_eq, not_true_eq_false, false_and] using (prob_false (Ξ© := Ξ©)) | |
| rw [hz] | |
| exact hb | |
| Β· exact (prob_mono (fun _ hw => hw.2)).trans | |
| (h ij.1 (Finset.mem_product.mp hij).1 ij.2 (Finset.mem_product.mp hij).2 heq) | |
| _ = (S.card : β)^2 * b := by simp [pow_two] | |
| end PlanarL1.FiniteRandom | |
| end | |
| section | |
| namespace PlanarL1.FiniteRandom | |
| lemma prob_prod_bound_left {Ξ© Ξ : Type*} [Fintype Ξ©] [Fintype Ξ] [Nonempty Ξ] | |
| (P : Ξ© Γ Ξ β Prop) {b : β} (h : β z, prob (fun w : Ξ© => P (w,z)) β€ b) : | |
| prob P β€ b := by | |
| rw [β prob_equiv (Equiv.prodComm Ξ Ξ©) P] | |
| exact prob_prod_bound _ h | |
| end PlanarL1.FiniteRandom | |
| end | |
| section | |
| namespace PlanarL1.FiniteRandom | |
| /-- Expose one independent finite coordinate, retaining every other coordinate. | |
| This is the conditional probability step used between distinct seed groups. -/ | |
| lemma prob_update_bound {I Ξ© : Type*} [Fintype I] [DecidableEq I] | |
| [Fintype Ξ©] [Nonempty Ξ©] (i : I) (P : (I β Ξ©) β Prop) {b : β} | |
| (h : β Ξ±, prob (fun r : Ξ© => P (Function.update Ξ± i r)) β€ b) : | |
| prob P β€ b := by | |
| classical | |
| let e : (I β Ξ©) β ({j : I // j β i} β Ξ©) Γ Ξ© := | |
| (Equiv.funSplitAt i Ξ©).trans (Equiv.prodComm _ _) | |
| rw [β prob_equiv e.symm P] | |
| apply prob_prod_bound | |
| intro rest | |
| let Ξ± : I β Ξ© := e.symm (rest, Classical.arbitrary Ξ©) | |
| have hu (r : Ξ©) : e.symm (rest,r) = Function.update Ξ± i r := by | |
| funext j | |
| by_cases hj : j=i | |
| Β· subst j; simp [e,Ξ±,Equiv.funSplitAt_symm_apply] | |
| Β· simp [e,Ξ±,Equiv.funSplitAt_symm_apply,hj] | |
| simpa only [hu] using h Ξ± | |
| end PlanarL1.FiniteRandom | |
| end | |
| section | |
| namespace PlanarL1.FiniteRandom | |
| attribute [local instance] Classical.propDecidable | |
| lemma prob_singleton {Ξ© : Type*} [Fintype Ξ©] (x : Ξ©) : | |
| prob (fun Ο => Ο=x) = 1/(Fintype.card Ξ© : β) := by | |
| classical | |
| have he : event (fun Ο : Ξ© => Ο=x)={x} := by | |
| ext Ο | |
| simp only [mem_event,Finset.mem_singleton] | |
| rw [prob,he] | |
| simp | |
| /-- Exact probability of any finite prescribed set of independent fair coins. | |
| Unprescribed coins are unrestricted, so their number does not affect the bound. -/ | |
| lemma prob_prescribed {I : Type*} [Fintype I] (S : Finset I) (b : I β Bool) : | |
| prob (fun Ο : I β Bool => β i β S, Ο i=b i) = 1/(2:β)^S.card := by | |
| classical | |
| let e : (I β Bool) β ({i : I // i β S} β Bool) Γ ({i : I // i β S} β Bool) := | |
| (Equiv.piEquivPiSubtypeProd (fun i => i β S) (fun _ => Bool)).trans (Equiv.prodComm _ _) | |
| let f : {i : I // i β S} β Bool := fun i => b i | |
| have he (Ο : ({i : I // i β S} β Bool) Γ ({i : I // i β S} β Bool)) : | |
| (β i β S, e.symm Ο i=b i) β Ο.2=f := by | |
| constructor | |
| Β· intro h | |
| funext i | |
| simpa [e,f,Equiv.piEquivPiSubtypeProd] using h i i.property | |
| Β· intro h i hi | |
| simpa [e,f,Equiv.piEquivPiSubtypeProd,hi] using congrFun h β¨i,hiβ© | |
| rw [β prob_equiv e.symm (fun Ο : I β Bool => β i β S, Ο i=b i)] | |
| simp_rw [he] | |
| rw [prob_prod] | |
| simp_rw [prob_singleton] | |
| have hc : (Fintype.card ({i : I // i β S} β Bool) : β) β 0 := by positivity | |
| simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] | |
| rw [mul_div_cancel_leftβ _ hc] | |
| simp | |
| lemma prob_two_coins {I : Type*} [Fintype I] (i j : I) (hij : i β j) (a b : Bool) : | |
| prob (fun Ο : I β Bool => Ο i=a β§ Ο j=b) = (1:β)/4 := by | |
| classical | |
| have h := prob_prescribed ({i,j} : Finset I) (Function.update (fun _ => b) i a) | |
| have hp (Ο : I β Bool) : (β k β ({i,j} : Finset I), | |
| Ο k=Function.update (fun _ => b) i a k) β Ο i=a β§ Ο j=b := by | |
| simp [Function.update,Ne.symm hij] | |
| have hc : ({i,j} : Finset I).card=2 := by simp [hij] | |
| simpa only [hp,hc,pow_two,show (2:β)*2=4 by norm_num] using h | |
| /-- Any event forced by at most k independently prescribed group/cell coins | |
| has probability at least 2β»α΅. -/ | |
| lemma prob_at_least_prescription {I : Type*} [Fintype I] | |
| (S : Finset I) (b : I β Bool) (P : (I β Bool) β Prop) {k : β} | |
| (hk : S.card β€ k) (h : β Ο, (β i β S, Ο i=b i) β P Ο) : | |
| 1/(2:β)^k β€ prob P := by | |
| calc | |
| _ β€ 1/(2:β)^S.card := by | |
| apply one_div_le_one_div_of_le (by positivity) | |
| exact pow_le_pow_rightβ (by norm_num) hk | |
| _ = prob (fun Ο : I β Bool => β i β S, Ο i=b i) := (prob_prescribed S b).symm | |
| _ β€ prob P := prob_mono h | |
| end PlanarL1.FiniteRandom | |
| end | |
| end OAI | |