| import Mathlib |
| import OAI.Probability.SKGap.Terminal.Spin |
|
|
| namespace OAI |
|
|
| section |
| open scoped BigOperators |
| namespace SKGapCutoff |
|
|
| 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] |
|
|
| @[simp] theorem spin_sq {n : ℕ} (x : Spin n) (i : Fin n) : spin x i ^ 2 = 1 := by |
| unfold spin |
| cases x i <;> norm_num |
|
|
| @[simp] theorem spin_mul_self {n : ℕ} (x : Spin n) (i : Fin n) : |
| spin x i * spin x i = 1 := by simpa only [pow_two] using spin_sq x i |
|
|
| @[simp] theorem field_zero {n : ℕ} (x : Spin n) (i : Fin n) : |
| field (0 : Interaction n) x i = 0 := by simp [field] |
|
|
| @[simp] theorem mean_zero {n : ℕ} (x : Spin n) (i : Fin n) : |
| mean (0 : Interaction n) x i = 0 := by simp [mean] |
|
|
| @[simp] theorem energy_zero {n : ℕ} (x : Spin n) : |
| energy (0 : Interaction n) x = 0 := by simp [energy] |
|
|
| @[simp] theorem card_spin (n : ℕ) : Fintype.card (Spin n) = 2 ^ n := by |
| simp [Spin] |
|
|
| @[simp] theorem partition_zero (n : ℕ) : partition (0 : Interaction n) = (2 : ℝ) ^ n := by |
| simp [partition] |
|
|
| @[simp] theorem gibbs_zero {n : ℕ} (x : Spin n) : |
| gibbs (0 : Interaction n) x = ((2 : ℝ) ^ n)⁻¹ := by simp [gibbs] |
|
|
| noncomputable def character {n : ℕ} (s : Finset (Fin n)) (x : Spin n) : ℝ := |
| ∏ i ∈ s, spin x i |
|
|
| @[simp] theorem character_empty {n : ℕ} (x : Spin n) : character ∅ x = 1 := by |
| simp [character] |
|
|
| @[simp] theorem character_sq {n : ℕ} (s : Finset (Fin n)) (x : Spin n) : |
| character s x ^ 2 = 1 := by simp [character, ← Finset.prod_pow] |
|
|
| lemma character_erase {n : ℕ} (s : Finset (Fin n)) (x : Spin n) (i : Fin n) |
| (hi : i ∈ s) : spin x i * character (s.erase i) x = character s x := by |
| exact Finset.mul_prod_erase s (fun j => spin x j) hi |
|
|
| lemma spin_replace_of_ne {n : ℕ} (x : Spin n) {i j : Fin n} (h : j ≠ i) (b : Bool) : |
| spin (replace x i b) j = spin x j := by |
| simp [spin, replace, Function.update_of_ne h] |
|
|
| lemma character_replace_of_not_mem {n : ℕ} (s : Finset (Fin n)) (x : Spin n) |
| (i : Fin n) (hi : i ∉ s) (b : Bool) : character s (replace x i b) = character s x := by |
| apply Finset.prod_congr rfl |
| intro j hj |
| exact spin_replace_of_ne x (ne_of_mem_of_not_mem hj hi) b |
|
|
| lemma character_replace_of_mem {n : ℕ} (s : Finset (Fin n)) (x : Spin n) |
| (i : Fin n) (hi : i ∈ s) (b : Bool) : |
| character s (replace x i b) = (if b then 1 else -1) * character (s.erase i) x := by |
| rw [← character_erase s (replace x i b) i hi, |
| character_replace_of_not_mem _ x i (Finset.notMem_erase i s)] |
| simp [spin] |
|
|
| lemma halfDiff_character {n : ℕ} (s : Finset (Fin n)) (x : Spin n) (i : Fin n) : |
| halfDiff i (character s) x = if i ∈ s then character (s.erase i) x else 0 := by |
| by_cases hi : i ∈ s |
| · simp only [halfDiff, character_replace_of_mem s x i hi, Bool.false_eq_true, ↓reduceIte, hi] |
| ring |
| · simp [halfDiff, character_replace_of_not_mem s x i hi, hi] |
|
|
| lemma spin_mul_halfDiff_character {n : ℕ} (s : Finset (Fin n)) (x : Spin n) (i : Fin n) : |
| spin x i * halfDiff i (character s) x = if i ∈ s then character s x else 0 := by |
| rw [halfDiff_character] |
| split_ifs with hi |
| · exact character_erase s x i hi |
| · ring |
|
|
| lemma generator_zero_character {n : ℕ} (s : Finset (Fin n)) : |
| generatorCLM (0 : Interaction n) (character s) = -(s.card : ℝ) • character s := by |
| funext x |
| change generator (0 : Interaction n) (character s) x = -(s.card : ℝ) * character s x |
| simp only [generator, mean_zero, zero_sub, neg_mul, spin_mul_halfDiff_character, |
| Finset.sum_neg_distrib] |
| simp |
|
|
| theorem exp_apply_of_eigenvector {E : Type*} [NormedAddCommGroup E] |
| [NormedSpace ℝ E] [CompleteSpace E] (A : E →L[ℝ] E) (f : E) (a : ℝ) |
| (h : A f = a • f) : NormedSpace.exp A f = Real.exp a • f := by |
| have hp (k : ℕ) : (A ^ k) f = a ^ k • f := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| rw [pow_succ', mul_apply_eq_comp, ih, map_smul, h, smul_smul, pow_succ] |
| have hs : HasSum (fun k : ℕ => (k.factorial : ℝ)⁻¹ * a ^ k) (Real.exp a) := by |
| simpa only [smul_eq_mul, Real.exp_eq_exp_ℝ] using |
| (NormedSpace.exp_series_hasSum_exp' (𝕂 := ℝ) a) |
| apply (exp_apply_hasSum A f).unique |
| simpa only [hp, smul_smul] using hs.smul_const f |
|
|
| lemma semigroup_zero_character {n : ℕ} (s : Finset (Fin n)) (t : ℝ) : |
| semigroup (0 : Interaction n) t (character s) = |
| Real.exp (-t * (s.card : ℝ)) • character s := by |
| apply exp_apply_of_eigenvector |
| rw [smul_apply, generator_zero_character, smul_smul] |
| congr 1 |
| ring |
|
|
| lemma attempt_zero_character {n : ℕ} (s : Finset (Fin n)) : |
| attemptLM (0 : Interaction n) (character s) = |
| (1 - (s.card : ℝ) / n) • character s := by |
| change character s + (n : ℝ)⁻¹ • generatorCLM (0 : Interaction n) (character s) = _ |
| rw [generator_zero_character, smul_smul] |
| module |
|
|
| lemma attempt_pow_zero_character {n : ℕ} (s : Finset (Fin n)) (k : ℕ) : |
| (attemptLM (0 : Interaction n) ^ k) (character s) = |
| (1 - (s.card : ℝ) / n) ^ k • character s := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| rw [pow_succ', mul_apply_eq_comp, ih, map_smul, attempt_zero_character, |
| smul_smul, pow_succ] |
|
|
| lemma character_eq_prod_univ {n : ℕ} (s : Finset (Fin n)) (x : Spin n) : |
| character s x = ∏ i : Fin n, if i ∈ s then spin x i else 1 := by |
| simp [character, Finset.prod_ite_mem] |
|
|
| lemma character_inner {n : ℕ} (s r : Finset (Fin n)) : |
| ∑ x : Spin n, character s x * character r x = |
| if s = r then (2 : ℝ) ^ n else 0 := by |
| by_cases h : s = r |
| · subst r |
| simp only [← pow_two, character_sq, ↓reduceIte, Finset.sum_const, |
| Finset.card_univ, card_spin, nsmul_eq_mul, mul_one, Nat.cast_pow, Nat.cast_ofNat] |
| · rw [ite_eq_right h] |
| have hp : (∑ x : Spin n, character s x * character r x) = |
| ∏ i : Fin n, ∑ b : Bool, |
| (if i ∈ s then (if b then (1 : ℝ) else -1) else 1) * |
| (if i ∈ r then (if b then (1 : ℝ) else -1) else 1) := by |
| rw [Fintype.prod_sum] |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [character_eq_prod_univ, character_eq_prod_univ, ← Finset.prod_mul_distrib] |
| rfl |
| rw [hp] |
| obtain ⟨i, hi⟩ : ∃ i, ¬ (i ∈ s ↔ i ∈ r) := by |
| by_contra! hc |
| exact h (Finset.ext hc) |
| apply Finset.prod_eq_zero (Finset.mem_univ i) |
| by_cases hs : i ∈ s <;> by_cases hr : i ∈ r |
| · exact (hi (by simp [hs, hr])).elim |
| · simp [hs, hr] |
| · simp [hs, hr] |
| · exact (hi (by simp [hs, hr])).elim |
|
|
| lemma character_sum {n : ℕ} (s : Finset (Fin n)) : |
| ∑ x : Spin n, character s x = if s = ∅ then (2 : ℝ) ^ n else 0 := by |
| simpa only [character_empty, mul_one] using character_inner s ∅ |
|
|
| lemma character_delta_sum {n : ℕ} (x y : Spin n) : |
| ∑ s : Finset (Fin n), character s x * character s y = |
| if x = y then (2 : ℝ) ^ n else 0 := by |
| have hsum : (∑ s : Finset (Fin n), character s x * character s y) = |
| ∏ i : Fin n, (spin x i * spin y i + 1) := by |
| rw [Finset.prod_add_one] |
| simp only [Finset.powerset_univ] |
| apply Finset.sum_congr rfl |
| intro s _ |
| exact (Finset.prod_mul_distrib (f := spin x) (g := spin y)).symm |
| rw [hsum] |
| by_cases h : x = y |
| · subst y |
| simp only [spin_mul_self, ↓reduceIte, Finset.prod_const, Finset.card_univ, |
| Fintype.card_fin] |
| norm_num |
| · rw [ite_eq_right h] |
| obtain ⟨i, hi⟩ : ∃ i, x i ≠ y i := Function.ne_iff.mp h |
| apply Finset.prod_eq_zero (Finset.mem_univ i) |
| unfold spin |
| cases hx : x i <;> cases hy : y i <;> simp_all |
|
|
| lemma delta_character_expansion {n : ℕ} (y : Spin n) : |
| (fun x : Spin n => if x = y then (1 : ℝ) else 0) = |
| ((2 : ℝ) ^ n)⁻¹ • ∑ s : Finset (Fin n), character s y • character s := by |
| funext x |
| simp only [Pi.smul_apply, Finset.sum_apply, smul_eq_mul] |
| simp_rw [mul_comm (character _ y)] |
| rw [character_delta_sum] |
| split_ifs <;> simp |
|
|
| lemma character_parseval {n : ℕ} (a : Finset (Fin n) → ℝ) : |
| (∑ x : Spin n, (∑ s : Finset (Fin n), a s * character s x) ^ 2) = |
| (2 : ℝ) ^ n * ∑ s : Finset (Fin n), a s ^ 2 := by |
| simp only [pow_two, Finset.sum_mul_sum] |
| rw [Finset.sum_comm] |
| apply Eq.trans _ (Finset.mul_sum ..).symm |
| apply Finset.sum_congr rfl |
| intro s _ |
| rw [Finset.sum_comm] |
| simp_rw [show ∀ r x, a s * character s x * (a r * character r x) = |
| (a s * a r) * (character s x * character r x) by intros; ring, |
| ← Finset.mul_sum, character_inner] |
| simp only [mul_ite, mul_zero, Fintype.sum_ite_eq] |
| ring |
|
|
| noncomputable def fourierKernel {n : ℕ} (a : Finset (Fin n) → ℝ) |
| (x y : Spin n) : ℝ := |
| ((2 : ℝ) ^ n)⁻¹ * ∑ s : Finset (Fin n), a s * character s x * character s y |
|
|
| lemma continuousKernel_zero_fourier {n : ℕ} (t : ℝ) (x y : Spin n) : |
| continuousKernel (0 : Interaction n) t x y = |
| fourierKernel (fun s => Real.exp (-t * (s.card : ℝ))) x y := by |
| unfold continuousKernel |
| rw [delta_character_expansion y, map_smul, map_sum] |
| simp_rw [map_smul, semigroup_zero_character] |
| simp only [Pi.smul_apply, Finset.sum_apply, smul_eq_mul, fourierKernel] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro s _ |
| ring |
|
|
| lemma discreteKernel_zero_fourier {n : ℕ} (k : ℕ) (x y : Spin n) : |
| discreteKernel (0 : Interaction n) k x y = |
| fourierKernel (fun s => (1 - (s.card : ℝ) / n) ^ k) x y := by |
| unfold discreteKernel |
| rw [delta_character_expansion y, map_smul, map_sum] |
| simp_rw [map_smul, attempt_pow_zero_character] |
| simp only [Pi.smul_apply, Finset.sum_apply, smul_eq_mul, fourierKernel] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro s _ |
| ring |
|
|
| noncomputable def centeredFourier {n : ℕ} (a : Finset (Fin n) → ℝ) |
| (s : Finset (Fin n)) : ℝ := a s - if s = ∅ then 1 else 0 |
|
|
| lemma centeredFourier_sum_sq {n : ℕ} (a : Finset (Fin n) → ℝ) (ha : a ∅ = 1) : |
| ∑ s, centeredFourier a s ^ 2 = (∑ s, a s ^ 2) - 1 := by |
| have h (s : Finset (Fin n)) : centeredFourier a s ^ 2 = |
| a s ^ 2 - if s = ∅ then 1 else 0 := by |
| by_cases hs : s = ∅ <;> simp [centeredFourier, hs, ha] |
| simp_rw [h, Finset.sum_sub_distrib] |
| simp |
|
|
| lemma centeredFourier_expansion {n : ℕ} (a : Finset (Fin n) → ℝ) (x y : Spin n) : |
| ∑ s, centeredFourier a s * character s x * character s y = |
| (∑ s, a s * character s x * character s y) - 1 := by |
| simp only [centeredFourier, sub_mul, Finset.sum_sub_distrib] |
| simp |
|
|
| lemma fourierKernel_sub_uniform {n : ℕ} (a : Finset (Fin n) → ℝ) (x y : Spin n) : |
| fourierKernel a x y - ((2 : ℝ) ^ n)⁻¹ = |
| ((2 : ℝ) ^ n)⁻¹ * ∑ s, centeredFourier a s * character s x * character s y := by |
| rw [centeredFourier_expansion] |
| unfold fourierKernel |
| ring |
|
|
| lemma fourierKernel_chiSquare {n : ℕ} (a : Finset (Fin n) → ℝ) (ha : a ∅ = 1) |
| (x : Spin n) : |
| (2 : ℝ) ^ n * ∑ y, (fourierKernel a x y - ((2 : ℝ) ^ n)⁻¹) ^ 2 = |
| (∑ s, a s ^ 2) - 1 := by |
| simp_rw [fourierKernel_sub_uniform, mul_pow] |
| rw [← Finset.mul_sum, character_parseval] |
| simp only [mul_pow, character_sq, mul_one] |
| rw [centeredFourier_sum_sq a ha] |
| field_simp |
|
|
| lemma totalVariation_fourier_sq_le {n : ℕ} (a : Finset (Fin n) → ℝ) |
| (ha : a ∅ = 1) (x : Spin n) : |
| 4 * totalVariation (fourierKernel a x) (gibbs (0 : Interaction n)) ^ 2 ≤ |
| (∑ s, a s ^ 2) - 1 := by |
| have hc := Finset.sum_mul_sq_le_sq_mul_sq (R := ℝ) Finset.univ |
| (fun y : Spin n => |fourierKernel a x y - ((2 : ℝ) ^ n)⁻¹|) (fun _ => 1) |
| simp only [mul_one, one_pow, Finset.sum_const, Finset.card_univ, card_spin, |
| nsmul_eq_mul, Nat.cast_pow, Nat.cast_ofNat, mul_one, sq_abs] at hc |
| rw [mul_comm, fourierKernel_chiSquare a ha x] at hc |
| simp only [totalVariation, gibbs_zero] |
| nlinarith |
|
|
| lemma sum_pow_card {n : ℕ} (q : ℝ) : |
| ∑ s : Finset (Fin n), q ^ s.card = (1 + q) ^ n := by |
| simpa only [Finset.powerset_univ, one_pow, mul_one, Finset.card_univ, |
| Fintype.card_fin, add_comm] using |
| (Finset.sum_pow_mul_eq_add_pow q 1 (Finset.univ : Finset (Fin n))) |
|
|
| lemma exp_card_sq (t : ℝ) (k : ℕ) : |
| Real.exp (-t * (k : ℝ)) ^ 2 = Real.exp (-2 * t) ^ k := by |
| rw [← Real.exp_nat_mul, ← Real.exp_nat_mul] |
| congr 1 |
| push_cast |
| ring |
|
|
| lemma continuous_zero_tv_sq_le {n : ℕ} (t : ℝ) (x : Spin n) : |
| 4 * totalVariation (continuousKernel (0 : Interaction n) t x) |
| (gibbs (0 : Interaction n)) ^ 2 ≤ (1 + Real.exp (-2 * t)) ^ n - 1 := by |
| have hkernel : continuousKernel (0 : Interaction n) t x = |
| fourierKernel (fun s => Real.exp (-t * (s.card : ℝ))) x := by |
| funext y; exact continuousKernel_zero_fourier t x y |
| rw [hkernel] |
| have h := totalVariation_fourier_sq_le (fun s => Real.exp (-t * (s.card : ℝ))) |
| (by simp) x |
| simpa only [exp_card_sq, sum_pow_card] using h |
|
|
| lemma discrete_character_sq_le {n : ℕ} (hn : 0 < n) (k : ℕ) |
| (s : Finset (Fin n)) : |
| ((1 - (s.card : ℝ) / n) ^ k) ^ 2 ≤ Real.exp (-2 * (k : ℝ) / n) ^ s.card := by |
| have hn' : (0 : ℝ) < n := by exact_mod_cast hn |
| have hc : (s.card : ℝ) ≤ n := by |
| exact_mod_cast (show s.card ≤ n by simpa using Finset.card_le_univ s) |
| have hnonneg : 0 ≤ 1 - (s.card : ℝ) / n := sub_nonneg.mpr ((div_le_one hn').mpr hc) |
| have hle : 1 - (s.card : ℝ) / n ≤ Real.exp (-(s.card : ℝ) / n) := by |
| simpa only [neg_div, sub_eq_add_neg, add_comm] using |
| Real.add_one_le_exp (-(s.card : ℝ) / n) |
| calc |
| ((1 - (s.card : ℝ) / n) ^ k) ^ 2 = |
| (1 - (s.card : ℝ) / n) ^ (2 * k) := by rw [← pow_mul, Nat.mul_comm] |
| _ ≤ Real.exp (-(s.card : ℝ) / n) ^ (2 * k) := pow_le_pow_left₀ hnonneg hle _ |
| _ = Real.exp (-2 * (k : ℝ) / n) ^ s.card := by |
| rw [← Real.exp_nat_mul, ← Real.exp_nat_mul] |
| congr 1 |
| push_cast |
| ring |
|
|
| lemma discrete_zero_tv_sq_le {n : ℕ} (hn : 0 < n) (k : ℕ) (x : Spin n) : |
| 4 * totalVariation (discreteKernel (0 : Interaction n) k x) |
| (gibbs (0 : Interaction n)) ^ 2 ≤ |
| (1 + Real.exp (-2 * (k : ℝ) / n)) ^ n - 1 := by |
| have hkernel : discreteKernel (0 : Interaction n) k x = |
| fourierKernel (fun s => (1 - (s.card : ℝ) / n) ^ k) x := by |
| funext y; exact discreteKernel_zero_fourier k x y |
| rw [hkernel] |
| apply (totalVariation_fourier_sq_le (fun s => (1 - (s.card : ℝ) / n) ^ k) |
| (by simp) x).trans |
| apply sub_le_sub_right _ 1 |
| rw [← sum_pow_card] |
| exact Finset.sum_le_sum (fun s _ => discrete_character_sq_le hn k s) |
|
|
| end SKGapCutoff |
| end |
|
|
| end OAI |
|
|
