math / data /lean /OAI /Combinatorics /PlanarL1 /Probability.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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