| import Mathlib |
| import OAI.Probability.SKRatio.Calculus.GibbsMeanCLM |
| import OAI.Probability.SKRatio.Dynamics.SumPoissonMass |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators Topology Matrix |
| open ContinuousLinearMap MeasureTheory Filter ProbabilityTheory SKRatioClock |
| namespace SKRatio.Calculus |
|
|
| lemma kernel_apply {n : ℕ} (K : Observables n →L[ℝ] Observables n) |
| (f : Observables n) (x : Spin n) : |
| (∑ y, K (fun z => if z = y then 1 else 0) x*f y) = K f x := by |
| conv_rhs => rw [observable_basis f] |
| simp only [map_sum, map_smul, Finset.sum_apply, Pi.smul_apply, smul_eq_mul] |
| exact Finset.sum_congr rfl (fun _ _ => mul_comm _ _) |
|
|
| def attemptKernel {n : ℕ} (J : Interaction n) : Matrix (Spin n) (Spin n) ℝ := |
| fun x y => attemptLM J (fun z => if z = y then 1 else 0) x |
|
|
| lemma attemptKernel_nonneg {n : ℕ} (J : Interaction n) (x y : Spin n) : |
| 0 ≤ attemptKernel J x y := by |
| classical |
| exact attempt_nonneg J _ (fun z => by split_ifs <;> norm_num) x |
|
|
| lemma attemptKernel_eq_transition {n : ℕ} (g : Disorder n) : |
| attemptKernel (coupling g) = transition g := by |
| classical |
| funext x y |
| simp [attemptKernel, attempt_eq_transition, Matrix.mulVec, dotProduct] |
|
|
| noncomputable def residualAttempt {n : ℕ} (J : Interaction n) (q : ℝ) : |
| Observables n →L[ℝ] Observables n := |
| q⁻¹ • (attemptLM J-(1-q) • 1) |
|
|
| lemma residualAttempt_apply {n : ℕ} (J : Interaction n) (q : ℝ) |
| (f : Observables n) (x : Spin n) : |
| residualAttempt J q f x = (attemptLM J f x-(1-q)*f x)/q := by |
| simp [residualAttempt,div_eq_mul_inv,mul_comm] |
|
|
| lemma attempt_eq_lazy_residual {n : ℕ} (J : Interaction n) {q : ℝ} (hq : q ≠ 0) : |
| attemptLM J = q • residualAttempt J q+(1-q) • 1 := by |
| simp only [residualAttempt,smul_smul,mul_inv_cancel₀ hq,one_smul,sub_add_cancel] |
|
|
| lemma residualAttempt_const {n : ℕ} (J : Interaction n) {q : ℝ} (hq : q ≠ 0) |
| (c : ℝ) : residualAttempt J q (fun _ => c) = fun _ => c := by |
| ext x |
| rw [residualAttempt_apply,attempt_const] |
| field_simp |
| ring |
|
|
| lemma residualAttempt_pow_const {n : ℕ} (J : Interaction n) {q : ℝ} (hq : q ≠ 0) |
| (k : ℕ) (c : ℝ) : (residualAttempt J q ^ k) (fun _ => c) = fun _ => c := by |
| induction k with |
| | zero => simp |
| | succ k ih => rw [pow_succ',mul_apply_eq_comp,ih,residualAttempt_const J hq] |
| |
| lemma residualAttempt_nonneg {n : ℕ} (J : Interaction n) {q : ℝ} (hq : 0 < q) |
| (hhold : ∀ x, 1-q ≤ attemptKernel J x x) |
| (f : Observables n) (hf : ∀ x, 0 ≤ f x) (x : Spin n) : |
| 0 ≤ residualAttempt J q f x := by |
| rw [← kernel_apply (residualAttempt J q) f x] |
| apply Finset.sum_nonneg |
| intro y _ |
| apply mul_nonneg _ (hf y) |
| rw [residualAttempt_apply] |
| apply div_nonneg _ hq.le |
| by_cases hxy : x=y |
| · subst y |
| simpa [attemptKernel] using sub_nonneg.mpr (hhold x) |
| · simpa only [hxy,↓reduceIte,mul_zero,sub_zero,attemptKernel] using |
| attemptKernel_nonneg J x y |
| |
| lemma residualAttempt_pow_nonneg {n : ℕ} (J : Interaction n) {q : ℝ} (hq : 0 < q) |
| (hhold : ∀ x, 1-q ≤ attemptKernel J x x) |
| (k : ℕ) (f : Observables n) (hf : ∀ x, 0 ≤ f x) (x : Spin n) : |
| 0 ≤ (residualAttempt J q ^ k) f x := by |
| induction k generalizing x with |
| | zero => exact hf x |
| | succ k ih => |
| rw [pow_succ',mul_apply_eq_comp] |
| exact residualAttempt_nonneg J hq hhold _ (fun x => ih x) x |
|
|
| lemma residualAttempt_pow_abs_le {n : ℕ} (J : Interaction n) {q : ℝ} (hq : 0 < q) |
| (hhold : ∀ x, 1-q ≤ attemptKernel J x x) |
| (k : ℕ) (f : Observables n) (hf : ∀ x, |f x| ≤ 1) (x : Spin n) : |
| |(residualAttempt J q ^ k) f x| ≤ 1 := by |
| have hup := residualAttempt_pow_nonneg J hq hhold k (fun y => 1-f y) |
| (fun y => by have := (abs_le.mp (hf y)).2; linarith) x |
| have hlo := residualAttempt_pow_nonneg J hq hhold k (fun y => f y+1) |
| (fun y => by have := (abs_le.mp (hf y)).1; linarith) x |
| change 0 ≤ (residualAttempt J q ^ k) ((fun _ => 1)-f) x at hup |
| change 0 ≤ (residualAttempt J q ^ k) (f+(fun _ => 1)) x at hlo |
| rw [map_sub,residualAttempt_pow_const J hq.ne'] at hup |
| rw [map_add,residualAttempt_pow_const J hq.ne'] at hlo |
| simp only [Pi.add_apply,Pi.sub_apply] at hlo hup |
| exact abs_le.mpr ⟨by linarith,by linarith⟩ |
|
|
| lemma residual_semigroup_uniformization {n : ℕ} (hn : 0 < n) |
| (J : Interaction n) {q : ℝ} (hq : q ≠ 0) (t : ℝ) : |
| semigroup J t = Real.exp (-(q*n*t)) • |
| NormedSpace.exp ((q*n*t) • residualAttempt J q) := by |
| have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne' |
| have heq : t • generatorCLM J = |
| (-(q*n*t)) • (1 : Observables n →L[ℝ] Observables n) + |
| (q*n*t) • residualAttempt J q := by |
| unfold residualAttempt attemptLM |
| simp only [smul_smul,smul_sub,smul_add] |
| have hc : q*n*t*q⁻¹ = (n:ℝ)*t := by field_simp |
| have hc' : q*n*t*(q⁻¹*(n:ℝ)⁻¹) = t := by field_simp |
| have hc'' : q*n*t*(q⁻¹*(1-q)) = (n:ℝ)*t*(1-q) := by field_simp |
| rw [hc,hc',hc''] |
| module |
| let : NormedAlgebra ℚ (Observables n →L[ℝ] Observables n) := |
| NormedAlgebra.restrictScalars ℚ ℝ _ |
| unfold semigroup |
| rw [heq,NormedSpace.exp_add_of_commute |
| (((Commute.one_left (residualAttempt J q)).smul_left _).smul_right _), |
| exp_smul_identity,smul_mul_assoc,one_mul] |
|
|
| lemma residual_poisson_hasSum {n : ℕ} (hn : 0 < n) |
| (J : Interaction n) {q : ℝ} (hq : q ≠ 0) (t : ℝ) |
| (f : Observables n) (x : Spin n) : |
| HasSum (fun j => Clock.poissonMass (q*n*t) j*(residualAttempt J q ^ j) f x) |
| (semigroup J t f x) := by |
| have hs := (Pi.hasSum.mp (exp_apply_hasSum ((q*n*t) • residualAttempt J q) f) x).mul_left |
| (Real.exp (-(q*n*t))) |
| convert! hs using 1 |
| · funext j |
| simp only [smul_pow,_root_.smul_apply,Pi.smul_apply,smul_eq_mul,Clock.poissonMass] |
| ring |
| · rw [residual_semigroup_uniformization hn J hq] |
| rfl |
|
|
| lemma natCastCLM_apply {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (k : ℕ) (f : E) : (k : E →L[ℝ] E) f = (k:ℝ) • f := by |
| induction k with |
| | zero => simp |
| | succ k ih => simp [Nat.cast_succ,ih,add_smul] |
|
|
| lemma residual_binomial_sum {n : ℕ} (J : Interaction n) {q : ℝ} (hq : q ≠ 0) |
| (M : ℕ) (f : Observables n) (x : Spin n) : |
| (∑ j ∈ Finset.range (M+1), Clock.binomialMass q M j* |
| (residualAttempt J q ^ j) f x) = (attemptLM J ^ M) f x := by |
| rw [attempt_eq_lazy_residual J hq] |
| rw [(((Commute.one_right (residualAttempt J q)).smul_left q).smul_right (1-q)).add_pow] |
| simp only [_root_.sum_apply,smul_pow,one_pow,smul_mul_assoc,mul_smul_comm,mul_one, |
| Clock.binomialMass,mul_apply_eq_comp,_root_.smul_apply,Finset.sum_apply,Pi.smul_apply,smul_eq_mul] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [natCastCLM_apply,map_smul,Pi.smul_apply,smul_eq_mul] |
| ring |
|
|
| lemma residual_binomial_hasSum {n : ℕ} (J : Interaction n) {q : ℝ} (hq : q ≠ 0) |
| (M : ℕ) (f : Observables n) (x : Spin n) : |
| HasSum (fun j => Clock.binomialMass q M j*(residualAttempt J q ^ j) f x) |
| ((attemptLM J ^ M) f x) := by |
| rw [← residual_binomial_sum J hq M f x] |
| apply hasSum_sum_of_ne_finset_zero |
| intro j hj |
| have hj' : M < j := by simp only [Finset.mem_range,not_lt] at hj; omega |
| simp [Clock.binomialMass,Nat.choose_eq_zero_of_lt hj'] |
|
|
| lemma gibbsMean_abs_le_one {n : ℕ} (g : Disorder n) (f : Observables n) |
| (hf : ∀ x, |f x| ≤ 1) : |FiniteLaw.mean (mass g 0) f| ≤ 1 := by |
| unfold FiniteLaw.mean |
| calc |
| _ ≤ ∑ x, |mass g 0 x*f x| := Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ ∑ x, mass g 0 x := by |
| apply Finset.sum_le_sum |
| intro x _ |
| rw [abs_mul,abs_of_nonneg (mass_nonneg g 0 x)] |
| exact mul_le_of_le_one_right (mass_nonneg g 0 x) (hf x) |
| _ = _ := sum_mass g 0 |
|
|
| lemma residual_test_bound {n : ℕ} (g : Disorder n) {q : ℝ} (hq : 0 < q) |
| (hhold : ∀ x, 1-q ≤ transition g x x) |
| (f : Observables n) (hf : ∀ x, |f x| ≤ 1) (x : Spin n) (j : ℕ) : |
| |(residualAttempt (coupling g) q ^ j) f x-FiniteLaw.mean (mass g 0) f| ≤ 2 := by |
| have h := abs_sub ((residualAttempt (coupling g) q ^ j) f x) |
| (FiniteLaw.mean (mass g 0) f) |
| have hhold' : ∀ x, 1-q ≤ attemptKernel (coupling g) x x := by |
| rwa [attemptKernel_eq_transition] |
| linarith [residualAttempt_pow_abs_le (coupling g) hq hhold' j f hf x, |
| gibbsMean_abs_le_one g f hf] |
|
|
| lemma residual_poisson_test {n : ℕ} (hn : 0 < n) |
| (g : Disorder n) {q : ℝ} (hq : q ≠ 0) (m : ℝ) |
| (f : Observables n) (x : Spin n) : |
| (∑' j, Clock.poissonMass m j*((residualAttempt (coupling g) q ^ j) f x- |
| FiniteLaw.mean (mass g 0) f)) = |
| semigroup (coupling g) (m/(q*n)) f x-FiniteLaw.mean (mass g 0) f := by |
| have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne' |
| have he : q*n*(m/(q*n)) = m := by field_simp |
| have hs := residual_poisson_hasSum hn (coupling g) hq (m/(q*n)) f x |
| rw [he] at hs |
| have hh := hs.sub ((Clock.hasSum_poissonMass m).mul_right (FiniteLaw.mean (mass g 0) f)) |
| simpa only [one_mul,← mul_sub] using hh.tsum_eq |
| |
| lemma residual_binomial_test {n : ℕ} (g : Disorder n) {q : ℝ} (hq : q ≠ 0) |
| (M : ℕ) (f : Observables n) (x : Spin n) : |
| (∑' j, Clock.binomialMass q M j*((residualAttempt (coupling g) q ^ j) f x- |
| FiniteLaw.mean (mass g 0) f)) = |
| ((transition g ^ M) *ᵥ f) x-FiniteLaw.mean (mass g 0) f := by |
| have hs := residual_binomial_hasSum (coupling g) hq M f x |
| have hh := hs.sub ((Clock.hasSum_binomialMass q M).mul_right (FiniteLaw.mean (mass g 0) f)) |
| simpa only [one_mul,← mul_sub, attempt_pow_eq_transition_pow] using hh.tsum_eq |
|
|
| lemma totalVariation_test_bound {n : ℕ} (p r f : Spin n → ℝ) |
| (hf : ∀ y, |f y| ≤ 1) : |
| |FiniteLaw.mean p f-FiniteLaw.mean r f| ≤ 2*totalVariation p r := by |
| unfold FiniteLaw.mean |
| rw [← Finset.sum_sub_distrib] |
| simp_rw [← sub_mul] |
| calc |
| _ ≤ ∑ y, |(p y-r y)*f y| := Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ ∑ y, |p y-r y| := by |
| apply Finset.sum_le_sum |
| intro y _ |
| rw [abs_mul] |
| exact mul_le_of_le_one_right (abs_nonneg _) (hf y) |
| _ = _ := by dsimp [totalVariation]; ring |
|
|
| lemma continuous_test_bound {n : ℕ} (g : Disorder n) (t : ℝ) |
| (f : Observables n) (hf : ∀ y, |f y| ≤ 1) (x : Spin n) : |
| |semigroup (coupling g) t f x-FiniteLaw.mean (mass g 0) f| ≤ |
| 2*continuousDistance g t := by |
| rw [semigroup_eq_kernel] |
| apply (totalVariation_test_bound (continuousKernel (coupling g) t x) (mass g 0) f hf).trans |
| exact mul_le_mul_of_nonneg_left (tv_le_continuousDistance g t x) (by norm_num) |
|
|
| lemma field_square_sum_le {n : ℕ} (J : Interaction n) (x : Spin n) |
| {K : ℝ} (_hK : 0 ≤ K) |
| (hJ : ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) J‖ ≤ K) : |
| ∑ i, field J x i^2 ≤ K^2*(n:ℝ) := by |
| let A := Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) J |
| let v : EuclideanSpace ℝ (Fin n) := (WithLp.equiv 2 _).symm (spin x) |
| have hv : ‖v‖^2 = (n:ℝ) := by |
| rw [EuclideanSpace.real_norm_sq_eq] |
| simp [v, spin_sq] |
| have hh : ‖A v‖ ≤ K*‖v‖ := (A.le_opNorm v).trans |
| (mul_le_mul_of_nonneg_right hJ (norm_nonneg _)) |
| have hs := pow_le_pow_left₀ (norm_nonneg _) hh 2 |
| rw [mul_pow, hv, EuclideanSpace.real_norm_sq_eq] at hs |
| exact hs |
|
|
| lemma one_sub_tanh_half (a : ℝ) : |
| (1-Real.tanh a)/2 = 1/(1+Real.exp (2*a)) := by |
| have hh := exp_two_mul_one_sub_tanh a |
| have he := Real.exp_pos (2*a) |
| apply (eq_div_iff (by positivity : (1+Real.exp (2*a)) ≠ 0)).mpr |
| nlinarith |
|
|
| lemma one_add_tanh_half (a : ℝ) : |
| (1+Real.tanh a)/2 = 1/(1+Real.exp (-2*a)) := by |
| simpa only [Real.tanh_neg, sub_neg_eq_add, mul_neg, neg_mul] using one_sub_tanh_half (-a) |
|
|
| lemma siteRefresh_diagonal_lower {n : ℕ} (J : Interaction n) (x : Spin n) (i : Fin n) : |
| 1/(1+Real.exp (2*|field J x i|)) ≤ |
| siteRefresh J i (fun z => if z=x then 1 else 0) x := by |
| have htrue : replace x i true = x ↔ x i = true := by |
| constructor |
| · intro h; simpa using (congrFun h i).symm |
| · intro h; simpa only [h] using replace_self x i |
| have hfalse : replace x i false = x ↔ x i = false := by |
| constructor |
| · intro h; simpa using (congrFun h i).symm |
| · intro h; simpa only [h] using replace_self x i |
| simp only [siteRefresh, htrue, hfalse, mean] |
| cases x i <;> simp only [ Bool.false_eq_true, Bool.true_eq_false, |
| ↓reduceIte, mul_zero, mul_one, zero_add, add_zero] |
| · rw [one_sub_tanh_half] |
| apply one_div_le_one_div_of_le (by positivity) |
| apply add_le_add le_rfl |
| apply Real.exp_le_exp.mpr |
| linarith [le_abs_self (field J x i)] |
| · rw [one_add_tanh_half] |
| apply one_div_le_one_div_of_le (by positivity) |
| apply add_le_add le_rfl |
| apply Real.exp_le_exp.mpr |
| linarith [neg_le_abs (field J x i)] |
|
|
| lemma logistic_quadratic_lower {a L : ℝ} (hL : 0 < L) : |
| (1-a^2/L^2)/(1+Real.exp (2*L)) ≤ 1/(1+Real.exp (2*|a|)) := by |
| by_cases ha : |a| ≤ L |
| · calc |
| _ ≤ 1/(1+Real.exp (2*L)) := by |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| have : 0 ≤ a^2/L^2 := by positivity |
| linarith |
| _ ≤ _ := by |
| apply one_div_le_one_div_of_le (by positivity) |
| apply add_le_add le_rfl |
| apply Real.exp_le_exp.mpr |
| linarith |
| · have ha2 : L^2 ≤ a^2 := by nlinarith [sq_abs a, abs_nonneg a, le_of_not_ge ha] |
| have hratio : 1 ≤ a^2/L^2 := (one_le_div (sq_pos_of_pos hL)).mpr ha2 |
| exact (div_nonpos_of_nonpos_of_nonneg (by linarith) (by positivity)).trans (by positivity) |
|
|
| lemma attempted_holding_lower {n : ℕ} (hn : 0 < n) (J : Interaction n) |
| {K : ℝ} (hK : 0 < K) |
| (hJ : ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) J‖ ≤ K) (x : Spin n) : |
| 1/(2*(1+Real.exp (2*(Real.sqrt 2*K)))) ≤ attemptKernel J x x := by |
| have hnR : (0:ℝ) < n := Nat.cast_pos.mpr hn |
| have hL : 0 < Real.sqrt 2*K := mul_pos (Real.sqrt_pos.mpr (by norm_num)) hK |
| have hL2 : (Real.sqrt 2*K)^2 = 2*K^2 := by |
| rw [mul_pow, Real.sq_sqrt (by norm_num : (0:ℝ) ≤ 2)] |
| have hsum := field_square_sum_le J x hK.le hJ |
| have hs : (∑ i, (1-field J x i^2/(Real.sqrt 2*K)^2)/(1+Real.exp (2*(Real.sqrt 2*K)))) ≤ |
| ∑ i, siteRefresh J i (fun z => if z=x then 1 else 0) x := by |
| apply Finset.sum_le_sum |
| intro i _ |
| exact (logistic_quadratic_lower hL).trans (siteRefresh_diagonal_lower J x i) |
| simp only [← Finset.sum_div, Finset.sum_sub_distrib, Finset.sum_const, |
| Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, mul_one, hL2] at hs |
| have hf : (∑ i, field J x i^2)/(2*K^2) ≤ (n:ℝ)/2 := by |
| apply (div_le_iff₀ (by positivity : 0 < 2*K^2)).mpr |
| nlinarith |
| change _ ≤ attemptLM J (fun z => if z=x then 1 else 0) x |
| rw [attempt_apply_of_pos hn] |
| apply (le_div_iff₀ hnR).mpr |
| calc |
| _ = ((n:ℝ)/2)/(1+Real.exp (2*(Real.sqrt 2*K))) := by field_simp |
| _ ≤ ((n:ℝ)-(∑ i, field J x i^2)/(2*K^2))/(1+Real.exp (2*(Real.sqrt 2*K))) := by |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| linarith |
| _ ≤ _ := hs |
|
|
| end SKRatio.Calculus |
|
|
| end |
| end |
|
|
| end OAI |
|
|
