| import Mathlib | |
| import OAI.Probability.SKRatio.FiniteChain.Mean | |
| import OAI.Probability.SKRatio.Calculus.RowControl | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open scoped BigOperators Topology Matrix | |
| open ContinuousLinearMap | |
| namespace SKRatio.Calculus | |
| open Real Set | |
| lemma gradientForm_pairs_bound {n : ℕ} (J : Interaction n) | |
| (hsymm : ∀ i j, J i j = J j i) (p : Fin n → ℝ) : | |
| pairSum (fun i j => | |
| J i j^2 * (conditionalVariance J (plusSpin n) j * p i + | |
| conditionalVariance J (plusSpin n) i * p j)^2 / | |
| (gradientWeight J (plusSpin n) i + gradientWeight J (plusSpin n) j)) ≤ | |
| (32/27)*R2 J * ∑ i, p i^2 := by | |
| have hpoint (i j : Fin n) : | |
| (conditionalVariance J (plusSpin n) j * p i + | |
| conditionalVariance J (plusSpin n) i * p j)^2 / | |
| (gradientWeight J (plusSpin n) i + gradientWeight J (plusSpin n) j) ≤ | |
| (32/27)*(p i^2+p j^2) := by | |
| have habs : |conditionalVariance J (plusSpin n) j * p i + | |
| conditionalVariance J (plusSpin n) i * p j| ≤ | |
| conditionalVariance J (plusSpin n) j * |p i| + | |
| conditionalVariance J (plusSpin n) i * |p j| := by | |
| simpa only [abs_mul, abs_of_pos (conditionalVariance_pos J (plusSpin n) j), | |
| abs_of_pos (conditionalVariance_pos J (plusSpin n) i)] using abs_add_le | |
| (conditionalVariance J (plusSpin n) j * p i) (conditionalVariance J (plusSpin n) i * p j) | |
| have hsquare := pow_le_pow_left₀ (abs_nonneg _) habs 2 | |
| rw [sq_abs] at hsquare | |
| refine (div_le_div_of_nonneg_right hsquare | |
| (add_pos (gradientWeight_pos J (plusSpin n) i) (gradientWeight_pos J (plusSpin n) j)).le).trans ?_ | |
| simpa only [conditionalVariance, mean_weight_plus, mean] using | |
| (scalar_pair_denominator_control | |
| (Real.neg_one_lt_tanh (field J (plusSpin n) i)).le | |
| (Real.tanh_lt_one (field J (plusSpin n) i)) | |
| (Real.neg_one_lt_tanh (field J (plusSpin n) j)).le | |
| (Real.tanh_lt_one (field J (plusSpin n) j)) (pi := p i) (pj := p j)) | |
| have hp := pairSum_le (fun i j (_ : i < j) => | |
| mul_le_mul_of_nonneg_left (hpoint i j) (sq_nonneg (J i j))) | |
| simp only [← mul_assoc] at hp | |
| have hr := mul_le_mul_of_nonneg_left (pair_row_bound J hsymm p 2) | |
| (by norm_num : (0:ℝ) ≤ 32/27) | |
| have hid : pairSum (fun i j => J i j^2 * (32/27) * (p i^2+p j^2)) = | |
| (32/27)*pairSum (fun i j => |J i j|^2 * (p i^2+p j^2)) := by | |
| rw [← pairSum_mul] | |
| unfold pairSum | |
| simp only [sq_abs] | |
| congr 1 | |
| ext i | |
| congr 1 | |
| ext j | |
| ring | |
| rw [hid] at hp | |
| simpa only [mul_div_assoc, mul_assoc] using hp.trans hr | |
| theorem rough_gradient_bound {n : ℕ} (J : Interaction n) | |
| (hsymm : ∀ i j, J i j = J j i) (hdiag : ∀ i, J i i = 0) (p : Fin n → ℝ) : | |
| gradientForm J p ≤ (euclideanOpNorm J + | |
| (4/(3*Real.sqrt 3)+32/27)*R2 J) * ∑ i, p i^2 := by | |
| have h₁ := gradientForm_linear_bound J hdiag p | |
| have h₂ := gradientForm_quadratic_bound J hsymm p | |
| have h₃ := gradientForm_pairs_bound J hsymm p | |
| unfold gradientForm | |
| linarith only [h₁, h₂, h₃] | |
| def signedVector {n : ℕ} (x : Spin n) (p : EuclideanSpace ℝ (Fin n)) : | |
| EuclideanSpace ℝ (Fin n) := WithLp.toLp 2 (fun i => spin x i * p.ofLp i) | |
| @[simp] lemma norm_signedVector {n : ℕ} (x : Spin n) (p : EuclideanSpace ℝ (Fin n)) : | |
| ‖signedVector x p‖ = ‖p‖ := by | |
| apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp | |
| simp only [EuclideanSpace.real_norm_sq_eq, signedVector, mul_pow, spin_sq, one_mul] | |
| lemma signConjugate_action {n : ℕ} (J : Interaction n) (x : Spin n) | |
| (p : EuclideanSpace ℝ (Fin n)) : | |
| Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) (signConjugate x J) p = | |
| signedVector x (Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) J (signedVector x p)) := by | |
| apply WithLp.ofLp_injective | |
| funext i | |
| change (∑ j, signConjugate x J i j * p.ofLp j) = | |
| spin x i * (∑ j, J i j * (spin x j * p.ofLp j)) | |
| simp only [signConjugate, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| ring | |
| lemma euclideanOpNorm_signConjugate_le {n : ℕ} (J : Interaction n) (x : Spin n) : | |
| euclideanOpNorm (signConjugate x J) ≤ euclideanOpNorm J := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (euclideanOpNorm_nonneg J) | |
| intro p | |
| rw [signConjugate_action, norm_signedVector] | |
| simpa only [norm_signedVector, euclideanOpNorm] using | |
| (Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) J).le_opNorm (signedVector x p) | |
| @[simp] lemma signConjugate_twice {n : ℕ} (J : Interaction n) (x : Spin n) : | |
| signConjugate x (signConjugate x J) = J := by | |
| funext i j | |
| simp only [signConjugate] | |
| calc | |
| _ = (spin x i)^2 * (spin x j)^2 * J i j := by ring | |
| _ = J i j := by simp only [spin_sq, one_mul] | |
| @[simp] lemma euclideanOpNorm_signConjugate {n : ℕ} (J : Interaction n) (x : Spin n) : | |
| euclideanOpNorm (signConjugate x J) = euclideanOpNorm J := by | |
| exact le_antisymm (euclideanOpNorm_signConjugate_le J x) | |
| (by simpa only [signConjugate_twice] using euclideanOpNorm_signConjugate_le (signConjugate x J) x) | |
| theorem gradient_global_bound {n : ℕ} (J : Interaction n) | |
| (hsymm : ∀ i j, J i j = J j i) (hdiag : ∀ i, J i i = 0) | |
| (hsmall : ∀ i j, |J i j| ≤ 1/10) (f : Observables n) (t : ℝ) (x : Spin n) : | |
| deriv (fun s => unweightedGradient (semigroup J s f) x) t - | |
| generator J (unweightedGradient (semigroup J t f)) x ≤ | |
| 2*(-1+euclideanOpNorm J+(4/(3*Real.sqrt 3)+32/27)*R2 J+16*R3 J) * | |
| unweightedGradient (semigroup J t f) x := by | |
| have hlocal := pointwise_gradient_local_bound J hsymm hdiag hsmall f t x | |
| have hform := rough_gradient_bound (signConjugate x J) (signConjugate_symm J hsymm x) | |
| (signConjugate_diag J hdiag x) (fun i => spin x i * halfDiff i (semigroup J t f) x) | |
| simp only [euclideanOpNorm_signConjugate, R2, rowControl_signConjugate, mul_pow, spin_sq, one_mul] at hform | |
| change gradientForm _ _ ≤ _ * unweightedGradient (semigroup J t f) x at hform | |
| linarith only [hlocal, hform] | |
| lemma rough_coefficient_lt_two : 4/(3*Real.sqrt 3)+32/27 < (2:ℝ) := by | |
| have hs : 0 < Real.sqrt 3 := Real.sqrt_pos.2 (by norm_num) | |
| have hs2 : (Real.sqrt 3)^2 = 3 := Real.sq_sqrt (by norm_num) | |
| have hslo : (18/11:ℝ) < Real.sqrt 3 := by nlinarith only [hs2, hs] | |
| have h : 4/(3*Real.sqrt 3) < (22/27:ℝ) := | |
| (div_lt_iff₀ (by positivity : 0 < 3*Real.sqrt 3)).mpr (by linarith only [hslo]) | |
| linarith only [h] | |
| theorem gradient_dissipation_small_norm {n : ℕ} (J : Interaction n) | |
| (hsymm : ∀ i j, J i j = J j i) (hdiag : ∀ i, J i i = 0) | |
| (hsmall : ∀ i j, |J i j| ≤ 1/10) | |
| (hop : euclideanOpNorm J ≤ 7/10+1/10000) | |
| (hr2 : R2 J ≤ 49/400+1/10000) (hr3 : R3 J ≤ 1/10000) | |
| (f : Observables n) (t : ℝ) (x : Spin n) : | |
| deriv (fun s => unweightedGradient (semigroup J s f) x) t - | |
| generator J (unweightedGradient (semigroup J t f)) x ≤ | |
| -(1/10:ℝ) * unweightedGradient (semigroup J t f) x := by | |
| have h := gradient_global_bound J hsymm hdiag hsmall f t x | |
| have hc : 2*(-1+euclideanOpNorm J+(4/(3*Real.sqrt 3)+32/27)*R2 J+16*R3 J) ≤ -(1/10:ℝ) := by | |
| have hm := mul_le_mul_of_nonneg_right rough_coefficient_lt_two.le (rowControl_nonneg J 2) | |
| linarith only [hm, hop, hr2, hr3] | |
| exact h.trans (mul_le_mul_of_nonneg_right hc | |
| (Finset.sum_nonneg (fun i _ => sq_nonneg (halfDiff i (semigroup J t f) x)))) | |
| noncomputable def attemptLM {n : ℕ} (J : Interaction n) : | |
| Observables n →L[ℝ] Observables n := | |
| 1 + (n : ℝ)⁻¹ • generatorCLM J | |
| noncomputable def continuousKernel {n : ℕ} (J : Interaction n) (t : ℝ) : | |
| Matrix (Spin n) (Spin n) ℝ := fun x y => | |
| semigroup J t (fun z => if z = y then 1 else 0) x | |
| noncomputable def siteRefresh {n : ℕ} (J : Interaction n) (i : Fin n) | |
| (f : Observables n) (x : Spin n) : ℝ := | |
| ((1 + mean J x i) / 2) * f (replace x i true) + | |
| ((1 - mean J x i) / 2) * f (replace x i false) | |
| theorem generator_siteRefresh {n : ℕ} (J : Interaction n) (f : Observables n) | |
| (x : Spin n) : generator J f x = ∑ i, (siteRefresh J i f x - f x) := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| have hx : replace x i (x i) = x := replace_self x i | |
| cases hi : x i <;> simp only [hi] at hx | |
| · simp only [halfDiff, spin, hi, Bool.false_eq_true, ↓reduceIte, siteRefresh] | |
| rw [hx] | |
| ring | |
| · simp only [halfDiff, spin, hi, ↓reduceIte, siteRefresh] | |
| rw [hx] | |
| ring | |
| theorem attempt_apply_of_pos {n : ℕ} (hn : 0 < n) (J : Interaction n) | |
| (f : Observables n) (x : Spin n) : | |
| attemptLM J f x = (∑ i, siteRefresh J i f x) / (n : ℝ) := by | |
| have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast ne_of_gt hn | |
| change f x + (n : ℝ)⁻¹ * generator J f x = _ | |
| rw [generator_siteRefresh, Finset.sum_sub_distrib] | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] | |
| field_simp | |
| ring | |
| @[simp] theorem generator_const {n : ℕ} (J : Interaction n) (a : ℝ) (x : Spin n) : | |
| generator J (fun _ => a) x = 0 := by | |
| simp [generator] | |
| @[simp] theorem siteRefresh_const {n : ℕ} (J : Interaction n) (i : Fin n) | |
| (a : ℝ) (x : Spin n) : siteRefresh J i (fun _ => a) x = a := by | |
| unfold siteRefresh | |
| ring | |
| @[simp] theorem attempt_const {n : ℕ} (J : Interaction n) (a : ℝ) : | |
| attemptLM J (fun _ => a) = fun _ => a := by | |
| funext x | |
| change a + (n : ℝ)⁻¹ * generator J (fun _ => a) x = a | |
| simp | |
| @[simp] theorem attempt_pow_const {n : ℕ} (J : Interaction n) (k : ℕ) (a : ℝ) : | |
| (attemptLM J ^ k) (fun _ => a) = fun _ => a := by | |
| induction k with | |
| | zero => simp | |
| | succ k ih => simp only [pow_succ', mul_apply_eq_comp, ih, attempt_const] | |
| theorem siteRefresh_nonneg {n : ℕ} (J : Interaction n) (i : Fin n) | |
| (f : Observables n) (hf : ∀ x, 0 ≤ f x) (x : Spin n) : | |
| 0 ≤ siteRefresh J i f x := by | |
| have hm1 : -1 ≤ mean J x i := le_of_lt (Real.neg_one_lt_tanh _) | |
| have hm2 : mean J x i ≤ 1 := le_of_lt (Real.tanh_lt_one _) | |
| exact add_nonneg (mul_nonneg (by linarith) (hf _)) | |
| (mul_nonneg (by linarith) (hf _)) | |
| theorem attempt_nonneg {n : ℕ} (J : Interaction n) (f : Observables n) | |
| (hf : ∀ x, 0 ≤ f x) (x : Spin n) : 0 ≤ attemptLM J f x := by | |
| by_cases hn : n = 0 | |
| · subst n | |
| simpa [attemptLM] using hf x | |
| · rw [attempt_apply_of_pos (Nat.pos_of_ne_zero hn)] | |
| exact div_nonneg (Finset.sum_nonneg (fun _ _ => siteRefresh_nonneg J _ f hf x)) | |
| (Nat.cast_nonneg n) | |
| theorem attempt_pow_nonneg {n : ℕ} (J : Interaction n) (k : ℕ) (f : Observables n) | |
| (hf : ∀ x, 0 ≤ f x) (x : Spin n) : 0 ≤ (attemptLM J ^ k) f x := by | |
| induction k generalizing x with | |
| | zero => simpa using hf x | |
| | succ k ih => | |
| simp only [pow_succ', mul_apply_eq_comp] | |
| exact attempt_nonneg J _ ih x | |
| theorem exp_apply_hasSum {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [CompleteSpace E] (A : E →L[ℝ] E) (f : E) : | |
| HasSum (fun k : ℕ => (k.factorial : ℝ)⁻¹ • ((A ^ k) f)) | |
| (NormedSpace.exp A f) := by | |
| simpa only [NormedSpace.expSeries_apply_eq, ContinuousLinearMap.apply_apply, | |
| smul_apply] using | |
| (ContinuousLinearMap.apply ℝ E f).hasSum | |
| (NormedSpace.expSeries_hasSum_exp (𝕂 := ℝ) A) | |
| theorem exp_apply_of_apply_eq_zero {E : Type*} [NormedAddCommGroup E] | |
| [NormedSpace ℝ E] [CompleteSpace E] (A : E →L[ℝ] E) (f : E) | |
| (h : A f = 0) : NormedSpace.exp A f = f := by | |
| have hp (k : ℕ) : (A ^ (k + 1)) f = 0 := by | |
| induction k with | |
| | zero => simpa using h | |
| | succ k ih => rw [pow_succ', mul_apply_eq_comp, ih, map_zero] | |
| have hs : HasSum (fun k : ℕ => (k.factorial : ℝ)⁻¹ • ((A ^ k) f)) f := by | |
| convert hasSum_ite_eq 0 f using 1 | |
| funext k | |
| cases k with | |
| | zero => simp | |
| | succ k => simp [hp] | |
| exact (exp_apply_hasSum A f).unique hs | |
| @[simp] theorem semigroup_const {n : ℕ} (J : Interaction n) (t a : ℝ) : | |
| semigroup J t (fun _ => a) = fun _ => a := by | |
| apply exp_apply_of_apply_eq_zero | |
| funext x | |
| change t * generator J (fun _ => a) x = 0 | |
| simp | |
| theorem exp_smul_identity {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [CompleteSpace E] (a : ℝ) : | |
| NormedSpace.exp (a • (1 : E →L[ℝ] E)) = Real.exp a • (1 : E →L[ℝ] E) := by | |
| simpa only [Algebra.algebraMap_eq_smul_one, ← Real.exp_eq_exp_ℝ] using | |
| (NormedSpace.algebraMap_exp_comm (𝔸 := E →L[ℝ] E) a).symm | |
| theorem semigroup_uniformization {n : ℕ} (hn : 0 < n) (J : Interaction n) (t : ℝ) : | |
| semigroup J t = Real.exp (-(n : ℝ) * t) • | |
| NormedSpace.exp (((n : ℝ) * t) • attemptLM J) := by | |
| have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast ne_of_gt hn | |
| have heq : t • generatorCLM J = | |
| (-(n : ℝ) * t) • (1 : Observables n →L[ℝ] Observables n) + | |
| ((n : ℝ) * t) • attemptLM J := by | |
| unfold attemptLM | |
| simp only [smul_add, smul_smul] | |
| have hc : ((n : ℝ) * t) * (n : ℝ)⁻¹ = t := by field_simp | |
| rw [hc] | |
| module | |
| let : NormedAlgebra ℚ (Observables n →L[ℝ] Observables n) := | |
| NormedAlgebra.restrictScalars ℚ ℝ _ | |
| unfold semigroup | |
| rw [heq, NormedSpace.exp_add_of_commute | |
| (((Commute.one_left (attemptLM J)).smul_left _).smul_right _), | |
| exp_smul_identity, smul_mul_assoc, one_mul] | |
| theorem semigroup_nonneg {n : ℕ} (J : Interaction n) (t : ℝ) (ht : 0 ≤ t) | |
| (f : Observables n) (hf : ∀ x, 0 ≤ f x) (x : Spin n) : | |
| 0 ≤ semigroup J t f x := by | |
| by_cases hn : n = 0 | |
| · subst n | |
| have hL : generatorCLM J = 0 := by | |
| ext f x | |
| simp [generatorCLM, generatorLM, generator] | |
| simp only [semigroup, hL, smul_zero, NormedSpace.exp_zero, | |
| one_apply_eq_self] | |
| exact hf x | |
| · rw [semigroup_uniformization (Nat.pos_of_ne_zero hn)] | |
| simp only [smul_apply, Pi.smul_apply, smul_eq_mul] | |
| apply mul_nonneg (le_of_lt (Real.exp_pos _)) | |
| have hs := Pi.hasSum.mp (exp_apply_hasSum (((n : ℝ) * t) • attemptLM J) f) x | |
| apply HasSum.nonneg _ hs | |
| intro k | |
| simp only [smul_pow, smul_apply, Pi.smul_apply, smul_eq_mul] | |
| exact mul_nonneg (inv_nonneg.mpr (Nat.cast_nonneg _)) | |
| (mul_nonneg (pow_nonneg (mul_nonneg (Nat.cast_nonneg _) ht) _) | |
| (attempt_pow_nonneg J k f hf x)) | |
| theorem continuousKernel_nonneg {n : ℕ} (J : Interaction n) (t : ℝ) (ht : 0 ≤ t) | |
| (x y : Spin n) : 0 ≤ continuousKernel J t x y := by | |
| exact semigroup_nonneg J t ht _ (fun _ => by split_ifs <;> norm_num) x | |
| theorem continuousKernel_sum {n : ℕ} (J : Interaction n) (t : ℝ) (x : Spin n) : | |
| ∑ y, continuousKernel J t x y = 1 := by | |
| have eq_one : (∑ y : Spin n, fun z => if z = y then (1 : ℝ) else 0) = | |
| fun _ : Spin n => (1 : ℝ) := by | |
| funext z | |
| simp | |
| unfold continuousKernel | |
| rw [← Finset.sum_apply, ← map_sum, eq_one, semigroup_const] | |
| theorem attempt_eq_transition {n : ℕ} (g : Disorder n) (f : Observables n) : | |
| attemptLM (coupling g) f = transition g *ᵥ f := by | |
| funext x | |
| by_cases hn : n = 0 | |
| · subst n | |
| simp [attemptLM, transition] | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn | |
| change f x + (n : ℝ)⁻¹ * generator (coupling g) f x = _ | |
| rw [generator_eq_transition] | |
| simp only [← mul_assoc, inv_mul_cancel₀ hn', one_mul] | |
| change f x + ((transition g *ᵥ f) x - f x) = (transition g *ᵥ f) x | |
| ring | |
| theorem attempt_pow_eq_transition_pow {n : ℕ} (g : Disorder n) (k : ℕ) | |
| (f : Observables n) : (attemptLM (coupling g)^k) f = transition g^k *ᵥ f := by | |
| induction k with | |
| | zero => simp | |
| | succ k ih => | |
| rw [pow_succ', pow_succ', mul_apply_eq_comp, ih, attempt_eq_transition, | |
| Matrix.mulVec_mulVec] | |
| theorem semigroup_add {n : ℕ} (J : Interaction n) (s t : ℝ) : | |
| semigroup J (s+t) = semigroup J s * semigroup J t := by | |
| let : NormedAlgebra ℚ (Observables n →L[ℝ] Observables n) := | |
| NormedAlgebra.restrictScalars ℚ ℝ _ | |
| unfold semigroup | |
| rw [add_smul, NormedSpace.exp_add_of_commute | |
| (((Commute.refl (generatorCLM J)).smul_left _).smul_right _)] | |
| theorem semigroup_mono {n : ℕ} (J : Interaction n) {t : ℝ} (ht : 0 ≤ t) | |
| (f h : Observables n) (hfh : ∀ x, f x ≤ h x) (x : Spin n) : | |
| semigroup J t f x ≤ semigroup J t h x := by | |
| have hn := semigroup_nonneg J t ht (h-f) (fun x => sub_nonneg.mpr (hfh x)) x | |
| simpa only [map_sub, Pi.sub_apply, sub_nonneg] using hn | |
| theorem semigroup_abs_le {n : ℕ} (J : Interaction n) {t : ℝ} (ht : 0 ≤ t) | |
| (f : Observables n) {B : ℝ} (hf : ∀ x, |f x| ≤ B) (x : Spin n) : | |
| |semigroup J t f x| ≤ B := by | |
| have hu := semigroup_mono J ht f (fun _ => B) (fun x => (abs_le.mp (hf x)).2) x | |
| have hl := semigroup_mono J ht (fun _ => -B) f (fun x => (abs_le.mp (hf x)).1) x | |
| simp only [semigroup_const] at hu hl | |
| exact abs_le.mpr ⟨hl,hu⟩ | |
| theorem observable_basis {n : ℕ} (f : Observables n) : | |
| f = ∑ y : Spin n, f y • (fun z => if z = y then (1:ℝ) else 0) := by | |
| funext x | |
| simp | |
| theorem semigroup_eq_kernel {n : ℕ} (J : Interaction n) (t : ℝ) | |
| (f : Observables n) (x : Spin n) : | |
| semigroup J t f x = FiniteLaw.mean (continuousKernel J t x) f := by | |
| conv_lhs => rw [observable_basis f] | |
| simp only [map_sum, map_smul, Finset.sum_apply, Pi.smul_apply, smul_eq_mul, | |
| FiniteLaw.mean, continuousKernel] | |
| exact Finset.sum_congr rfl (fun _ _ => mul_comm _ _) | |
| theorem kernel_eq_mulVec {n : ℕ} (J : Interaction n) (t : ℝ) | |
| (f : Observables n) : semigroup J t f = continuousKernel J t *ᵥ f := by | |
| funext x | |
| exact semigroup_eq_kernel J t f x | |
| theorem continuousKernel_add {n : ℕ} (J : Interaction n) (s t : ℝ) : | |
| continuousKernel J (s+t) = | |
| (continuousKernel J s : Matrix (Spin n) (Spin n) ℝ) * continuousKernel J t := by | |
| funext x y | |
| unfold continuousKernel | |
| rw [semigroup_add, mul_apply_eq_comp, semigroup_eq_kernel] | |
| rfl | |
| theorem continuousKernel_poisson_hasSum {n : ℕ} (hn : 0 < n) (g : Disorder n) | |
| (t : ℝ) (x y : Spin n) : | |
| HasSum (fun k : ℕ => Real.exp (-(n:ℝ)*t) * ((n:ℝ)*t)^k / | |
| (k.factorial:ℝ) * (transition g^k) x y) | |
| (continuousKernel (coupling g) t x y) := by | |
| have hs := (Pi.hasSum.mp (exp_apply_hasSum (((n:ℝ)*t) • attemptLM (coupling g)) | |
| (fun z => if z = y then (1:ℝ) else 0)) x).mul_left (Real.exp (-(n:ℝ)*t)) | |
| simp only [smul_pow, smul_apply, Pi.smul_apply, smul_eq_mul, | |
| attempt_pow_eq_transition_pow, Matrix.mulVec, dotProduct, | |
| mul_ite, mul_one, mul_zero, Fintype.sum_ite_eq'] at hs | |
| rw [continuousKernel, semigroup_uniformization hn] | |
| have heq : (fun k : ℕ => Real.exp (-(n:ℝ)*t) * ((n:ℝ)*t)^k / | |
| (k.factorial:ℝ) * (transition g^k) x y) = | |
| (fun k : ℕ => Real.exp (-(n:ℝ)*t) * ((k.factorial:ℝ)⁻¹ * | |
| (((n:ℝ)*t)^k * (transition g^k) x y))) := by | |
| funext k | |
| ring | |
| rw [heq] | |
| exact hs | |
| end SKRatio.Calculus | |
| end | |
| end | |
| end OAI | |