| import Mathlib | |
| import OAI.Probability.ParisiFinite.Shape | |
| namespace OAI | |
| /-! Log Mean. -/ | |
| noncomputable section | |
| open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder | |
| open Filter | |
| open scoped BigOperators | |
| open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate | |
| open scoped InnerProductSpace ComplexConjugate | |
| open Filter Topology | |
| open Filter Set Topology | |
| open scoped InnerProductSpace ComplexConjugate Topology | |
| open scoped InnerProductSpace | |
| open scoped BigOperators Topology InnerProductSpace | |
| open scoped BigOperators InnerProductSpace | |
| open scoped BigOperators Matrix Topology ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology | |
| open scoped BigOperators Matrix Topology | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open scoped Topology | |
| open Filter Asymptotics | |
| open scoped InnerProductSpace Topology | |
| open scoped InnerProductSpace BigOperators | |
| open scoped InnerProductSpace Topology BigOperators | |
| open scoped Topology BigOperators | |
| open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace | |
| open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace BigOperators | |
| open Filter ContinuousLinearMap | |
| open ContinuousLinearMap | |
| open scoped InnerProductSpace BigOperators Topology | |
| open ContinuousLinearMap InnerProductSpace | |
| open ContinuousLinearMap Filter | |
| open Filter MeasureTheory | |
| open scoped Topology ENNReal | |
| open MeasureTheory ProbabilityTheory | |
| open scoped BigOperators Topology RealInnerProductSpace | |
| open scoped BigOperators TensorProduct | |
| open scoped Topology InnerProductSpace | |
| open MeasureTheory Filter | |
| open MeasureTheory ProbabilityTheory Complex | |
| open scoped BigOperators Topology InnerProductSpace ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology NNReal | |
| namespace ParisiFinite | |
| def logMean {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) (a : ℝ) | |
| (f : Ω → ℝ) : ℝ := | |
| if a = 0 then ∫ z, f z ∂μ else Real.log (∫ z, Real.exp (a * f z) ∂μ) / a | |
| def step (a s : ℝ) (f : ℝ → ℝ) (x : ℝ) : ℝ := | |
| logMean (gaussianReal 0 1) a (fun z => f (x + s * z)) | |
| def terminal (β x : ℝ) : ℝ := Real.log (2 * Real.cosh (β * x)) / β | |
| lemma integral_exp_pos {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} | |
| [IsProbabilityMeasure μ] {f : Ω → ℝ} | |
| (hf : Integrable (fun z => Real.exp (f z)) μ) : | |
| 0 < ∫ z, Real.exp (f z) ∂μ := by | |
| apply (integral_pos_iff_support_of_nonneg (fun z => (Real.exp_pos _).le) hf).2 | |
| have h : Function.support (fun z => Real.exp (f z)) = Set.univ := by | |
| ext z | |
| simp [Function.mem_support, (Real.exp_pos (f z)).ne'] | |
| rw [h, measure_univ] | |
| exact zero_lt_one | |
| @[simp] lemma logMean_zero {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) | |
| (f : Ω → ℝ) : logMean μ 0 f = ∫ z, f z ∂μ := by simp [logMean] | |
| @[simp] lemma logMean_const {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) | |
| [IsProbabilityMeasure μ] (a c : ℝ) : logMean μ a (fun _ => c) = c := by | |
| by_cases ha : a = 0 | |
| · simp [ha, logMean] | |
| · simp [logMean, ha, Real.log_exp, mul_div_cancel_left₀ _ ha] | |
| lemma logMean_add_const {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} | |
| [IsProbabilityMeasure μ] {a : ℝ} {f : Ω → ℝ} | |
| (hf : Integrable f μ) (he : Integrable (fun z => Real.exp (a * f z)) μ) | |
| (c : ℝ) : logMean μ a (fun z => f z + c) = logMean μ a f + c := by | |
| by_cases ha : a = 0 | |
| · simp [logMean, ha, integral_add hf (integrable_const c)] | |
| · have hp := integral_exp_pos he | |
| simp only [logMean, ha, ↓reduceIte] | |
| simp_rw [mul_add, Real.exp_add] | |
| rw [integral_mul_const, Real.log_mul hp.ne' (Real.exp_pos _).ne', Real.log_exp] | |
| field_simp | |
| lemma logMean_mono {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} | |
| [IsProbabilityMeasure μ] {a : ℝ} (ha : 0 ≤ a) {f g : Ω → ℝ} | |
| (hf : Integrable f μ) (hg : Integrable g μ) | |
| (hef : Integrable (fun z => Real.exp (a * f z)) μ) | |
| (heg : Integrable (fun z => Real.exp (a * g z)) μ) | |
| (hfg : ∀ z, f z ≤ g z) : logMean μ a f ≤ logMean μ a g := by | |
| by_cases h0 : a = 0 | |
| · simp only [logMean, h0, ↓reduceIte] | |
| exact integral_mono hf hg hfg | |
| · simp only [logMean, h0, ↓reduceIte] | |
| apply div_le_div_of_nonneg_right _ ha | |
| apply Real.log_le_log (integral_exp_pos hef) | |
| exact integral_mono hef heg fun z => Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (hfg z) ha) | |
| lemma integrable_exp_abs (c : ℝ) : | |
| Integrable (fun z : ℝ => Real.exp (c * |z|)) (gaussianReal 0 1) := by | |
| apply ((integrable_exp_mul_gaussianReal c).add | |
| (integrable_exp_mul_gaussianReal (-c))).mono' | |
| (by fun_prop) | |
| filter_upwards with z | |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] | |
| rcases le_total 0 z with hz | hz | |
| · rw [abs_of_nonneg hz] | |
| exact le_add_of_nonneg_right (Real.exp_pos _).le | |
| · rw [abs_of_nonpos hz] | |
| have he : c * -z = -c * z := by ring | |
| rw [he] | |
| exact le_add_of_nonneg_left (Real.exp_pos _).le | |
| lemma shift_norm_le {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| (x s z : ℝ) : |f (x + s * z)| ≤ |f x| + (L : ℝ) * |s| * |z| := by | |
| have h := hf.dist_le_mul (x + s * z) x | |
| simp only [Real.dist_eq, add_sub_cancel_left, abs_mul] at h | |
| have htri := abs_add_le (f (x + s * z) - f x) (f x) | |
| rw [sub_add_cancel] at htri | |
| nlinarith | |
| lemma integrable_shift {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| (x s : ℝ) : Integrable (fun z => f (x + s * z)) (gaussianReal 0 1) := by | |
| have hi : Integrable (fun z : ℝ => |z|) (gaussianReal 0 1) := | |
| (MemLp.integrable (by norm_num) (memLp_id_gaussianReal (μ := 0) (v := 1) 1)).abs | |
| apply ((integrable_const |f x|).add (hi.const_mul ((L : ℝ) * |s|))).mono' | |
| (hf.continuous.comp (by fun_prop)).aestronglyMeasurable | |
| exact ae_of_all _ fun z => by simpa [Real.norm_eq_abs] using shift_norm_le hf x s z | |
| lemma integrable_exp_shift {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| (a x s : ℝ) : Integrable (fun z => Real.exp (a * f (x + s * z))) | |
| (gaussianReal 0 1) := by | |
| apply ((integrable_exp_abs (|a| * (L : ℝ) * |s|)).const_mul | |
| (Real.exp (|a| * |f x|))).mono' | |
| (Real.continuous_exp.comp ((hf.continuous.comp (show Continuous (fun z : ℝ => x + s * z) by fun_prop)).const_mul a)).aestronglyMeasurable | |
| filter_upwards with z | |
| simp only [Function.comp_apply, Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] | |
| rw [← Real.exp_add] | |
| apply Real.exp_le_exp.mpr | |
| have h := mul_le_mul_of_nonneg_left (shift_norm_le hf x s z) (abs_nonneg a) | |
| have h' : a * f (x + s * z) ≤ |a| * |f (x + s * z)| := by | |
| simpa only [abs_mul] using le_abs_self (a * f (x + s * z)) | |
| nlinarith | |
| lemma step_integrals {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| (a s x : ℝ) : | |
| Integrable (fun z => f (x + s * z)) (gaussianReal 0 1) ∧ | |
| Integrable (fun z => Real.exp (a * f (x + s * z))) (gaussianReal 0 1) ∧ | |
| 0 < ∫ z, Real.exp (a * f (x + s * z)) ∂gaussianReal 0 1 := | |
| ⟨integrable_shift hf x s, integrable_exp_shift hf a x s, | |
| integral_exp_pos (integrable_exp_shift hf a x s)⟩ | |
| lemma logMean_le_add {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} | |
| [IsProbabilityMeasure μ] {a : ℝ} (ha : 0 ≤ a) {f g : Ω → ℝ} | |
| (hf : Integrable f μ) (hg : Integrable g μ) | |
| (hef : Integrable (fun z => Real.exp (a * f z)) μ) | |
| (heg : Integrable (fun z => Real.exp (a * g z)) μ) | |
| (c : ℝ) (hfg : ∀ z, f z ≤ g z + c) : logMean μ a f ≤ logMean μ a g + c := by | |
| have hec : Integrable (fun z => Real.exp (a * (g z + c))) μ := by | |
| simpa only [mul_add, Real.exp_add] using heg.mul_const (Real.exp (a * c)) | |
| exact (logMean_mono ha hf (hg.add (integrable_const c)) hef hec hfg).trans_eq | |
| (logMean_add_const hg heg c) | |
| lemma logMean_stable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} | |
| [IsProbabilityMeasure μ] {a : ℝ} (ha : 0 ≤ a) {f g : Ω → ℝ} | |
| (hf : Integrable f μ) (hg : Integrable g μ) | |
| (hef : Integrable (fun z => Real.exp (a * f z)) μ) | |
| (heg : Integrable (fun z => Real.exp (a * g z)) μ) | |
| (c : ℝ) (hfg : ∀ z, |f z - g z| ≤ c) : | |
| |logMean μ a f - logMean μ a g| ≤ c := by | |
| rw [abs_le] | |
| constructor | |
| · have h := logMean_le_add ha hg hf heg hef c (fun z => by | |
| have hz := (abs_le.mp (hfg z)).1 | |
| linarith) | |
| linarith | |
| · have h := logMean_le_add ha hf hg hef heg c (fun z => by | |
| have hz := (abs_le.mp (hfg z)).2 | |
| linarith) | |
| linarith | |
| lemma step_lipschitz {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| {a : ℝ} (ha : 0 ≤ a) (s : ℝ) : LipschitzWith L (step a s f) := by | |
| rw [lipschitzWith_iff_norm_sub_le] | |
| intro x y | |
| simp only [Real.norm_eq_abs, step] | |
| apply logMean_stable ha (integrable_shift hf x s) (integrable_shift hf y s) | |
| (integrable_exp_shift hf a x s) (integrable_exp_shift hf a y s) | |
| intro z | |
| have h := hf.dist_le_mul (x + s * z) (y + s * z) | |
| simpa only [Real.dist_eq, add_sub_add_right_eq_sub] using h | |
| lemma hasDerivAt_terminal {β : ℝ} (hβ : 0 < β) (x : ℝ) : | |
| HasDerivAt (terminal β) (Real.tanh (β * x)) x := by | |
| have hc : HasDerivAt (fun y : ℝ => 2 * Real.cosh (β * y)) | |
| (2 * (Real.sinh (β * x) * β)) x := by | |
| simpa using ((Real.hasDerivAt_cosh (β * x)).comp x | |
| ((hasDerivAt_id x).const_mul β)).const_mul (2 : ℝ) | |
| have hh := (hc.log (mul_pos (by norm_num) (Real.cosh_pos _)).ne').div_const β | |
| have he : (2 * (Real.sinh (β * x) * β) / (2 * Real.cosh (β * x))) / β = | |
| Real.tanh (β * x) := by | |
| rw [Real.tanh_eq_sinh_div_cosh] | |
| field_simp | |
| rw [he] at hh | |
| exact hh | |
| lemma terminal_lipschitz {β : ℝ} (hβ : 0 < β) : LipschitzWith 1 (terminal β) := by | |
| apply lipschitzWith_of_nnnorm_deriv_le (fun x => (hasDerivAt_terminal hβ x).differentiableAt) | |
| intro x | |
| rw [(hasDerivAt_terminal hβ x).deriv] | |
| exact_mod_cast (Real.abs_tanh_lt_one (β * x)).le | |
| @[simp] lemma step_zero_width (a : ℝ) (f : ℝ → ℝ) (x : ℝ) : | |
| step a 0 f x = f x := by | |
| simp [step] | |
| @[simp] lemma terminal_zero (β : ℝ) : terminal β 0 = Real.log 2 / β := by | |
| simp [terminal] | |
| lemma terminal_even (β x : ℝ) : terminal β (-x) = terminal β x := by | |
| simp [terminal, mul_neg] | |
| lemma integral_exp_linear (a : ℝ) : | |
| (∫ z : ℝ, Real.exp (a * z) ∂gaussianReal 0 1) = Real.exp (a ^ 2 / 2) := by | |
| have h := mgf_gaussianReal (μ := 0) (v := 1) (X := fun z : ℝ => z) (p := gaussianReal 0 1) | |
| (by simp) a | |
| simpa [mgf] using h | |
| lemma exp_terminal {β : ℝ} (hβ : 0 < β) (x : ℝ) : | |
| Real.exp (β * terminal β x) = 2 * Real.cosh (β * x) := by | |
| unfold terminal | |
| have he : β * (Real.log (2 * Real.cosh (β * x)) / β) = | |
| Real.log (2 * Real.cosh (β * x)) := by field_simp | |
| rw [he, Real.exp_log (mul_pos (by norm_num) (Real.cosh_pos _))] | |
| lemma exp_terminal_shift {β : ℝ} (hβ : 0 < β) (x s z : ℝ) : | |
| Real.exp (β * terminal β (x + s * z)) = | |
| Real.exp (β * x) * Real.exp ((β * s) * z) + | |
| Real.exp (-(β * x)) * Real.exp ((-(β * s)) * z) := by | |
| rw [exp_terminal hβ, Real.cosh_eq] | |
| have h₁ : β * (x + s * z) = β * x + (β * s) * z := by ring | |
| have h₂ : -(β * (x + s * z)) = -(β * x) + (-(β * s)) * z := by ring | |
| rw [h₂, h₁, Real.exp_add, Real.exp_add] | |
| ring | |
| lemma integral_exp_terminal {β : ℝ} (hβ : 0 < β) (x s : ℝ) : | |
| (∫ z, Real.exp (β * terminal β (x + s * z)) ∂gaussianReal 0 1) = | |
| (2 * Real.cosh (β * x)) * Real.exp ((β * s) ^ 2 / 2) := by | |
| simp_rw [exp_terminal_shift hβ] | |
| rw [integral_add ((integrable_exp_mul_gaussianReal (β * s)).const_mul _) | |
| ((integrable_exp_mul_gaussianReal (-(β * s))).const_mul _)] | |
| rw [integral_const_mul, integral_const_mul, integral_exp_linear, integral_exp_linear] | |
| rw [neg_sq, Real.cosh_eq] | |
| ring | |
| lemma step_terminal {β : ℝ} (hβ : 0 < β) (s x : ℝ) : | |
| step β s (terminal β) x = terminal β x + β * s ^ 2 / 2 := by | |
| unfold step logMean | |
| rw [ite_eq_right hβ.ne', integral_exp_terminal hβ, | |
| Real.log_mul (mul_pos (by norm_num) (Real.cosh_pos _)).ne' (Real.exp_pos _).ne', | |
| Real.log_exp] | |
| unfold terminal | |
| field_simp | |
| abbrev Schedule := List (ℝ≥0 × ℝ≥0) | |
| def recursion (β : ℝ) : Schedule → ℝ → ℝ | |
| | [] => terminal β | |
| | (a, d) :: ls => step a (Real.sqrt d) (recursion β ls) | |
| def penalty (t : ℝ) : Schedule → ℝ | |
| | [] => 0 | |
| | (a, d) :: ls => a * ((t + d) ^ 2 - t ^ 2) / 4 + penalty (t + d) ls | |
| def width (ls : Schedule) : ℝ := (ls.map (fun l => (l.2 : ℝ))).sum | |
| def Admissible (β : ℝ) (ls : Schedule) : Prop := | |
| width ls = 1 ∧ ls.Pairwise (fun a b => a.1 ≤ b.1) ∧ ∀ l ∈ ls, (l.1 : ℝ) ≤ β | |
| def functional (β : ℝ) (ls : Schedule) : ℝ := recursion β ls 0 - penalty 0 ls | |
| lemma recursion_lipschitz {β : ℝ} (hβ : 0 < β) (ls : Schedule) : | |
| LipschitzWith 1 (recursion β ls) := by | |
| induction ls with | |
| | nil => exact terminal_lipschitz hβ | |
| | cons l ls ih => exact step_lipschitz ih l.1.coe_nonneg _ | |
| lemma recursion_integrals {β : ℝ} (hβ : 0 < β) (ls : Schedule) (a s x : ℝ) : | |
| Integrable (fun z => recursion β ls (x + s * z)) (gaussianReal 0 1) ∧ | |
| Integrable (fun z => Real.exp (a * recursion β ls (x + s * z))) (gaussianReal 0 1) ∧ | |
| 0 < ∫ z, Real.exp (a * recursion β ls (x + s * z)) ∂gaussianReal 0 1 := | |
| step_integrals (recursion_lipschitz hβ ls) a s x | |
| end ParisiFinite | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators NNReal Topology | |
| namespace ParisiFinite | |
| lemma step_add_const {L : ℝ≥0} {f : ℝ → ℝ} (hf : LipschitzWith L f) | |
| (a s c x : ℝ) : step a s (fun y => f y + c) x = step a s f x + c := | |
| logMean_add_const (integrable_shift hf x s) (integrable_exp_shift hf a x s) c | |
| lemma step_mean (s : ℝ) (f : ℝ → ℝ) (x : ℝ) : | |
| step 0 s f x = ∫ z, f (x + s * z) ∂gaussianReal 0 1 := by simp [step] | |
| def replicaSymmetricSchedule (β : ℝ≥0) (q : ℝ≥0) : Schedule := | |
| [(0, q), (β, 1 - q)] | |
| lemma replicaSymmetric_admissible (β q : ℝ≥0) (hq : q ≤ 1) : | |
| Admissible β (replicaSymmetricSchedule β q) := by | |
| simp [Admissible, replicaSymmetricSchedule, width, NNReal.coe_sub hq] | |
| lemma replicaSymmetric_recursion {β : ℝ≥0} (hβ : 0 < β) (q : ℝ≥0) (hq : q ≤ 1) (x : ℝ) : | |
| recursion β (replicaSymmetricSchedule β q) x = | |
| step 0 (Real.sqrt q) (terminal β) x + β * (1 - q) / 2 := by | |
| have hβ' : (0 : ℝ) < β := hβ | |
| have htail : (fun y => step (β : ℝ) (Real.sqrt (↑(1-q) : ℝ)) (terminal β) y) = | |
| fun y => terminal β y + (β : ℝ) * (1 - q) / 2 := by | |
| funext y | |
| rw [step_terminal hβ', Real.sq_sqrt (NNReal.coe_nonneg _), NNReal.coe_sub hq] | |
| norm_num | |
| change step 0 (Real.sqrt q) (fun y => step (β : ℝ) | |
| (Real.sqrt (↑(1 - q) : ℝ)) (terminal β) y) x = _ | |
| rw [htail, step_add_const (terminal_lipschitz hβ')] | |
| lemma replicaSymmetric_penalty (β q : ℝ≥0) (hq : q ≤ 1) : | |
| penalty 0 (replicaSymmetricSchedule β q) = β * (1 - (q : ℝ)^2) / 4 := by | |
| simp [replicaSymmetricSchedule, penalty, NNReal.coe_sub hq] | |
| lemma replicaSymmetric_functional {β : ℝ≥0} (hβ : 0 < β) (q : ℝ≥0) (hq : q ≤ 1) : | |
| functional β (replicaSymmetricSchedule β q) = | |
| (∫ z : ℝ, terminal β (Real.sqrt q * z) ∂gaussianReal 0 1) + | |
| β * (1 - (q : ℝ)) ^ 2 / 4 := by | |
| rw [functional, replicaSymmetric_recursion hβ q hq, replicaSymmetric_penalty β q hq, | |
| step_mean] | |
| simp only [zero_add] | |
| ring | |
| end ParisiFinite | |
| open MeasureTheory ProbabilityTheory | |
| open scoped BigOperators NNReal | |
| namespace ParisiInterpolation | |
| open SKGaussian SKQAOA | |
| variable {κ : Type*} [Fintype κ] | |
| lemma memLp_coordinate (k : κ) : | |
| MemLp (fun x : κ → ℝ => x k) 2 (gaussianLaw κ) := by | |
| exact (memLp_id_gaussianReal (μ := 0) (v := 1) 2).comp_measurePreserving | |
| (measurePreserving_eval (fun _ : κ => gaussianReal 0 1) k) | |
| lemma covariance_coordinate [DecidableEq κ] (i j : κ) : | |
| covariance (fun x : κ → ℝ => x i) (fun x => x j) (gaussianLaw κ) = | |
| if i = j then 1 else 0 := by | |
| classical | |
| by_cases hij : i = j | |
| · subst j | |
| rw [ite_eq_left rfl] | |
| have hm := measurePreserving_eval (fun _ : κ => gaussianReal 0 1) i | |
| have h := covariance_map (X := id) (Y := id) (Z := fun x : κ → ℝ => x i) | |
| measurable_id.aestronglyMeasurable measurable_id.aestronglyMeasurable | |
| hm.aemeasurable | |
| rw [hm.map_eq] at h | |
| calc | |
| _ = covariance id id (gaussianReal 0 1) := h.symm | |
| _ = 1 := by | |
| rw [covariance_self measurable_id.aemeasurable, variance_id_gaussianReal] | |
| rfl | |
| · rw [ite_eq_right hij] | |
| have hi : iIndepFun (fun i (x : κ → ℝ) => x i) (gaussianLaw κ) := | |
| iIndepFun_pi (X := fun _ : κ => id) (fun _ => measurable_id.aemeasurable) | |
| exact (hi.indepFun hij).covariance_eq_zero (memLp_coordinate i) (memLp_coordinate j) | |
| lemma covariance_field {ι : Type*} (A : ι → κ → ℝ) (i j : ι) : | |
| covariance (fun x => field A x i) (fun x => field A x j) (gaussianLaw κ) = | |
| ∑ k, A i k * A j k := by | |
| classical | |
| have hm (i : ι) (k : κ) : MemLp (fun x : κ → ℝ => A i k * x k) 2 (gaussianLaw κ) := | |
| (memLp_coordinate k).const_mul (A i k) | |
| have hf (i : ι) : (fun x => field A x i) = ∑ k, fun x => A i k * x k := by | |
| ext x | |
| simp [field] | |
| have hsum (i : ι) : MemLp (∑ k, fun x : κ → ℝ => A i k * x k) 2 (gaussianLaw κ) := by | |
| rw [← hf i] | |
| exact memLp_finsetSum Finset.univ (fun k _ => hm i k) | |
| rw [hf i, hf j, covariance_sum_left (hm i) (hsum j)] | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| rw [covariance_sum_right (hm j) (hm i k)] | |
| simp_rw [covariance_const_mul_left, covariance_const_mul_right, covariance_coordinate] | |
| simp | |
| lemma hamiltonian_covariance {n : ℕ} (hn : 0 < n) (σ τ : Configuration n) : | |
| covariance (fun J => hamiltonian n J σ) (fun J => hamiltonian n J τ) | |
| (disorderLaw n) = (overlapSum σ τ ^ 2 - (n : ℝ)) / (2 * (n : ℝ)) := by | |
| have h := covariance_field (skCoeff n) σ τ | |
| simp_rw [field_skCoeff] at h | |
| exact h.trans (coeff_covariance hn σ τ) | |
| def overlap {n : ℕ} (σ τ : Configuration n) : ℝ := overlapSum σ τ / n | |
| lemma normalized_hamiltonian_covariance {n : ℕ} (hn : 0 < n) (σ τ : Configuration n) : | |
| covariance (fun J => hamiltonian n J σ) (fun J => hamiltonian n J τ) | |
| (disorderLaw n) / n = (overlap σ τ ^ 2 - 1 / (n : ℝ)) / 2 := by | |
| rw [hamiltonian_covariance hn] | |
| unfold overlap | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn.ne' | |
| field_simp | |
| end ParisiInterpolation | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology NNReal | |
| namespace ParisiInterpolation | |
| open SKGaussian | |
| variable {ι κ : Type*} [Fintype ι] [Nonempty ι] [Fintype κ] | |
| def rotate (A B : ι → κ → ℝ) (t : ℝ) (i : ι) (k : κ) : ℝ := | |
| Real.cos t * A i k + Real.sin t * B i k | |
| def increment (A : ι → κ → ℝ) (i j : ι) : ℝ := | |
| ∑ k, (A i k - A j k) ^ 2 | |
| def expected (A : ι → κ → ℝ) : ℝ := | |
| ∫ x, logPartition (field A x) ∂gaussianLaw κ | |
| lemma hasDerivAt_expected_rotate (A B : ι → κ → ℝ) | |
| (hAB : ∀ i j, ∑ k, A i k * B j k = 0) (t : ℝ) : | |
| HasDerivAt (fun s => expected (rotate A B s)) | |
| (∫ x, (1 / 2 : ℝ) * ∑ i, ∑ j, | |
| weight (field (rotate A B t) x) i * weight (field (rotate A B t) x) j * | |
| (Real.sin t * Real.cos t * (increment B i j - increment A i j)) | |
| ∂gaussianLaw κ) t := by | |
| let e : Fin (Fintype.card κ) ≃ κ := (Fintype.equivFin κ).symm | |
| let A' : ι → Fin (Fintype.card κ) → ℝ := fun i k => A i (e k) | |
| let B' : ι → Fin (Fintype.card κ) → ℝ := fun i k => B i (e k) | |
| have hAB' : ∀ i j, ∑ k, A' i k * B' j k = 0 := by | |
| intro i j | |
| exact (e.sum_comp (fun k => A i k * B j k)).trans (hAB i j) | |
| have h := hasDerivAt_expected_rotated A' B' t | |
| rw [integral_weightedMean_eq_pairwise] at h | |
| simp_rw [rotated_increment_covariance A' B' hAB'] at h | |
| have hinc (C : ι → κ → ℝ) (i j : ι) : | |
| (∑ k, (C i (e k) - C j (e k)) ^ 2) = increment C i j := | |
| e.sum_comp (fun k => (C i k - C j k) ^ 2) | |
| change HasDerivAt (fun s => ∫ x, | |
| logPartition (linearField (fun i k => rotate A B s i (e k)) x) | |
| ∂standardLaw (Fintype.card κ)) _ t at h | |
| have he (s : ℝ) : (∫ x, | |
| logPartition (linearField (fun i k => rotate A B s i (e k)) x) | |
| ∂standardLaw (Fintype.card κ)) = expected (rotate A B s) := | |
| integral_reindex_field (rotate A B s) logPartition | |
| simp_rw [he] at h | |
| convert h using 1 | |
| symm | |
| change (∫ x, (1 / 2 : ℝ) * ∑ i, ∑ j, | |
| weight (linearField (fun i k => rotate A B t i (e k)) x) i * | |
| weight (linearField (fun i k => rotate A B t i (e k)) x) j * | |
| (Real.sin t * Real.cos t * | |
| ((∑ k, (B i (e k) - B j (e k)) ^ 2) - | |
| (∑ k, (A i (e k) - A j (e k)) ^ 2))) | |
| ∂standardLaw (Fintype.card κ)) = _ | |
| simp_rw [hinc] | |
| exact integral_reindex_field (rotate A B t) (fun y => | |
| (1 / 2 : ℝ) * ∑ i, ∑ j, weight y i * weight y j * | |
| (Real.sin t * Real.cos t * (increment B i j - increment A i j))) | |
| omit [Fintype ι] [Nonempty ι] in | |
| lemma continuous_field (A : ι → κ → ℝ) : Continuous (field A) := by | |
| unfold field | |
| fun_prop | |
| lemma integrable_weight_pair (A : ι → κ → ℝ) (i j : ι) : | |
| Integrable (fun x => weight (field A x) i * weight (field A x) j) (gaussianLaw κ) := by | |
| apply (integrable_const (1 : ℝ)).mono' | |
| (((continuous_weight i).comp (continuous_field A)).mul | |
| ((continuous_weight j).comp (continuous_field A))).aestronglyMeasurable | |
| filter_upwards with x | |
| simp only [Function.comp_apply, Pi.mul_apply, Real.norm_eq_abs] | |
| rw [abs_of_nonneg (mul_nonneg (weight_pos _ _).le (weight_pos _ _).le)] | |
| exact (mul_le_of_le_one_left (weight_pos _ _).le (weight_le_one _ _)).trans | |
| (weight_le_one _ _) | |
| def replicaAverage (A : ι → κ → ℝ) (K : ι → ι → ℝ) (x : κ → ℝ) : ℝ := | |
| ∑ i, ∑ j, weight (field A x) i * weight (field A x) j * K i j | |
| lemma integrable_replicaAverage (A : ι → κ → ℝ) (K : ι → ι → ℝ) : | |
| Integrable (replicaAverage A K) (gaussianLaw κ) := by | |
| apply integrable_finsetSum | |
| intro i _ | |
| exact integrable_finsetSum _ fun j _ => (integrable_weight_pair A i j).mul_const (K i j) | |
| @[simp] lemma replicaAverage_const (A : ι → κ → ℝ) (x : κ → ℝ) (c : ℝ) : | |
| replicaAverage A (fun _ _ => c) x = c := by | |
| simp only [replicaAverage, mul_assoc, ← Finset.mul_sum, ← Finset.sum_mul, sum_weight, one_mul] | |
| omit [Nonempty ι] in | |
| lemma replicaAverage_sub (A : ι → κ → ℝ) (K L : ι → ι → ℝ) (x : κ → ℝ) : | |
| replicaAverage A (fun i j => K i j - L i j) x = | |
| replicaAverage A K x - replicaAverage A L x := by | |
| simp [replicaAverage, mul_sub, Finset.sum_sub_distrib] | |
| omit [Nonempty ι] in | |
| lemma replicaAverage_const_mul (A : ι → κ → ℝ) (K : ι → ι → ℝ) (x : κ → ℝ) (c : ℝ) : | |
| replicaAverage A (fun i j => c * K i j) x = c * replicaAverage A K x := by | |
| simp only [replicaAverage, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| ring | |
| lemma replicaAverage_nonneg (A : ι → κ → ℝ) {K : ι → ι → ℝ} | |
| (hK : ∀ i j, 0 ≤ K i j) (x : κ → ℝ) : 0 ≤ replicaAverage A K x := by | |
| exact Finset.sum_nonneg fun i _ => Finset.sum_nonneg fun j _ => | |
| mul_nonneg (mul_nonneg (weight_pos _ _).le (weight_pos _ _).le) (hK i j) | |
| def replicaMean (A : ι → κ → ℝ) (K : ι → ι → ℝ) : ℝ := | |
| ∫ x, replicaAverage A K x ∂gaussianLaw κ | |
| @[simp] lemma replicaMean_const (A : ι → κ → ℝ) (c : ℝ) : | |
| replicaMean A (fun _ _ => c) = c := by | |
| simp [replicaMean] | |
| lemma replicaMean_sub (A : ι → κ → ℝ) (K L : ι → ι → ℝ) : | |
| replicaMean A (fun i j => K i j - L i j) = replicaMean A K - replicaMean A L := by | |
| simp only [replicaMean, replicaAverage_sub] | |
| exact integral_sub (integrable_replicaAverage A K) (integrable_replicaAverage A L) | |
| omit [Nonempty ι] in | |
| lemma replicaMean_const_mul (A : ι → κ → ℝ) (K : ι → ι → ℝ) (c : ℝ) : | |
| replicaMean A (fun i j => c * K i j) = c * replicaMean A K := by | |
| simp only [replicaMean, replicaAverage_const_mul, integral_const_mul] | |
| lemma replicaMean_nonneg (A : ι → κ → ℝ) {K : ι → ι → ℝ} | |
| (hK : ∀ i j, 0 ≤ K i j) : 0 ≤ replicaMean A K := | |
| integral_nonneg (replicaAverage_nonneg A hK) | |
| lemma hasDerivAt_expected_rotate_mean (A B : ι → κ → ℝ) | |
| (hAB : ∀ i j, ∑ k, A i k * B j k = 0) (t : ℝ) : | |
| HasDerivAt (fun s => expected (rotate A B s)) | |
| (Real.sin t * Real.cos t / 2 * | |
| replicaMean (rotate A B t) (fun i j => increment B i j - increment A i j)) t := by | |
| have h := hasDerivAt_expected_rotate A B hAB t | |
| convert h using 1 | |
| change _ = ∫ x, (1 / 2 : ℝ) * replicaAverage (rotate A B t) | |
| (fun i j => (Real.sin t * Real.cos t) * (increment B i j - increment A i j)) x | |
| ∂gaussianLaw κ | |
| simp only [replicaAverage_const_mul, integral_const_mul, replicaMean] | |
| ring | |
| end ParisiInterpolation | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology NNReal | |
| namespace ParisiInterpolation | |
| open SKGaussian SKQAOA | |
| def siteCoeff (n : ℕ) (β q : ℝ) (σ : Configuration n) (i : Fin n) : ℝ := | |
| β * Real.sqrt q * spin σ i | |
| def siteLift (n : ℕ) (β q : ℝ) (σ : Configuration n) : Fin n ⊕ Edge n → ℝ := | |
| Sum.elim (siteCoeff n β q σ) (fun _ => 0) | |
| def skLift (n : ℕ) (β : ℝ) (σ : Configuration n) : Fin n ⊕ Edge n → ℝ := | |
| Sum.elim (fun _ => 0) (fun e => β * skCoeff n σ e) | |
| lemma lifts_orthogonal (n : ℕ) (β q : ℝ) (σ τ : Configuration n) : | |
| (∑ k, siteLift n β q σ k * skLift n β τ k) = 0 := by | |
| simp [siteLift, skLift, Fintype.sum_sum_type] | |
| lemma spin_increment {n : ℕ} (σ τ : Configuration n) : | |
| (∑ i, (spin σ i - spin τ i) ^ 2) = 2 * (n : ℝ) - 2 * overlapSum σ τ := by | |
| have he (i : Fin n) : (spin σ i - spin τ i)^2 = 2 - 2 * (spin σ i * spin τ i) := by | |
| nlinarith [spin_sq σ i, spin_sq τ i] | |
| simp_rw [he] | |
| simp only [Finset.sum_sub_distrib, ← Finset.mul_sum] | |
| simp [overlapSum, mul_comm] | |
| lemma siteCoeff_increment {n : ℕ} {q : ℝ} (hq : 0 ≤ q) (β : ℝ) (σ τ : Configuration n) : | |
| increment (siteCoeff n β q) σ τ = β ^ 2 * q * (2 * (n : ℝ) - 2 * overlapSum σ τ) := by | |
| unfold increment siteCoeff | |
| rw [scaled_increment, spin_increment] | |
| rw [mul_pow, Real.sq_sqrt hq] | |
| lemma siteLift_increment {n : ℕ} {q : ℝ} (hq : 0 ≤ q) (β : ℝ) (σ τ : Configuration n) : | |
| increment (siteLift n β q) σ τ = β ^ 2 * q * (2 * (n : ℝ) - 2 * overlapSum σ τ) := by | |
| simpa only [increment, siteLift, Fintype.sum_sum_type, Sum.elim_inl, Sum.elim_inr, | |
| sub_self, zero_pow (by norm_num : 2 ≠ 0), Finset.sum_const_zero, add_zero] using | |
| siteCoeff_increment hq β σ τ | |
| lemma skLift_increment {n : ℕ} (hn : 0 < n) (β : ℝ) (σ τ : Configuration n) : | |
| increment (skLift n β) σ τ = β ^ 2 * ((n : ℝ) - overlapSum σ τ ^ 2 / n) := by | |
| simp only [increment, skLift, Fintype.sum_sum_type, Sum.elim_inl, Sum.elim_inr, | |
| sub_self, zero_pow (by norm_num : 2 ≠ 0), Finset.sum_const_zero, zero_add] | |
| rw [scaled_increment, coeff_increment hn] | |
| lemma interpolation_increment {n : ℕ} (hn : 0 < n) {q : ℝ} (hq : 0 ≤ q) | |
| (β : ℝ) (σ τ : Configuration n) : | |
| increment (skLift n β) σ τ - increment (siteLift n β q) σ τ = | |
| β ^ 2 * n * ((1 - q) ^ 2 - (overlap σ τ - q) ^ 2) := by | |
| rw [skLift_increment hn, siteLift_increment hq] | |
| unfold overlap | |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn.ne' | |
| field_simp | |
| ring | |
| def interpolatedPressure (n : ℕ) (β q t : ℝ) : ℝ := | |
| expected (rotate (siteLift n β q) (skLift n β) t) | |
| def remainder (n : ℕ) (β q t : ℝ) : ℝ := | |
| replicaMean (rotate (siteLift n β q) (skLift n β) t) | |
| (fun σ τ => (overlap σ τ - q) ^ 2) | |
| lemma remainder_nonneg (n : ℕ) (β q t : ℝ) : 0 ≤ remainder n β q t := | |
| replicaMean_nonneg _ (fun _ _ => sq_nonneg _) | |
| lemma hasDerivAt_interpolatedPressure {n : ℕ} (hn : 0 < n) (β : ℝ) {q : ℝ} | |
| (hq : 0 ≤ q) (t : ℝ) : | |
| HasDerivAt (interpolatedPressure n β q) | |
| (β ^ 2 * n * (Real.sin t * Real.cos t) / 2 * | |
| ((1 - q) ^ 2 - remainder n β q t)) t := by | |
| have h := hasDerivAt_expected_rotate_mean (siteLift n β q) (skLift n β) | |
| (lifts_orthogonal n β q) t | |
| simp_rw [interpolation_increment hn hq] at h | |
| rw [replicaMean_const_mul, replicaMean_sub, replicaMean_const] at h | |
| change HasDerivAt (fun s => expected (rotate (siteLift n β q) (skLift n β) s)) _ t | |
| convert h using 1 | |
| simp only [remainder] | |
| ring | |
| end ParisiInterpolation | |
| end | |
| end OAI | |