openAI-math-dataset / lean /OAI /Probability /InvariantIsing /Arrays /NSpinTensorFrozenFluctuation.lean
| import OAI.Probability.InvariantIsing.Arrays.NSpinTensorFlatLaw | |
| import OAI.Probability.InvariantIsing.Pressure.PressureDifferenceConcentration | |
| namespace OAI | |
| /-! Transfer the actual three-disorder pressure moments to one frozen Gaussian CGF. -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory IsingPerceptron | |
| open scoped BigOperators NNReal ENNReal | |
| namespace InvariantIsing | |
| private lemma joint_map_eq_of_conditional_map_eq {Ω G E : Type*} | |
| [MeasurableSpace Ω] [MeasurableSpace G] [MeasurableSpace E] | |
| (P : Measure Ω) (Q : Measure G) [SFinite Q] | |
| (f g : Ω × G → E) (hf : Measurable f) (hg : Measurable g) | |
| (he : ∀ ω, Q.map (fun z => f (ω, z)) = Q.map (fun z => g (ω, z))) : | |
| (P.prod Q).map f = (P.prod Q).map g := by | |
| apply Measure.ext | |
| intro s hs | |
| rw [Measure.map_apply hf hs, Measure.map_apply hg hs, | |
| Measure.prod_apply (hf hs), Measure.prod_apply (hg hs)] | |
| apply lintegral_congr_ae | |
| refine ae_of_all P fun ω => ?_ | |
| have h := congrArg (fun ν : Measure E => ν s) (he ω) | |
| have hfω : Measurable (fun z => f (ω, z)) := hf.comp (measurable_const.prodMk measurable_id) | |
| have hgω : Measurable (fun z => g (ω, z)) := hg.comp (measurable_const.prodMk measurable_id) | |
| rw [Measure.map_apply hfω hs, Measure.map_apply hgω hs] at h | |
| exact h | |
| private lemma tensorNamespacedLog_conditional_law {N m k : ℕ} (eig c : Fin N → ℝ) | |
| (U : SpecialOrthogonal N) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (T : LabeledTree n) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) : | |
| gaussianCoordinates.map (fun g => tensorFlatLog eig (specialRotation U) c I degree amplitude n | |
| (tensorPathProfile I degree n treeDegree h) (T, g)) = | |
| gaussianCoordinates.map (fun g => tensorNamespacedLog eig c I degree amplitude n treeDegree h ((U, T), g)) := by | |
| let ν := labeledSpinReference n (uniformSpinPrior N : Measure (Spin N)) T | |
| let H := fun x : Spin N × LabeledLeaf n => rotatedEnergy eig (specialRotation U) x.1 + fieldEnergy c x.1 | |
| let K := fun F : Spin N × LabeledLeaf n → ℝ => Real.log (∫ x, Real.exp (H x + F x) ∂ν) | |
| have : ∀ F : (Spin N × LabeledLeaf n → ℝ), IsProbabilityMeasure ((fun _ => ν) F) := | |
| fun _ => by | |
| change IsProbabilityMeasure (labeledSpinReference n (uniformSpinPrior N : Measure (Spin N)) T) | |
| infer_instance | |
| have hE : Measurable (fun p : (Spin N × LabeledLeaf n → ℝ) × (Spin N × LabeledLeaf n) => H p.2 + p.1 p.2) := by | |
| apply measurable_from_prod_countable_left | |
| intro x | |
| have hc : Measurable (fun _ : Spin N × LabeledLeaf n → ℝ => H x) := measurable_const | |
| exact hc.add (measurable_pi_apply x) | |
| have hK : Measurable K := (measurable_random_referencePartition | |
| (ν := fun _ : Spin N × LabeledLeaf n → ℝ => ν) measurable_const hE).log | |
| let v : Fin (n + 1) → SpinTensorIndex I degree → ℝ≥0 := | |
| fun i => tensorPathProfile I degree n treeDegree h i | |
| have hleft : Measurable (fun g x => cylinderField | |
| (tensorLeafCoefficients (specialRotation U) I degree amplitude n v x) g) := | |
| Measurable.of_eval (fun _ => measurable_cylinderField _) | |
| have hright : Measurable (fun g x => cylinderField | |
| (tensorNamespacedCoefficients (specialRotation U) I degree amplitude n v x) g) := | |
| Measurable.of_eval (fun _ => measurable_cylinderField _) | |
| change gaussianCoordinates.map (K ∘ (fun g x => cylinderField | |
| (tensorLeafCoefficients (specialRotation U) I degree amplitude n v x) g)) = | |
| gaussianCoordinates.map (K ∘ (fun g x => cylinderField | |
| (tensorNamespacedCoefficients (specialRotation U) I degree amplitude n v x) g)) | |
| rw [← Measure.map_map hK hleft, ← Measure.map_map hK hright, tensorNamespacedFields_law] | |
| private lemma measurable_tensorLeafField_joint {N m k : ℕ} | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (v : Fin (n + 1) → SpinTensorIndex I degree → ℝ≥0) | |
| (x : Spin N × LabeledLeaf n) : | |
| Measurable (fun p : SpecialOrthogonal N × (ℕ → ℝ) => | |
| cylinderField (tensorLeafCoefficients (specialRotation p.1) I degree amplitude n v x) p.2) := by | |
| simp only [tensorLeafCoefficients, cylinderField_feature] | |
| apply Finset.measurable_sum | |
| intro i _ | |
| exact (((measurable_spinTensorFeature I degree amplitude x.1 i.2).comp measurable_fst).const_mul _).mul | |
| ((measurable_pi_apply (treeFeatureTag n x.2 i)).comp measurable_snd) | |
| private lemma measurable_tensorJointLog {N : ℕ} (eig c : Fin N → ℝ) (n : ℕ) | |
| (Y : (((SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) × (Spin N × LabeledLeaf n)) → ℝ) | |
| (hY : Measurable Y) : | |
| Measurable (fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| Real.log (∫ x : Spin N × LabeledLeaf n, | |
| Real.exp (rotatedEnergy eig (specialRotation p.1.1) x.1 + fieldEnergy c x.1 + Y (p, x)) | |
| ∂labeledSpinReference n (uniformSpinPrior N : Measure (Spin N)) p.1.2)) := by | |
| have hbase : Measurable (fun p : (((SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) × | |
| (Spin N × LabeledLeaf n)) => rotatedEnergy eig (specialRotation p.1.1.1) p.2.1 + fieldEnergy c p.2.1) := by | |
| apply measurable_from_prod_countable_left | |
| intro x | |
| have hr : Measurable (fun U : SpecialOrthogonal N => rotatedEnergy eig (specialRotation U) x.1) := by | |
| unfold rotatedEnergy | |
| exact (Finset.measurable_sum _ fun i _ => | |
| ((measurable_specialRotation_eval (spinVector x.1) i).pow_const 2).const_mul (eig i)).const_mul (1 / 2 : ℝ) | |
| exact (hr.comp measurable_fst.fst).add_const (fieldEnergy c x.1) | |
| let ν := fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| labeledSpinReference n (uniformSpinPrior N : Measure (Spin N)) p.1.2 | |
| have : ∀ p, IsProbabilityMeasure (ν p) := fun p => by | |
| change IsProbabilityMeasure (labeledSpinReference n (uniformSpinPrior N : Measure (Spin N)) p.1.2) | |
| infer_instance | |
| exact (measurable_random_referencePartition (ν := ν) | |
| ((measurable_labeledSpinReference_general n (uniformSpinPrior N : Measure (Spin N))).comp measurable_fst.snd) | |
| (hbase.add hY)).log | |
| lemma measurable_tensorNamespacedLog {N m k : ℕ} (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) : | |
| Measurable (tensorNamespacedLog eig c I degree amplitude n treeDegree h) := by | |
| let v : Fin (n + 1) → SpinTensorIndex I degree → ℝ≥0 := | |
| fun i => tensorPathProfile I degree n treeDegree h i | |
| have hY : Measurable (fun p : (((SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) × | |
| (Spin N × LabeledLeaf n)) => | |
| cylinderField (tensorNamespacedCoefficients (specialRotation p.1.1.1) I degree amplitude n v p.2) p.1.2) := by | |
| apply measurable_from_prod_countable_left | |
| intro x | |
| have hp : Measurable (fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| (p.1.1, p.2)) := measurable_fst.fst.prodMk measurable_snd | |
| convert (measurable_tensorNamespacedFields_joint I degree amplitude n v x).comp hp using 1 | |
| rfl | |
| exact measurable_tensorJointLog eig c n _ hY | |
| private lemma measurable_tensorJointFlatLog {N m k : ℕ} (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) : | |
| Measurable (fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| tensorFlatLog eig (specialRotation p.1.1) c I degree amplitude n | |
| (tensorPathProfile I degree n treeDegree h) (p.1.2, p.2)) := by | |
| let v : Fin (n + 1) → SpinTensorIndex I degree → ℝ≥0 := | |
| fun i => tensorPathProfile I degree n treeDegree h i | |
| have hY : Measurable (fun p : (((SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) × | |
| (Spin N × LabeledLeaf n)) => | |
| cylinderField (tensorLeafCoefficients (specialRotation p.1.1.1) I degree amplitude n v p.2) p.1.2) := by | |
| apply measurable_from_prod_countable_left | |
| intro x | |
| have hp : Measurable (fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| (p.1.1, p.2)) := measurable_fst.fst.prodMk measurable_snd | |
| convert (measurable_tensorLeafField_joint I degree amplitude n v x).comp hp using 1 | |
| rfl | |
| exact measurable_tensorJointLog eig c n _ hY | |
| def tensorNamespacedPressure {N m k : ℕ} (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) | |
| (p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) : ℝ := | |
| (N : ℝ)⁻¹ * tensorNamespacedLog eig c I degree amplitude n treeDegree h p | |
| /-- The tensor pressure has the marked-cascade pressure law, | |
| including the Haar rotation. This is a law identity, stronger than matching means. -/ | |
| theorem tensorNamespacedPressure_law {N m k : ℕ} | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) (hb : CascadeExponents n b) : | |
| HasLaw (tensorNamespacedPressure eig c I degree amplitude n treeDegree h) | |
| ((μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0))).map | |
| (tensorDisorderPressure eig c I degree amplitude n)) | |
| ((μ.prod (labeledCascadeLaw n b : Measure (LabeledTree n))).prod gaussianCoordinates) := by | |
| let P := μ.prod (labeledCascadeLaw n b : Measure (LabeledTree n)) | |
| let F := fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => | |
| tensorFlatLog eig (specialRotation p.1.1) c I degree amplitude n | |
| (tensorPathProfile I degree n treeDegree h) (p.1.2, p.2) | |
| let G := tensorNamespacedLog eig c I degree amplitude n treeDegree h | |
| have hF : Measurable F := measurable_tensorJointFlatLog eig c I degree amplitude n treeDegree h | |
| have hG : Measurable G := measurable_tensorNamespacedLog eig c I degree amplitude n treeDegree h | |
| have he : (P.prod gaussianCoordinates).map F = (P.prod gaussianCoordinates).map G := | |
| joint_map_eq_of_conditional_map_eq P gaussianCoordinates F G hF hG | |
| (fun ω => tensorNamespacedLog_conditional_law eig c ω.1 I degree amplitude n ω.2 treeDegree h) | |
| let S := fun x : ℝ => (N : ℝ)⁻¹ * x | |
| have hS : Measurable S := measurable_id.const_mul _ | |
| have hes : (P.prod gaussianCoordinates).map (S ∘ F) = (P.prod gaussianCoordinates).map (S ∘ G) := by | |
| rw [← Measure.map_map hS hF, ← Measure.map_map hS hG, he] | |
| have hactual := (hasLaw_map (measurable_tensorDisorderPressure eig c I degree amplitude n).aemeasurable).comp | |
| (tensorFlatToDisorder_measurePreserving μ I degree n b (tensorPathProfile I degree n treeDegree h)).hasLaw | |
| have hflat := hactual.congr (tensorFlatPressure_eq_disorder_ae μ eig c I degree amplitude n b | |
| (tensorPathProfile I degree n treeDegree h) hb) | |
| refine ⟨(hG.const_mul (N : ℝ)⁻¹).aemeasurable, ?_⟩ | |
| exact hes.symm.trans hflat.map_eq | |
| /-- Transport both the second moment and the exact variance and mean. -/ | |
| theorem tensorNamespacedPressure_moments {N m k : ℕ} | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) (hb : CascadeExponents n b) | |
| (hF : MemLp (tensorDisorderPressure eig c I degree amplitude n) 2 | |
| (μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)))) : | |
| let Q := (μ.prod (labeledCascadeLaw n b : Measure (LabeledTree n))).prod gaussianCoordinates | |
| let R := μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)) | |
| let F := tensorNamespacedPressure eig c I degree amplitude n treeDegree h | |
| MemLp F 2 Q ∧ variance F Q = variance (tensorDisorderPressure eig c I degree amplitude n) R ∧ | |
| (∫ p, F p ∂Q) = ∫ p, tensorDisorderPressure eig c I degree amplitude n p ∂ R := by | |
| intro Q R F | |
| have hlaw := tensorNamespacedPressure_law μ eig c I degree amplitude n b treeDegree h hb | |
| have hid : MemLp id 2 (R.map (tensorDisorderPressure eig c I degree amplitude n)) := | |
| (memLp_map_measure_iff aestronglyMeasurable_id hF.aemeasurable).mpr hF | |
| refine ⟨hlaw.memLp hid, hlaw.variance_eq.trans (variance_id_map hF.aemeasurable), ?_⟩ | |
| exact hlaw.integral_eq.trans (integral_map hF.aemeasurable aestronglyMeasurable_id) | |
| /-- Freezing one Gaussian namespace preserves the pressure law at every | |
| value of that namespace's amplitude, including zero. -/ | |
| theorem tensorFrozenPressure_moments {N m k : ℕ} | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) (hb : CascadeExponents n b) | |
| (j : Fin k) (t : ℝ) | |
| (hF : MemLp (tensorDisorderPressure eig c I degree (Function.update amplitude j t) n) 2 | |
| (μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)))) : | |
| let Q := (tensorFrozenLaw μ n b j).prod gaussianCoordinates | |
| let R := μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)) | |
| let F := fun p => (N : ℝ)⁻¹ * tensorFrozenPartitionLog eig c I degree amplitude n treeDegree h j t p | |
| MemLp F 2 Q ∧ | |
| variance F Q = variance (tensorDisorderPressure eig c I degree (Function.update amplitude j t) n) R ∧ | |
| (∫ p, F p ∂Q) = ∫ p, tensorDisorderPressure eig c I degree (Function.update amplitude j t) n p ∂ R := by | |
| intro Q R F | |
| have hp := tensorFrozenInsertion_measurePreserving μ n b j | |
| have hm := tensorNamespacedPressure_moments μ eig c I degree (Function.update amplitude j t) | |
| n b treeDegree h hb hF | |
| refine ⟨hm.1.comp_measurePreserving hp, ?_, ?_⟩ | |
| · exact (hp.variance_fun_comp hm.1.aemeasurable).trans hm.2.1 | |
| · exact (hp.hasLaw.integral_comp hm.1.aestronglyMeasurable).trans hm.2.2 | |
| lemma tensorFrozenCGF_eq_scaled_difference {N m k : ℕ} (hN : 0 < N) | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) | |
| (hh : Monotone h) (h0 : 0 ≤ h 0) (j : Fin k) (t : ℝ) : | |
| tensorFrozenCGF eig c I degree amplitude n treeDegree h j t =ᵐ[ | |
| (tensorFrozenLaw μ n b j).prod gaussianCoordinates] | |
| (fun p => (N : ℝ) * | |
| ((N : ℝ)⁻¹ * tensorFrozenPartitionLog eig c I degree amplitude n treeDegree h j t p - | |
| (N : ℝ)⁻¹ * tensorFrozenPartitionLog eig c I degree amplitude n treeDegree h j 0 p)) := by | |
| filter_upwards [tensorFrozenCGF_eq_log_difference μ eig c I degree amplitude n b treeDegree h hh h0 j t] | |
| with p hp | |
| rw [hp] | |
| have hn : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.ne_of_gt hN) | |
| field_simp | |
| /-- The expected frozen CGF is the volume times the difference of the | |
| two actual all-disorder pressures. -/ | |
| theorem tensorFrozenCGF_mean {N m k : ℕ} (hN : 0 < N) | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) | |
| (hh : Monotone h) (h0 : 0 ≤ h 0) (hb : CascadeExponents n b) (j : Fin k) (t : ℝ) | |
| (hF : ∀ a : ℝ, a = t ∨ a = 0 → | |
| MemLp (tensorDisorderPressure eig c I degree (Function.update amplitude j a) n) 2 | |
| (μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)))) : | |
| let Q := (tensorFrozenLaw μ n b j).prod gaussianCoordinates | |
| let R := μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)) | |
| (∫ p, tensorFrozenCGF eig c I degree amplitude n treeDegree h j t p ∂Q) = | |
| (N : ℝ) * ((∫ p, tensorDisorderPressure eig c I degree (Function.update amplitude j t) n p ∂ R) - | |
| ∫ p, tensorDisorderPressure eig c I degree (Function.update amplitude j 0) n p ∂ R) := by | |
| intro Q R | |
| have hmt := tensorFrozenPressure_moments μ eig c I degree amplitude n b treeDegree h hb j t (hF t (Or.inl rfl)) | |
| have hmz := tensorFrozenPressure_moments μ eig c I degree amplitude n b treeDegree h hb j 0 (hF 0 (Or.inr rfl)) | |
| rw [integral_congr_ae (tensorFrozenCGF_eq_scaled_difference hN μ eig c I degree amplitude n b treeDegree h hh h0 j t), | |
| integral_const_mul, integral_sub (hmt.1.integrable (by norm_num)) (hmz.1.integrable (by norm_num)), | |
| hmt.2.2, hmz.2.2] | |
| /-- The actual full-disorder pressure variance controls the centered | |
| selected-field CGF. The two pressures may be dependent. -/ | |
| theorem tensorFrozenCGF_centered_L1_bound {N m k : ℕ} (hN : 0 < N) | |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) | |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) | |
| (n : ℕ) (b : ℕ → ℝ) (treeDegree : Fin k → ℕ) (h : ℕ → ℝ) | |
| (hh : Monotone h) (h0 : 0 ≤ h 0) (hb : CascadeExponents n b) (j : Fin k) (t B : ℝ) | |
| (hF : ∀ a : ℝ, a = t ∨ a = 0 → | |
| MemLp (tensorDisorderPressure eig c I degree (Function.update amplitude j a) n) 2 | |
| (μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0)))) | |
| (hv : ∀ a : ℝ, a = t ∨ a = 0 → | |
| variance (tensorDisorderPressure eig c I degree (Function.update amplitude j a) n) | |
| (μ.prod (tensorRootTreeLaw I degree n b | |
| (fun i => tensorPathProfile I degree n treeDegree h (i + 1)) | |
| (tensorPathProfile I degree n treeDegree h 0))) ≤ B) : | |
| let Q := (tensorFrozenLaw μ n b j).prod gaussianCoordinates | |
| let Z := tensorFrozenCGF eig c I degree amplitude n treeDegree h j t | |
| MemLp Z 2 Q ∧ (∫ p, |Z p - ∫ p', Z p' ∂Q| ∂Q) ≤ 2 * N * Real.sqrt B := by | |
| intro Q Z | |
| let F := fun a p => (N : ℝ)⁻¹ * tensorFrozenPartitionLog eig c I degree amplitude n treeDegree h j a p | |
| have ht : t = t ∨ t = 0 := Or.inl rfl | |
| have hz : (0 : ℝ) = t ∨ (0 : ℝ) = 0 := Or.inr rfl | |
| have hmt := tensorFrozenPressure_moments μ eig c I degree amplitude n b treeDegree h hb j t (hF t ht) | |
| have hmz := tensorFrozenPressure_moments μ eig c I degree amplitude n b treeDegree h hb j 0 (hF 0 hz) | |
| have he : Z =ᵐ[Q] fun p => (N : ℝ) * (F t p - F 0 p) := by | |
| exact tensorFrozenCGF_eq_scaled_difference hN μ eig c I degree amplitude n b treeDegree h hh h0 j t | |
| simpa only [abs_of_nonneg (show (0 : ℝ) ≤ N from Nat.cast_nonneg N)] using | |
| centered_scaled_difference_L1_bound Q hmt.1 hmz.1 | |
| (hmt.2.1.trans_le (hv t ht)) (hmz.2.1.trans_le (hv 0 hz)) he | |
| end InvariantIsing | |
| end | |
| end OAI | |