| import Mathlib |
| import OAI.Probability.CriticalPercolation.ProductMeasure.Prob |
| import OAI.Probability.CriticalPercolation.ProductMeasure.FiniteProductPin |
|
|
| namespace OAI |
|
|
| section |
| section |
| open Set MeasureTheory ProbabilityTheory |
| open Set |
| open scoped BigOperators |
| open scoped Classical |
|
|
| namespace CriticalPercolation.FiniteVariance |
|
|
| lemma sq_div_le_self {a r : ℝ} (ha : 0 ≤ a) (hr : 0 ≤ r) (hra : r ≤ a) : |
| r^2/a ≤ r := by |
| rcases eq_or_lt_of_le ha with hz | hp |
| · have : r = 0 := by linarith |
| simp [this] |
| · apply (div_le_iff₀ hp).mpr |
| nlinarith |
|
|
| lemma binary_split {a b x y : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) |
| (hx : 0 ≤ x) (hy : 0 ≤ y) (hxa : x ≤ a) (hyb : y ≤ b) : |
| x^2/a + y^2/b - (x+y)^2/(a+b) = a*b/(a+b)*(y/b-x/a)^2 := by |
| rcases eq_or_lt_of_le ha with hz | hp |
| · have hx0 : x = 0 := by linarith |
| simp [← hz, hx0] |
| · rcases eq_or_lt_of_le hb with hz | hq |
| · have hy0 : y = 0 := by linarith |
| simp [← hz, hy0] |
| · have hab : a+b ≠ 0 := (add_pos hp hq).ne' |
| field_simp |
| ring |
|
|
| end CriticalPercolation.FiniteVariance |
|
|
| namespace CriticalPercolation.FiniteProduct |
| open scoped Classical |
|
|
| variable {E : Type*} [Fintype E] |
|
|
| lemma expect_prop_mask_pin (w : E → Prop → ℝ) (e : E) (b : Prop) (f : (E → Prop) → ℝ) : |
| expect w (fun ω => if ω e = b then f ω else 0) = w e b*expect (pin w e b) f := by |
| convert expect_mask_pin w e b f using 1 |
| congr 1 |
| funext ω |
| by_cases h : ω e = b <;> simp [h] |
|
|
| lemma expect_split_pin (w : E → Prop → ℝ) (e : E) (f : (E → Prop) → ℝ) : |
| expect w f = w e False*expect (pin w e False) f + |
| w e True*expect (pin w e True) f := by |
| calc |
| expect w f = expect w (fun ω => (if ω e = False then f ω else 0) + |
| (if ω e = True then f ω else 0)) := by |
| congr 1 |
| funext ω |
| by_cases h : ω e <;> simp [h] |
| _ = _ := by |
| rw [expect_add] |
| apply congrArg₂ (· + ·) |
| · convert expect_prop_mask_pin w e False f using 1 |
| congr 1 |
| funext ω |
| by_cases h : ω e <;> simp [h] |
| · convert expect_prop_mask_pin w e True f using 1 |
| congr 1 |
| funext ω |
| by_cases h : ω e <;> simp [h] |
|
|
| lemma expect_congr_support (w : E → Prop → ℝ) (f g : Set E → ℝ) |
| (h : ∀ ω, density w ω ≠ 0 → f ω = g ω) : expect w f = expect w g := by |
| unfold expect |
| apply Finset.sum_congr rfl |
| intro ω _ |
| by_cases hd : density w ω = 0 |
| · simp [hd] |
| · rw [h ω hd] |
|
|
| lemma density_pin_support (w : E → Prop → ℝ) (e : E) (b : Prop) (ω : E → Prop) |
| (h : density (pin w e b) ω ≠ 0) : ω e = b := by |
| rw [density_pin] at h |
| by_contra he |
| simp [he] at h |
|
|
| lemma density_pin_old_support (w : E → Prop → ℝ) (e : E) (b : Prop) (ω : E → Prop) |
| (hw : w e b ≠ 0) (h : density (pin w e b) ω ≠ 0) : density w ω ≠ 0 := by |
| have hbit := density_pin_support w e b ω h |
| rw [density,← Finset.prod_erase_mul _ _ (Finset.mem_univ e),hbit] |
| rw [density_pin,ite_eq_left hbit,one_mul] at h |
| exact mul_ne_zero h hw |
|
|
| lemma expect_pin_mask (w : E → Prop → ℝ) (e : E) (b : Prop) (f : Set E → ℝ) : |
| expect (pin w e b) (fun ω => if ω e = b then f ω else 0) = |
| expect (pin w e b) f := by |
| apply expect_congr_support |
| intro ω h |
| rw [ite_eq_left (density_pin_support w e b ω h)] |
|
|
| noncomputable def potential (w : E → Prop → ℝ) (U R : Set E → Prop) : ℝ := |
| prob w R - (prob w R)^2/prob w U |
|
|
| lemma potential_le (w : E → Prop → ℝ) (hp : ∀ e b, 0 ≤ w e b) (U R : Set E → Prop) : |
| potential w U R ≤ prob w R := by |
| have hU := prob_nonneg w hp U |
| dsimp [potential] |
| exact sub_le_self _ (div_nonneg (sq_nonneg _) hU) |
|
|
| lemma potential_nonneg (w : E → Prop → ℝ) (hp : ∀ e b, 0 ≤ w e b) |
| (U R : Set E → Prop) (hRU : ∀ ω, R ω → U ω) : 0 ≤ potential w U R := by |
| dsimp [potential] |
| exact sub_nonneg.mpr (FiniteVariance.sq_div_le_self (prob_nonneg w hp U) |
| (prob_nonneg w hp R) (prob_mono w hp hRU)) |
|
|
| lemma potential_split (w : E → Prop → ℝ) (hp : ∀ e b, 0 ≤ w e b) |
| (e : E) (U R : Set E → Prop) (hRU : ∀ ω, R ω → U ω) |
| {p : ℝ} (hp0 : 0 < p) (hp1 : p < 1) (hw0 : w e False = 1-p) (hw1 : w e True = p) : |
| let U0 := prob (pin w e False) U |
| let U1 := prob (pin w e True) U |
| let R0 := prob (pin w e False) R |
| let R1 := prob (pin w e True) R |
| potential w U R - ((1-p)*potential (pin w e False) U R + |
| p*potential (pin w e True) U R) = |
| p*(1-p)*U0*U1/((1-p)*U0+p*U1)*(R1/U1-R0/U0)^2 := by |
| dsimp only |
| have hUn := fun b => prob_nonneg (pin w e b) (pin_nonneg w hp e b) U |
| have hRn := fun b => prob_nonneg (pin w e b) (pin_nonneg w hp e b) R |
| have hRU' := fun b => prob_mono (pin w e b) (pin_nonneg w hp e b) hRU |
| have hU : prob w U = (1-p)*prob (pin w e False) U+p*prob (pin w e True) U := by |
| have hh := expect_split_pin w e (fun ω => if U ω then 1 else 0) |
| simpa only [prob,hw0,hw1] using hh |
| have hR : prob w R = (1-p)*prob (pin w e False) R+p*prob (pin w e True) R := by |
| have hh := expect_split_pin w e (fun ω => if R ω then 1 else 0) |
| simpa only [prob,hw0,hw1] using hh |
| have hq : 0 < 1-p := sub_pos.mpr hp1 |
| have hb := FiniteVariance.binary_split |
| (mul_nonneg hq.le (hUn False)) (mul_nonneg hp0.le (hUn True)) |
| (mul_nonneg hq.le (hRn False)) (mul_nonneg hp0.le (hRn True)) |
| (mul_le_mul_of_nonneg_left (hRU' False) hq.le) |
| (mul_le_mul_of_nonneg_left (hRU' True) hp0.le) |
| have hscale : ∀ (c d : ℝ), (c*d)^2/c = c*d^2 := by |
| intro c d |
| by_cases hc : c = 0 |
| · simp [hc] |
| · field_simp |
| simp only [mul_div_mul_left _ _ hq.ne',mul_div_mul_left _ _ hp0.ne'] at hb |
| have hx : ∀ (c d u : ℝ), (c*d)^2/(c*u) = c*d^2/u := by |
| intro c d u |
| rw [div_mul_eq_div_div,hscale] |
| simp only [hx] at hb |
| dsimp [potential] |
| rw [hU,hR] |
| convert hb using 1 <;> ring |
|
|
| end CriticalPercolation.FiniteProduct |
|
|
| end |
| end |
|
|
| end OAI |
|
|
