import Mathlib import OAI.Probability.ParisiFinite.InnerRootYCoordinates import OAI.Probability.ParisiFinite.Space namespace OAI /-! Joint. -/ 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 namespace GaussianFactorization open MeasureTheory ProbabilityTheory Complex CoherentFock GaussianCoherent open scoped BigOperators InnerProductSpace ComplexConjugate variable {κ E : Type*} [Fintype κ] [NormedAddCommGroup E] [InnerProductSpace ℂ E] abbrev Joint (κ E : Type*) [Fintype κ] := HilbertPair.Space (Mode κ) E abbrev Hilbert (κ E : Type*) [Fintype κ] [NormedAddCommGroup E] [InnerProductSpace ℂ E] := Lp (Space E) 2 (GaussianFourier.law κ) def wave (d : Joint κ E) (g : κ → ℝ) : Space E := GaussianCoherent.wave d.fst g • coherent d.snd theorem continuous_wave (d : Joint κ E) : Continuous (wave d) := (GaussianCoherent.continuous_wave d.fst).smul continuous_const @[simp] theorem norm_wave (d : Joint κ E) (g : κ → ℝ) : ‖wave d g‖=‖GaussianCoherent.wave d.fst g‖ := by simp [wave,norm_smul] theorem memLp_wave (d : Joint κ E) : MemLp (wave d) 2 (GaussianFourier.law κ) := (GaussianCoherent.memLp_wave d.fst).congr_norm (continuous_wave d).aestronglyMeasurable (Filter.Eventually.of_forall fun g => (norm_wave d g).symm) def vector (d : Joint κ E) : Hilbert κ E := (memLp_wave d).toLp (wave d) theorem vector_ae (d : Joint κ E) : (vector d : (κ → ℝ) → Space E)=ᵐ[GaussianFourier.law κ] wave d := MemLp.coeFn_toLp _ theorem kernel_joint (d e : Joint κ E) : kernel d e=kernel d.fst e.fst*kernel d.snd e.snd := by unfold kernel rw [←Complex.exp_add] congr 1 rw [WithLp.prod_norm_sq_eq_of_L2,WithLp.prod_norm_sq_eq_of_L2] simp only [WithLp.prod_inner_apply] change Complex.ofReal (-(‖d.fst‖^2+‖d.snd‖^2)/2)+ (⟪d.fst,e.fst⟫_ℂ+⟪d.snd,e.snd⟫_ℂ)+Complex.ofReal (-(‖e.fst‖^2+‖e.snd‖^2)/2)=_ push_cast ring @[simp] theorem inner_vector (d e : Joint κ E) : ⟪vector d,vector e⟫_ℂ=kernel d e := by rw [L2.inner_def,kernel_joint,←GaussianCoherent.integral_wave_pair,←integral_mul_const] apply integral_congr_ae filter_upwards [vector_ae d,vector_ae e] with g hd he rw [hd,he] simp only [wave,inner_smul_left,inner_smul_right,inner_coherent] ring def preMap : PreSpace (Joint κ E) →ₗᵢ[ℂ] Hilbert κ E := LinearMap.isometryOfInner ((Finsupp.linearCombination ℂ vector).comp toFinsupp.toLinearMap) (by intro x y change ⟪(toFinsupp x).sum (fun d a => a • vector d), (toFinsupp y).sum (fun e b => b • vector e)⟫_ℂ=_ rw [Finsupp.sum_inner] change (toFinsupp x).sum (fun d a => ⟪a • vector d, (toFinsupp y).sum (fun e b => b • vector e)⟫_ℂ)= (toFinsupp x).sum (fun d a => (toFinsupp y).sum (fun e b => conj a*kernel d e*b)) apply Finsupp.sum_congr intro d hd rw [Finsupp.inner_sum] apply Finsupp.sum_congr intro e he simp only [inner_smul_left,inner_smul_right,inner_vector] ring) def representation : Space (Joint κ E) →ₗᵢ[ℂ] Hilbert κ E where toLinearMap := preMap.toContinuousLinearMap.fromCompletion.toLinearMap norm_map' x := by refine UniformSpace.Completion.induction_on x (isClosed_eq (preMap.toContinuousLinearMap.fromCompletion.continuous.norm) continuous_norm) fun y => ?_ change ‖preMap.toContinuousLinearMap.fromCompletion (y:Space (Joint κ E))‖= ‖(y:Space (Joint κ E))‖ rw [ContinuousLinearMap.fromCompletion_apply_coe,UniformSpace.Completion.norm_coe] exact preMap.norm_map y @[simp] theorem representation_coherent (d : Joint κ E) : representation (coherent d)=vector d := by change preMap.toContinuousLinearMap.fromCompletion ((toFinsupp.symm (Finsupp.single d 1):PreSpace (Joint κ E)):Space (Joint κ E))=vector d rw [ContinuousLinearMap.fromCompletion_apply_coe] change Finsupp.linearCombination ℂ vector (Finsupp.single d 1)=vector d simp theorem representation_surjective : Function.Surjective (representation (κ := κ) (E := E)) := by let K := (representation (κ := κ) (E := E)).toLinearMap.range have hK : IsClosed (K : Set (Hilbert κ E)) := (representation (κ := κ) (E := E)).isometry.isClosedEmbedding.isClosed_range have hbot : Kᗮ=⊥ := by apply (Submodule.eq_bot_iff _).mpr intro f hf apply Lp.ext have hi : Integrable (fun g => f g) (GaussianFourier.law κ) := memLp_one_iff_integrable.mp ((Lp.memLp f).mono_exponent (by norm_num)) have hcoef (x : E) : (fun g => ⟪coherent x,f g⟫_ℂ)=ᵐ[GaussianFourier.law κ] 0 := by apply FourierDensity.ae_zero_of_fourier_zero (hi.const_inner (coherent x)) intro a let d : Joint κ E := WithLp.toLp 2 (realMode (-a),x) have hh := (Submodule.mem_orthogonal K f).mp hf (vector d) ⟨coherent d,representation_coherent _⟩ rw [L2.inner_def] at hh convert hh using 1 apply integral_congr_ae filter_upwards [vector_ae d] with g hg rw [hg] simp only [wave,inner_smul_left] change FourierDensity.character a g*⟪coherent x,f g⟫_ℂ= conj (GaussianCoherent.wave (realMode (-a)) g)*⟪coherent x,f g⟫_ℂ rw [wave_realMode] change FourierDensity.character a g*⟪coherent x,f g⟫_ℂ= conj (FourierDensity.character (-a) g)*⟪coherent x,f g⟫_ℂ rw [FourierDensity.character_neg,Complex.conj_conj] have hz : (fun g => f g)=ᵐ[GaussianFourier.law κ] 0 := by apply hi.ae_eq_zero_of_forall_setIntegral_eq_zero intro s hs hsm apply CoherentFock.eq_zero_of_inner_coherent intro x change (innerSL ℂ (coherent x)) (∫g in s, f g ∂GaussianFourier.law κ)=0 rw [←(innerSL ℂ (coherent x)).integral_comp_comm (hi.integrableOn (s := s))] change (∫g in s, ⟪coherent x,f g⟫_ℂ ∂GaussianFourier.law κ)=0 rw [integral_congr_ae (ae_restrict_of_ae (hcoef x))] simp exact hz.trans (Lp.coeFn_zero (Space E) 2 (GaussianFourier.law κ)).symm apply LinearMap.range_eq_top.mp change K=⊤ calc K=K.topologicalClosure := hK.submodule_topologicalClosure_eq.symm _=Kᗮᗮ := (Submodule.orthogonal_orthogonal_eq_closure K).symm _=⊤ := by rw [hbot,Submodule.bot_orthogonal_eq_top] def jointGaussianUnitary : Space (Joint κ E) ≃ₗᵢ[ℂ] Hilbert κ E := LinearIsometryEquiv.ofSurjective representation representation_surjective @[simp] theorem jointGaussianUnitary_coherent (d : Joint κ E) : jointGaussianUnitary (coherent d)=vector d := representation_coherent d end GaussianFactorization namespace GaussianFactorization open MeasureTheory ProbabilityTheory Complex CoherentFock GaussianCoherent open scoped BigOperators InnerProductSpace ComplexConjugate variable {κ E : Type*} [Fintype κ] [NormedAddCommGroup E] [InnerProductSpace ℂ E] theorem memLp_seedPhase (a : κ → ℝ) (f : Hilbert κ E) : MemLp (fun g => GaussianCoherent.wave (realMode a) g • f g) 2 (GaussianFourier.law κ) := by apply (Lp.memLp f).congr_norm ((GaussianCoherent.continuous_wave (realMode a)).aestronglyMeasurable.smul (Lp.aestronglyMeasurable f)) exact Filter.Eventually.of_forall fun g => by change ‖f g‖=‖GaussianCoherent.wave (realMode a) g • f g‖ rw [norm_smul,norm_wave_realMode,one_mul] def seedPhase (a : κ → ℝ) (f : Hilbert κ E) : Hilbert κ E := (memLp_seedPhase a f).toLp (fun g => GaussianCoherent.wave (realMode a) g • f g) theorem seedPhase_ae (a : κ → ℝ) (f : Hilbert κ E) : (seedPhase a f : (κ → ℝ) → Space E)=ᵐ[GaussianFourier.law κ] fun g => GaussianCoherent.wave (realMode a) g • f g := MemLp.coeFn_toLp _ def seedPhaseIsometry (a : κ → ℝ) : Hilbert κ E →ₗᵢ[ℂ] Hilbert κ E where toFun := seedPhase a map_add' f h := by apply Lp.ext filter_upwards [seedPhase_ae a (f+h),Lp.coeFn_add f h, Lp.coeFn_add (seedPhase a f) (seedPhase a h),seedPhase_ae a f,seedPhase_ae a h] with g h1 h2 h3 h4 h5 rw [h1,h2,h3] simp only [Pi.add_apply,h4,h5,smul_add] map_smul' c f := by change seedPhase a (c • f)=c • seedPhase a f apply Lp.ext filter_upwards [seedPhase_ae a (c • f),Lp.coeFn_smul c f, Lp.coeFn_smul c (seedPhase a f),seedPhase_ae a f] with g h1 h2 h3 h4 rw [h1,h2,h3] simp only [Pi.smul_apply,h4] exact smul_comm _ _ _ norm_map' f := by have hh : ∀ᵐ g ∂GaussianFourier.law κ, ‖seedPhase a f g‖=‖f g‖ := by filter_upwards [seedPhase_ae a f] with g hg rw [hg,norm_smul,norm_wave_realMode,one_mul] exact le_antisymm (Lp.norm_le_norm_of_ae_le (hh.mono fun _ h => h.le)) (Lp.norm_le_norm_of_ae_le (hh.mono fun _ h => h.ge)) @[simp] theorem phase_inl (a : Mode κ) (d : Joint κ E) : phase (HilbertPair.inl a) d=phase a d.fst := by simp [phase,HilbertPair.inl_apply,WithLp.prod_inner_apply] @[simp] theorem phase_inr (e : E) (d : Joint κ E) : phase (HilbertPair.inr e) d=phase e d.snd := by simp [phase,HilbertPair.inr_apply,WithLp.prod_inner_apply] theorem seedPhase_vector (a : κ → ℝ) (d : Joint κ E) : seedPhaseIsometry a (vector d)= phase (HilbertPair.inl (realMode a)) d • vector (HilbertPair.inl (realMode a)+d) := by apply Lp.ext filter_upwards [seedPhase_ae a (vector d),vector_ae d,vector_ae (HilbertPair.inl (realMode a)+d), Lp.coeFn_smul (phase (HilbertPair.inl (realMode a)) d) (vector (HilbertPair.inl (realMode a)+d))] with g h1 h2 h3 h4 change seedPhase a (vector d) g = _ rw [h1,h2,h4] change GaussianCoherent.wave (realMode a) g • wave d g = phase (HilbertPair.inl (realMode a)) d • vector (HilbertPair.inl (realMode a)+d) g rw [h3,phase_inl] change GaussianCoherent.wave (realMode a) g • (GaussianCoherent.wave d.fst g • coherent d.snd)= phase (realMode a) d.fst • (GaussianCoherent.wave (realMode a+d.fst) g • coherent (0+d.snd)) rw [zero_add,smul_smul,smul_smul,phase_wave_real_add] theorem representation_W_external (a : κ → ℝ) (x : Space (Joint κ E)) : representation (W (HilbertPair.inl (realMode a)) x)= seedPhaseIsometry a (representation x) := by have he : (representation (E:=E)).toContinuousLinearMap.comp (W (HilbertPair.inl (realMode a)))= (seedPhaseIsometry a).toContinuousLinearMap.comp representation.toContinuousLinearMap := by apply CoherentFock.ext_coherent intro d simp only [ContinuousLinearMap.comp_apply,LinearIsometry.coe_toContinuousLinearMap, W_coherent,map_smul,representation_coherent,seedPhase_vector] exact DFunLike.congr_fun he x theorem endogenous_vector (e : E) (d : Joint κ E) : (W e).compLpL 2 (GaussianFourier.law κ) (vector d)= phase (HilbertPair.inr e) d • vector (HilbertPair.inr e+d) := by apply Lp.ext filter_upwards [(W e).coeFn_compLpL (vector d),vector_ae d, vector_ae (HilbertPair.inr e+d),Lp.coeFn_smul (phase (HilbertPair.inr e) d) (vector (HilbertPair.inr e+d))] with g h1 h2 h3 h4 rw [h1,h2,h4] change W e (wave d g)=phase (HilbertPair.inr e) d • vector (HilbertPair.inr e+d) g rw [h3,phase_inr] change W e (GaussianCoherent.wave d.fst g • coherent d.snd)= phase e d.snd • (GaussianCoherent.wave (0+d.fst) g • coherent (e+d.snd)) rw [zero_add,map_smul,W_coherent] exact smul_comm _ _ _ theorem representation_W_endogenous (e : E) (x : Space (Joint κ E)) : representation (W (HilbertPair.inr e) x)= (W e).compLpL 2 (GaussianFourier.law κ) (representation x) := by have he : representation.toContinuousLinearMap.comp (W (HilbertPair.inr e : Joint κ E))= ((W e).compLpL 2 (GaussianFourier.law κ)).comp representation.toContinuousLinearMap := by apply CoherentFock.ext_coherent intro d simp only [ContinuousLinearMap.comp_apply,LinearIsometry.coe_toContinuousLinearMap, W_coherent,map_smul,representation_coherent,endogenous_vector] exact DFunLike.congr_fun he x end GaussianFactorization open scoped BigOperators Topology InnerProductSpace open Filter namespace QuantumCLT variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A] [NormOneClass A] [CompleteSpace A] theorem exp_remainder_bound (x : A) (n : ℕ) : ‖NormedSpace.exp x-∑ k ∈ Finset.range n, ((k.factorial:ℂ)⁻¹) • x^k‖ ≤ ‖x‖^n * Real.exp ‖x‖ := by have hs := NormedSpace.exp_series_hasSum_exp' (𝕂 := ℂ) x have hn := NormedSpace.norm_expSeries_summable' (𝕂 := ℂ) x have ht : NormedSpace.exp x-∑ k ∈ Finset.range n, ((k.factorial:ℂ)⁻¹) • x^k= ∑' k : ℕ, (((k+n).factorial:ℂ)⁻¹) • x^(k+n) := by rw [← hs.tsum_eq,← hs.summable.sum_add_tsum_nat_add n] abel rw [ht] have hb : HasSum (fun k : ℕ => ‖x‖^n * (‖x‖^k/(k.factorial:ℝ))) (‖x‖^n*Real.exp ‖x‖) := by simpa [smul_eq_mul,div_eq_mul_inv,mul_comm,← Real.exp_eq_exp_ℝ] using (NormedSpace.exp_series_hasSum_exp' (𝕂 := ℝ) ‖x‖).mul_left (‖x‖^n) calc _ ≤ ∑' k : ℕ, ‖(((k+n).factorial:ℂ)⁻¹) • x^(k+n)‖ := norm_tsum_le_tsum_norm ((summable_nat_add_iff n).mpr hn) _ ≤ ∑' k : ℕ, ‖x‖^n * (‖x‖^k/(k.factorial:ℝ)) := by apply Summable.tsum_le_tsum _ ((summable_nat_add_iff n).mpr hn) hb.summable intro k rw [norm_smul, norm_inv,Complex.norm_natCast] calc _ ≤ ((k+n).factorial:ℝ)⁻¹*(‖x‖^(k+n)) := by gcongr exact norm_pow_le x (k+n) _ ≤ (k.factorial:ℝ)⁻¹*(‖x‖^(k+n)) := by gcongr exact Nat.le_add_right k n _ = _ := by rw [pow_add]; ring _ = _ := hb.tsum_eq theorem norm_exp_le (x : A) : ‖NormedSpace.exp x‖ ≤ Real.exp ‖x‖ := by simpa using exp_remainder_bound x 0 theorem exp_second_bound (X : A) (r L : ℝ) (hL : 0 ≤ L) (hX : ‖X‖ ≤ L) (hr : |r| ≤ 1) : ‖NormedSpace.exp ((r:ℂ) • X)-1-(r:ℂ) • X-((r^2/2:ℝ):ℂ) • X^2‖ ≤ (L^3*Real.exp L)*|r|^3 := by have h := exp_remainder_bound ((r:ℂ) • X) 3 have he : (∑ k ∈ Finset.range 3, ((k.factorial:ℂ)⁻¹) • ((r:ℂ) • X)^k)= 1+(r:ℂ) • X+((r^2/2:ℝ):ℂ) • X^2 := by simp [Finset.sum_range_succ,smul_pow] module rw [he] at h have hn : ‖(r:ℂ) • X‖ ≤ L := by rw [norm_smul,Complex.norm_real,Real.norm_eq_abs] exact (mul_le_mul_of_nonneg_left hX (abs_nonneg r)).trans (by nlinarith) calc _ = ‖NormedSpace.exp ((r:ℂ) • X)-(1+(r:ℂ) • X+((r^2/2:ℝ):ℂ) • X^2)‖ := by congr 1; abel _ ≤ ‖(r:ℂ) • X‖^3*Real.exp ‖(r:ℂ) • X‖ := h _ ≤ (|r| * L)^3*Real.exp L := by gcongr · simpa only [norm_smul,Complex.norm_real,Real.norm_eq_abs] using mul_le_mul_of_nonneg_left hX (abs_nonneg r) _ = _ := by ring omit [NormOneClass A] [CompleteSpace A] in theorem product_second_bound (f g a b c d : A) (r C D K : ℝ) (hC : 0 ≤ C) (_hD : 0 ≤ D) (hK : 0 ≤ K) (hr : |r| ≤ 1) (hf : ‖f-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ ≤ C*|r|^3) (hg : ‖g-1-(r:ℂ) • c-((r:ℂ)^2) • d‖ ≤ D*|r|^3) (hnf : ‖f‖ ≤ K) : ‖f*g-1-(r:ℂ) • (a+c)-((r:ℂ)^2) • (b+d+a*c)‖ ≤ (C+(‖b‖+C)*‖c‖+(‖a‖+‖b‖+C)*‖d‖+K*D)*|r|^3 := by have hp : |r|^3 ≤ |r|^2 := by nlinarith [sq_nonneg |r|] have h2 : ‖f-1-(r:ℂ) • a‖ ≤ (‖b‖+C)*|r|^2 := by calc _ = ‖(f-1-(r:ℂ) • a-((r:ℂ)^2) • b)+((r:ℂ)^2) • b‖ := by congr 1; abel _ ≤ ‖f-1-(r:ℂ) • a-((r:ℂ)^2) • b‖+‖((r:ℂ)^2) • b‖ := norm_add_le _ _ _ ≤ C*|r|^3+|r|^2*‖b‖ := by rw [norm_smul,Complex.norm_pow,Complex.norm_real,Real.norm_eq_abs] exact add_le_add hf le_rfl _ ≤ C*|r|^2+|r|^2*‖b‖ := by gcongr _ = _ := by ring have hp' : |r|^2 ≤ |r| := by nlinarith [abs_nonneg r] have h1 : ‖f-1‖ ≤ (‖a‖+‖b‖+C)*|r| := by calc _ = ‖(f-1-(r:ℂ) • a)+(r:ℂ) • a‖ := by congr 1; abel _ ≤ ‖f-1-(r:ℂ) • a‖+‖(r:ℂ) • a‖ := norm_add_le _ _ _ ≤ (‖b‖+C)*|r|^2+|r| *‖a‖ := by simpa only [norm_smul,Complex.norm_real,Real.norm_eq_abs] using add_le_add h2 (le_refl ‖(r:ℂ) • a‖) _ ≤ (‖b‖+C)*|r|+|r| *‖a‖ := by gcongr _ = _ := by ring have he : f*g-1-(r:ℂ) • (a+c)-((r:ℂ)^2) • (b+d+a*c)= (f-1-(r:ℂ) • a-((r:ℂ)^2) • b)+ (r:ℂ) • ((f-1-(r:ℂ) • a)*c)+ ((r:ℂ)^2) • ((f-1)*d)+ f*(g-1-(r:ℂ) • c-((r:ℂ)^2) • d) := by simp only [mul_sub,sub_mul,one_mul,mul_one,mul_smul_comm,smul_mul_assoc] module rw [he] calc _ ≤ ‖f-1-(r:ℂ) • a-((r:ℂ)^2) • b‖+ ‖(r:ℂ) • ((f-1-(r:ℂ) • a)*c)‖+ ‖((r:ℂ)^2) • ((f-1)*d)‖+ ‖f*(g-1-(r:ℂ) • c-((r:ℂ)^2) • d)‖ := (norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)) le_rfl) _ ≤ C*|r|^3+|r| *((‖b‖+C)*|r|^2*‖c‖)+ |r|^2*((‖a‖+‖b‖+C)*|r| *‖d‖)+K*(D*|r|^3) := by simp only [norm_smul,Complex.norm_pow,Complex.norm_real,Real.norm_eq_abs] exact add_le_add (add_le_add (add_le_add hf (mul_le_mul_of_nonneg_left ((norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right h2 (norm_nonneg _))) (abs_nonneg r))) (mul_le_mul_of_nonneg_left ((norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right h1 (norm_nonneg _))) (sq_nonneg |r|))) ((norm_mul_le _ _).trans (mul_le_mul hnf hg (norm_nonneg _) hK)) _ = _ := by ring def HasSecond (f : ℝ → A) (a b : A) : Prop := ∃ C : ℝ, 0 ≤ C ∧ ∀ r : ℝ, |r| ≤ 1 → ‖f r-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ ≤ C*|r|^3 omit [CompleteSpace A] in theorem jet_norm_bound {f : ℝ → A} {a b : A} {C : ℝ} (hC : 0 ≤ C) (hf : ∀ r : ℝ, |r| ≤ 1 → ‖f r-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ ≤ C*|r|^3) {r : ℝ} (hr : |r| ≤ 1) : ‖f r‖ ≤ 1+‖a‖+‖b‖+C := by have he : f r=1+(r:ℂ) • a+((r:ℂ)^2) • b+ (f r-1-(r:ℂ) • a-((r:ℂ)^2) • b) := by abel calc ‖f r‖ ≤ ‖1+(r:ℂ) • a+((r:ℂ)^2) • b‖+ ‖f r-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ := by nth_rw 1 [he]; exact norm_add_le _ _ _ ≤ ‖1+(r:ℂ) • a+((r:ℂ)^2) • b‖+C*|r|^3 := add_le_add le_rfl (hf r hr) _ ≤ (‖(1:A)‖+‖(r:ℂ) • a‖+‖((r:ℂ)^2) • b‖)+C*|r|^3 := by exact add_le_add ((norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)) le_rfl _ ≤ _ := by simp only [norm_one,norm_smul,Complex.norm_pow,Complex.norm_real,Real.norm_eq_abs] have h2 : |r|^2 ≤ 1 := by nlinarith [abs_nonneg r] have h3 : |r|^3 ≤ 1 := (pow_le_pow_left₀ (abs_nonneg r) hr 3).trans (by norm_num) nlinarith [norm_nonneg a,norm_nonneg b,mul_le_mul_of_nonneg_right hr (norm_nonneg a), mul_le_mul_of_nonneg_right h2 (norm_nonneg b),mul_le_mul_of_nonneg_left h3 hC] omit [CompleteSpace A] in theorem HasSecond.mul {f g : ℝ → A} {a b c d : A} (hf : HasSecond f a b) (hg : HasSecond g c d) : HasSecond (fun r => f r*g r) (a+c) (b+d+a*c) := by obtain ⟨C,hC,hf⟩ := hf obtain ⟨D,hD,hg⟩ := hg let K := 1+‖a‖+‖b‖+C have hK : 0 ≤ K := by dsimp [K]; positivity refine ⟨C+(‖b‖+C)*‖c‖+(‖a‖+‖b‖+C)*‖d‖+K*D,by positivity,fun r hr => ?_⟩ exact product_second_bound _ _ _ _ _ _ r C D K hC hD hK hr (hf r hr) (hg r hr) (jet_norm_bound hC hf hr) theorem exp_hasSecond (X : A) : HasSecond (fun r : ℝ => NormedSpace.exp ((r:ℂ) • X)) X ((2:ℂ)⁻¹ • X^2) := by refine ⟨‖X‖^3*Real.exp ‖X‖,by positivity,fun r hr => ?_⟩ have he : ((r:ℂ)^2) • ((2:ℂ)⁻¹ • X^2)=((r^2/2:ℝ):ℂ) • X^2 := by rw [smul_smul] congr 1 push_cast ring rw [he] exact exp_second_bound X r ‖X‖ (norm_nonneg _) le_rfl hr def generators (xs : List A) (r : ℝ) : A := (xs.map fun X => NormedSpace.exp ((r:ℂ) • X)).prod def second : List A → A | [] => 0 | X::xs => (2:ℂ)⁻¹ • X^2+second xs+X*xs.sum theorem generators_hasSecond (xs : List A) : HasSecond (generators xs) xs.sum (second xs) := by induction xs with | nil => refine ⟨0,le_rfl,?_⟩; intro r hr; simp [generators,second] | cons X xs ih => change HasSecond (fun r => NormedSpace.exp ((r:ℂ) • X)*generators xs r) (X+xs.sum) ((2:ℂ)⁻¹ • X^2+second xs+X*xs.sum) exact HasSecond.mul (exp_hasSecond X) ih omit [NormOneClass A] [CompleteSpace A] in theorem HasSecond.matrixElement {f : ℝ → A} {a b : A} (hf : HasSecond f a b) (φ : A →L[ℂ] ℂ) (hφ : φ 1=1) (hc : φ a=0) : ∃ C : ℝ, 0 ≤ C ∧ ∀ r : ℝ, |r| ≤ 1 → ‖φ (f r)-1-(r:ℂ)^2*φ b‖ ≤ C*|r|^3 := by obtain ⟨C,hC,hf⟩ := hf refine ⟨‖φ‖*C,by positivity,fun r hr => ?_⟩ calc _ = ‖φ (f r-1-(r:ℂ) • a-((r:ℂ)^2) • b)‖ := by simp [hφ,hc] _ ≤ ‖φ‖*‖f r-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ := φ.le_opNorm _ _ ≤ _ := by simpa [mul_assoc] using mul_le_mul_of_nonneg_left (hf r hr) (norm_nonneg φ) theorem scalar_scaled_limit (f : ℕ → ℂ) (b : ℕ → ℂ) (c : ℂ) (hb : Tendsto b atTop (𝓝 c)) (C : ℝ) (_hC : 0 ≤ C) (hf : ∀ n : ℕ, 0 < n → ‖f n-1-(n:ℂ)⁻¹*b n‖ ≤ C*(Real.sqrt (n:ℝ))⁻¹^3) : Tendsto (fun n : ℕ => (n:ℂ)*(f n-1)) atTop (𝓝 c) := by have hs : Tendsto (fun n : ℕ => (Real.sqrt (n:ℝ))⁻¹) atTop (𝓝 0) := tendsto_inv_atTop_zero.comp (Real.tendsto_sqrt_atTop.comp tendsto_natCast_atTop_atTop) have herror : Tendsto (fun n : ℕ => (n:ℂ)*(f n-1)-b n) atTop (𝓝 0) := by apply tendsto_iff_norm_sub_tendsto_zero.mpr simp only [sub_zero] apply squeeze_zero' (Eventually.of_forall (fun _ => norm_nonneg _)) _ (by simpa using hs.const_mul C) filter_upwards [Filter.eventually_gt_atTop (0:ℕ)] with n hn have hnR : 0 < (n:ℝ) := by exact_mod_cast hn have hnC : (n:ℂ) ≠ 0 := by exact_mod_cast hn.ne' have hsq := Real.sq_sqrt hnR.le have hsn : Real.sqrt (n:ℝ) ≠ 0 := (Real.sqrt_pos.mpr hnR).ne' calc _ = ‖(n:ℂ)*(f n-1-(n:ℂ)⁻¹*b n)‖ := by congr 1; field_simp _ = (n:ℝ)*‖f n-1-(n:ℂ)⁻¹*b n‖ := by rw [norm_mul,Complex.norm_natCast] _ ≤ (n:ℝ)*(C*(Real.sqrt (n:ℝ))⁻¹^3) := mul_le_mul_of_nonneg_left (hf n hn) hnR.le _ = C*(Real.sqrt (n:ℝ))⁻¹ := by nth_rw 1 [← hsq]; field_simp [hsn] have ht : Tendsto (fun n : ℕ => (n:ℂ)*(f n-1)) atTop (𝓝 c) := by convert herror.add hb using 1 <;> simp exact ht theorem scalar_power_limit (f : ℕ → ℂ) (b : ℕ → ℂ) (c : ℂ) (hb : Tendsto b atTop (𝓝 c)) (C : ℝ) (_hC : 0 ≤ C) (hf : ∀ n : ℕ, 0 < n → ‖f n-1-(n:ℂ)⁻¹*b n‖ ≤ C*(Real.sqrt (n:ℝ))⁻¹^3) : Tendsto (fun n => f n^n) atTop (𝓝 (Complex.exp c)) := by have ht := scalar_scaled_limit f b c hb C _hC hf simpa using Complex.tendsto_one_add_pow_exp_of_tendsto ht theorem generators_vacuum_limit (xs : List A) (φ : A →L[ℂ] ℂ) (hφ : φ 1=1) (hc : φ xs.sum=0) : Tendsto (fun n : ℕ => (φ (generators xs (Real.sqrt (n:ℝ))⁻¹))^n) atTop (𝓝 (Complex.exp (φ (second xs)))) := by obtain ⟨C,hC,hf⟩ := (generators_hasSecond xs).matrixElement φ hφ hc apply scalar_power_limit _ (fun _ => φ (second xs)) _ tendsto_const_nhds C hC intro n hn have hnR : (1:ℝ) ≤ n := by exact_mod_cast hn have hr : |(Real.sqrt (n:ℝ))⁻¹| ≤ 1 := by rw [abs_of_nonneg (by positivity)] exact inv_le_one_of_one_le₀ ((Real.le_sqrt (by norm_num) (by positivity)).mpr (by simpa using hnR)) have hsq : (((Real.sqrt (n:ℝ))⁻¹:ℝ):ℂ)^2=(n:ℂ)⁻¹ := by rw [← Complex.ofReal_pow,inv_pow,Real.sq_sqrt (by positivity),Complex.ofReal_inv,Complex.ofReal_natCast] simpa only [hsq,abs_of_nonneg (by positivity : 0 ≤ (Real.sqrt (n:ℝ))⁻¹)] using hf _ hr end QuantumCLT namespace QuantumCLT open scoped BigOperators Topology open Filter variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A] [NormOneClass A] [CompleteSpace A] def JetBound (L : ℝ) (f : ℝ → A) (a b : A) : Prop := ‖a‖ ≤ L ∧ ‖b‖ ≤ L ∧ ∀r : ℝ, |r| ≤ 1 → ‖f r-1-(r:ℂ) • a-((r:ℂ)^2) • b‖ ≤ L*|r|^3 omit [CompleteSpace A] in theorem JetBound.mul {L K : ℝ} (hL : 0 ≤ L) (hK : 0 ≤ K) {f g : ℝ → A} {a b c d : A} (hf : JetBound L f a b) (hg : JetBound K g c d) : JetBound (L+K+8*L*K) (fun r => f r*g r) (a+c) (b+d+a*c) := by refine ⟨?_,?_,?_⟩ · calc ‖a+c‖ ≤ ‖a‖+‖c‖ := norm_add_le _ _ _ ≤ L+K := add_le_add hf.1 hg.1 _ ≤ L+K+8*L*K := le_add_of_nonneg_right (by positivity) · calc ‖b+d+a*c‖ ≤ ‖b‖+‖d‖+‖a‖*‖c‖ := (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) (norm_mul_le _ _)) _ ≤ L+K+L*K := by gcongr; exact hf.2.1; exact hg.2.1; exact hf.1; exact hg.1 _ ≤ L+K+8*L*K := by nlinarith [mul_nonneg hL hK] · intro r hr have hnorm : ‖f r‖ ≤ 1+3*L := by exact (jet_norm_bound hL hf.2.2 hr).trans (by linarith [hf.1,hf.2.1]) have hh := product_second_bound (f r) (g r) a b c d r L K (1+3*L) hL hK (by positivity) hr (hf.2.2 r hr) (hg.2.2 r hr) hnorm apply hh.trans apply mul_le_mul_of_nonneg_right _ (by positivity) calc L+(‖b‖+L)*‖c‖+(‖a‖+‖b‖+L)*‖d‖+(1+3*L)*K ≤ L+(L+L)*K+(L+L+L)*K+(1+3*L)*K := by gcongr <;> first | exact hf.1 | exact hf.2.1 | exact hg.1 | exact hg.2.1 _ = L+K+8*L*K := by ring def exponentialBound (L : ℝ) : ℝ := L+L^2+L^3*Real.exp L theorem exponentialBound_nonneg {L : ℝ} (hL : 0 ≤ L) : 0 ≤ exponentialBound L := by unfold exponentialBound positivity theorem exp_jetBound (X : A) {L : ℝ} (hL : 0 ≤ L) (hX : ‖X‖ ≤ L) : JetBound (exponentialBound L) (fun r : ℝ => NormedSpace.exp ((r:ℂ) • X)) X ((2:ℂ)⁻¹ • X^2) := by refine ⟨?_,?_,?_⟩ · exact hX.trans (by unfold exponentialBound; nlinarith [sq_nonneg L,mul_nonneg (pow_nonneg hL 3) (Real.exp_pos L).le]) · calc ‖(2:ℂ)⁻¹ • X^2‖ = (2:ℝ)⁻¹*‖X^2‖ := by simp [norm_smul] _ ≤ (2:ℝ)⁻¹*L^2 := by apply mul_le_mul_of_nonneg_left _ (by positivity) exact (norm_pow_le _ _).trans (pow_le_pow_left₀ (norm_nonneg _) hX _) _ ≤ exponentialBound L := by unfold exponentialBound nlinarith [mul_nonneg (pow_nonneg hL 3) (Real.exp_pos L).le] · intro r hr have he : ((r:ℂ)^2) • ((2:ℂ)⁻¹ • X^2)=((r^2/2:ℝ):ℂ) • X^2 := by rw [smul_smul] congr 1 push_cast ring rw [he] exact (exp_second_bound X r L hL hX hr).trans (mul_le_mul_of_nonneg_right (by unfold exponentialBound; nlinarith [sq_nonneg L]) (by positivity)) def orderedBound (L : ℝ) : ℕ → ℝ | 0 => 0 | n+1 => exponentialBound L+orderedBound L n+8*exponentialBound L*orderedBound L n theorem orderedBound_nonneg {L : ℝ} (hL : 0 ≤ L) (n : ℕ) : 0 ≤ orderedBound L n := by induction n with | zero => rfl | succ n ih => dsimp [orderedBound] have := exponentialBound_nonneg hL positivity theorem generators_jetBound (xs : List A) {L : ℝ} (hL : 0 ≤ L) (hxs : ∀ X ∈ xs, ‖X‖ ≤ L) : JetBound (orderedBound L xs.length) (generators xs) xs.sum (second xs) := by induction xs with | nil => refine ⟨by simp [orderedBound],by simp [second,orderedBound],?_⟩; intro r hr; simp [generators,second,orderedBound] | cons X xs ih => apply (exp_jetBound X hL (hxs X (by simp))).mul (exponentialBound_nonneg hL) (orderedBound_nonneg hL xs.length) (ih (fun Y hY => hxs Y (by simp [hY]))) theorem moving_generators_vacuum_limit {ι : Type*} (A : ℕ → Type*) [∀n, NormedRing (A n)] [∀n, NormedAlgebra ℂ (A n)] [∀n, NormOneClass (A n)] [∀n, CompleteSpace (A n)] (l : List ι) (X : ∀n, ι → A n) (φ : ∀n, A n →L[ℂ] ℂ) (L K : ℝ) (hL : 0 ≤ L) (hK : 0 ≤ K) (hX : ∀n i, i ∈ l → ‖X n i‖ ≤ L) (hφ : ∀n, ‖φ n‖ ≤ K) (h1 : ∀n, φ n 1=1) (hc : ∀n, φ n (l.map (X n)).sum=0) {z : ℂ} (hz : Tendsto (fun n => φ n (second (l.map (X n)))) atTop (𝓝 z)) : Tendsto (fun n : ℕ => (φ n (generators (l.map (X n)) (Real.sqrt (n:ℝ))⁻¹))^n) atTop (𝓝 (Complex.exp z)) := by apply scalar_power_limit _ (fun n => φ n (second (l.map (X n)))) z hz (K*orderedBound L l.length) (mul_nonneg hK (orderedBound_nonneg hL _)) intro n hn have hj := generators_jetBound (l.map (X n)) hL (by intro Y hY obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hY exact hX n i hi) simp only [List.length_map] at hj have hnR : (1:ℝ) ≤ n := by exact_mod_cast hn have hr : |(Real.sqrt (n:ℝ))⁻¹| ≤ 1 := by rw [abs_of_nonneg (by positivity)] exact inv_le_one_of_one_le₀ ((Real.le_sqrt (by norm_num) (by positivity)).mpr (by simpa using hnR)) have hsq : (((Real.sqrt (n:ℝ))⁻¹:ℝ):ℂ)^2=(n:ℂ)⁻¹ := by rw [←Complex.ofReal_pow,inv_pow,Real.sq_sqrt (by positivity),Complex.ofReal_inv,Complex.ofReal_natCast] let r := (Real.sqrt (n:ℝ))⁻¹ calc _ = ‖φ n (generators (l.map (X n)) r-1-(r:ℂ) • (l.map (X n)).sum- ((r:ℂ)^2) • second (l.map (X n)))‖ := by simp only [map_sub,map_smul,h1,hc,smul_eq_mul,mul_zero,sub_zero] dsimp only [r] rw [hsq] _ ≤ ‖φ n‖*‖generators (l.map (X n)) r-1-(r:ℂ) • (l.map (X n)).sum- ((r:ℂ)^2) • second (l.map (X n))‖ := (φ n).le_opNorm _ _ ≤ K*(orderedBound L l.length*|r|^3) := mul_le_mul (hφ n) (hj.2.2 r hr) (norm_nonneg _) hK _ = K*orderedBound L l.length*(Real.sqrt (n:ℝ))⁻¹^3 := by dsimp [r] rw [abs_of_nonneg (by positivity)] ring end QuantumCLT end end OAI