Download data/lean/OAI/RepresentationTheory/VertexAlgebra/ApproximatingFlowDerivative.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 27.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/ApproximatingFlowDerivative.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/VertexAlgebra/ApproximatingFlowDerivative.lean
-
curl -L -o ApproximatingFlowDerivative.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/ApproximatingFlowDerivative.lean
27.6 kB
| import Mathlib | |
| import OAI.RepresentationTheory.VertexAlgebra.BoundedFlows | |
| namespace OAI | |
| /-! Vertex algebra, energy bounds and closed smeared-field operators. -/ | |
| noncomputable section | |
| open scoped Topology | |
| open Filter | |
| open Filter MeasureTheory | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma approximatingFlow_derivative (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (n : β) (t : β) (x : H) : | |
| HasDerivAt (fun s : β => approximatingFlow T hs n s x) | |
| (approximatingFlow T hs n t (Complex.I β’ boundedGenerator T hs (sampleRadius n) (sampleRadius_ge n) x)) t := by | |
| exact BoundedFlow.flow_derivative _ t x | |
| lemma approximatingFlow_continuous (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (n : β) (x : H) : Continuous (fun t : β => approximatingFlow T hs n t x) := | |
| continuous_iff_continuousAt.mpr (fun t => (approximatingFlow_derivative T hs n t x).continuousAt) | |
| lemma approximatingFlow_derivative_limit (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (t : β) {x y : H} (hxy : (x,y) β T.graph) : | |
| Tendsto (fun n : β => approximatingFlow T hs n t | |
| (Complex.I β’ boundedGenerator T hs (sampleRadius n) (sampleRadius_ge n) x)) | |
| atTop (π (flow T hs t (Complex.I β’ y))) := by | |
| have hz : Tendsto (fun n : β => approximatingFlow T hs n t | |
| (Complex.I β’ (boundedGenerator T hs (sampleRadius n) (sampleRadius_ge n) x-y))) atTop (π 0) := by | |
| apply squeeze_zero_norm (a := fun n : β => βboundedGenerator T hs (sampleRadius n) (sampleRadius_ge n) x-yβ) | |
| Β· intro n | |
| rw [approximatingFlow_norm,norm_smul,Complex.norm_I,one_mul] | |
| Β· simpa only [sub_self,norm_zero] using ((boundedGenerator_strong T hs hxy).sub_const y).norm | |
| have h := hz.add (flow_tendsto T hs t (Complex.I β’ y)) | |
| simpa only [smul_sub,map_sub,sub_add_cancel,zero_add] using h | |
| lemma flow_integral (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| {x y : H} (hxy : (x,y) β T.graph) (t : β) : | |
| (β« s in 0..t, flow T hs s (Complex.I β’ y)) = flow T hs t x-x := by | |
| let F (n : β) (s : β) := approximatingFlow T hs n s | |
| (Complex.I β’ boundedGenerator T hs (sampleRadius n) (sampleRadius_ge n) x) | |
| have hc (n : β) : Continuous (F n) := approximatingFlow_continuous T hs n _ | |
| have hb (n : β) (s : β) : βF n sβ β€ βyβ := by | |
| dsimp [F] | |
| rw [approximatingFlow_norm,norm_smul,Complex.norm_I,one_mul, | |
| regularizer_on_graph T hs _ _ hxy] | |
| simpa only [one_mul] using (regularizer T hs (sampleRadius n) (sampleRadius_ge n)).le_of_opNorm_le | |
| (regularizer_norm_le T hs _ _) y | |
| have hi := StrongLimit.intervalIntegral_tendsto hc hb | |
| (fun s => approximatingFlow_derivative_limit T hs s hxy) 0 t | |
| have he (n : β) : (β« s in 0..t, F n s) = approximatingFlow T hs n t x-x := by | |
| have h := intervalIntegral.integral_eq_sub_of_hasDerivAt | |
| (fun s _ => approximatingFlow_derivative T hs n s x) ((hc n).intervalIntegrable 0 t) | |
| simpa only [F,approximatingFlow,BoundedFlow.flow_zero,one_apply_eq_self] using h | |
| simp_rw [he] at hi | |
| exact tendsto_nhds_unique hi ((flow_tendsto T hs t x).sub_const x) | |
| lemma flow_derivative (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| {x y : H} (hxy : (x,y) β T.graph) (t : β) : | |
| HasDerivAt (fun s : β => flow T hs s x) (flow T hs t (Complex.I β’ y)) t := by | |
| have hc := flow_continuous T hs (Complex.I β’ y) | |
| have he : (fun s : β => flow T hs s x) = | |
| (fun s : β => x+β« r in 0..s, flow T hs r (Complex.I β’ y)) := by | |
| funext s | |
| rw [flow_integral T hs hxy s] | |
| abel | |
| rw [he] | |
| exact (intervalIntegral.integral_hasDerivAt_right (hc.intervalIntegrable 0 t) | |
| (hc.stronglyMeasurableAtFilter volume (π t)) hc.continuousAt).const_add x | |
| end StronglyRationalVOA.SymmetricOperator | |
| open scoped Topology | |
| open Filter | |
| namespace StronglyRationalVOA.StrongLimit | |
| variable {H : Type*} [NormedAddCommGroup H] [NormedSpace β H] | |
| lemma apply_tendsto {ΞΉ : Type*} {l : Filter ΞΉ} (F : ΞΉ β H βL[β] H) (A : H βL[β] H) | |
| {C : β} (hF : β n, βF nβ β€ C) | |
| (hf : β x, Tendsto (fun n => F n x) l (π (A x))) | |
| {v : ΞΉ β H} {x : H} (hv : Tendsto v l (π x)) : | |
| Tendsto (fun n => F n (v n)) l (π (A x)) := by | |
| have hz : Tendsto (fun n => F n (v n-x)) l (π 0) := by | |
| apply squeeze_zero_norm (a := fun n => C*βv n-xβ) | |
| Β· exact fun n => (F n).le_of_opNorm_le (hF n) _ | |
| Β· simpa only [sub_self,norm_zero,mul_zero] using | |
| (tendsto_const_nhds.mul (hv.sub_const x).norm) | |
| have h := hz.add (hf x) | |
| simpa only [map_sub,sub_add_cancel,zero_add] using h | |
| lemma hasDerivAt_apply {F : β β H βL[β] H} {g : β β H} {g' z' : H} {t C : β} | |
| (hF : β s, βF sβ β€ C) (hc : β x, ContinuousAt (fun s => F s x) t) | |
| (hg : HasDerivAt g g' t) (hz : HasDerivAt (fun s => F s (g t)) z' t) : | |
| HasDerivAt (fun s => F s (g s)) (F t g'+z') t := by | |
| rw [hasDerivAt_iff_tendsto_slope] at hg hz β’ | |
| have ha := apply_tendsto F (F t) hF (fun x => (hc x).tendsto.mono_left nhdsWithin_le_nhds) hg | |
| have h := ha.add hz | |
| convert h using 1 | |
| funext s | |
| simp only [slope, vsub_eq_sub] | |
| rw [show F s ((s-t)β»ΒΉ β’ (g s-g t)) = (s-t)β»ΒΉ β’ F s (g s-g t) from | |
| (F s |>.restrictScalars β).map_smul _ _] | |
| rw [map_sub] | |
| module | |
| end StronglyRationalVOA.StrongLimit | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [NormedSpace β H] | |
| lemma norm_le_exp_of_derivative_bound {f f' : β β H} {C : β} | |
| (hf : β t, HasDerivAt f (f' t) t) (hb : β t, βf' tβ β€ C*βf tβ) (t : β) : | |
| βf tβ β€ βf 0β*Real.exp (C*|t|) := by | |
| have hp {f f' : β β H} (hf : β t, HasDerivAt f (f' t) t) | |
| (hb : β t, βf' tβ β€ C*βf tβ) {t : β} (ht : 0 β€ t) : | |
| βf tβ β€ βf 0β*Real.exp (C*t) := by | |
| have hc : Continuous f := continuous_iff_continuousAt.mpr (fun s => (hf s).continuousAt) | |
| have h := norm_le_gronwallBound_of_norm_deriv_right_le (K := C) (Ξ΅ := 0) hc.continuousOn | |
| (fun s _ => (hf s).hasDerivWithinAt) (le_refl βf 0β) | |
| (fun s _ => by simpa only [add_zero] using hb s) t (show t β Set.Icc 0 t from β¨ht,le_rflβ©) | |
| simpa only [gronwallBound_Ξ΅0,sub_zero] using h | |
| by_cases ht : 0 β€ t | |
| Β· simpa only [abs_of_nonneg ht] using hp hf hb ht | |
| Β· have hn : 0 β€ -t := by linarith | |
| have hd (s : β) : HasDerivAt (fun r => f (-r)) (-f' (-s)) s := by | |
| simpa only [neg_one_smul, Function.comp_def] using (hf (-s)).scomp s (hasDerivAt_neg s) | |
| have hb' (s : β) : β-f' (-s)β β€ C*βf (-s)β := by simpa only [norm_neg] using hb (-s) | |
| simpa only [neg_neg,neg_zero,abs_of_neg (lt_of_not_ge ht)] using hp hd hb' hn | |
| end StronglyRationalVOA.SymmetricOperator | |
| open scoped Topology | |
| open Filter | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma flow_opNorm (T : H ββ.[β] H) (hs : IsSelfAdjoint T) (t : β) : | |
| βflow T hs tβ β€ 1 := by | |
| apply (flow T hs t).opNorm_le_bound zero_le_one | |
| intro x | |
| simp only [flow_norm,one_mul,le_refl] | |
| lemma flow_adjoint (T : H ββ.[β] H) (hs : IsSelfAdjoint T) (t : β) : | |
| (flow T hs t).adjoint = flow T hs (-t) := by | |
| have hi := ContinuousLinearMap.norm_map_iff_adjoint_comp_self (flow T hs t) |>.mp (flow_norm T hs t) | |
| have hi' : (flow T hs t).adjoint * flow T hs t = 1 := hi | |
| calc | |
| (flow T hs t).adjoint = (flow T hs t).adjoint * (flow T hs t*flow T hs (-t)) := by | |
| rw [β flow_add,add_neg_cancel,flow_zero,mul_one] | |
| _ = flow T hs (-t) := by rw [β mul_assoc,hi',one_mul] | |
| lemma regularizer_flow_bound (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (S E F : H βL[β] H) (hS : IsSelfAdjoint S) | |
| (hg : β x, (S x,E x) β T.graph) (hdef : E-E.adjoint = S.comp F) | |
| (t : β) (x : H) : | |
| βS (flow T hs t x)β β€ Real.exp (βFβ*|t|)*βS xβ := by | |
| have hSa : S.adjoint = S := hS | |
| have hd : S.comp F = -(F.adjoint.comp S) := by | |
| have ha := congrArg ContinuousLinearMap.adjoint hdef | |
| rw [map_sub,ContinuousLinearMap.adjoint_adjoint,ContinuousLinearMap.adjoint_comp,hSa] at ha | |
| rw [β ha,β hdef] | |
| abel | |
| have hx (x y : H) (hxy : (x,y) β T.graph) : | |
| βS (flow T hs t x)β β€ Real.exp (βFβ*|t|)*βS xβ := by | |
| let q (s : β) := flow T hs (-s) (S (flow T hs s x)) | |
| let dq (s : β) := Complex.I β’ flow T hs (-s) (F.adjoint (S (flow T hs s x))) | |
| have hder (s : β) : HasDerivAt q (dq s) s := by | |
| have hg' := (S.hasFDerivAt.restrictScalars β).comp_hasDerivAt s (flow_derivative T hs hxy s) | |
| have hz : HasDerivAt (fun r : β => flow T hs (-r) (S (flow T hs s x))) | |
| (-(flow T hs (-s) (Complex.I β’ E (flow T hs s x)))) s := by | |
| simpa only [neg_one_smul,Function.comp_def] using | |
| (flow_derivative T hs (hg (flow T hs s x)) (-s)).scomp s (hasDerivAt_neg s) | |
| have hp := StrongLimit.hasDerivAt_apply (F := fun r => flow T hs (-r)) | |
| (fun r => flow_opNorm T hs (-r)) | |
| (fun v => ((flow_continuous T hs v).comp continuous_neg).continuousAt) hg' hz | |
| have hgxy := flow_graph T hs s hxy | |
| have he : E.adjoint (flow T hs s x) = S (flow T hs s y) := | |
| regularizer_adjoint hs.dense_domain S E hS hg (by rwa [show T.adjoint=T from hs]) | |
| have hval := congrArg (fun A : H βL[β] H => A (flow T hs s x)) hdef | |
| change E (flow T hs s x)-E.adjoint (flow T hs s x) = S (F (flow T hs s x)) at hval | |
| have hval' := congrArg (fun A : H βL[β] H => A (flow T hs s x)) hd | |
| change S (F (flow T hs s x)) = -F.adjoint (S (flow T hs s x)) at hval' | |
| have heq : S (flow T hs s y)-E (flow T hs s x) = F.adjoint (S (flow T hs s x)) := by | |
| rw [he] at hval | |
| rw [hval'] at hval | |
| simpa only [neg_sub,neg_neg] using congrArg Neg.neg hval | |
| convert hp using 1 | |
| Β· rfl | |
| Β· change Complex.I β’ flow T hs (-s) (F.adjoint (S (flow T hs s x))) = | |
| flow T hs (-s) (S (flow T hs s (Complex.I β’ y))) + | |
| -flow T hs (-s) (Complex.I β’ E (flow T hs s x)) | |
| simp only [map_smul] | |
| rw [β sub_eq_add_neg,β smul_sub,β map_sub,heq] | |
| have hb (s : β) : βdq sβ β€ βFβ*βq sβ := by | |
| dsimp only [dq,q] | |
| rw [norm_smul,Complex.norm_I,one_mul,flow_norm,flow_norm] | |
| simpa only [LinearIsometryEquiv.norm_map] using F.adjoint.le_opNorm (S (flow T hs s x)) | |
| have hb' := norm_le_exp_of_derivative_bound hder hb t | |
| dsimp only [q] at hb' | |
| simpa only [flow_norm,neg_zero,flow_zero,one_apply_eq_self,mul_comm] using hb' | |
| have hdense : DenseRange T.domain.subtype := by simpa [DenseRange] using hs.dense_domain | |
| apply hdense.induction_on (p := fun x => βS (flow T hs t x)β β€ Real.exp (βFβ*|t|)*βS xβ) | |
| Β· exact isClosed_le (S.continuous.comp (flow T hs t).continuous).norm | |
| (continuous_const.mul S.continuous.norm) | |
| Β· intro u | |
| exact hx u (T u) (T.mem_graph_iff.mpr β¨u,rfl,rflβ©) | |
| end StronglyRationalVOA.SymmetricOperator | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma flow_regularizer_factor (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (S E F : H βL[β] H) (hS : IsSelfAdjoint S) (hSd : DenseRange S) | |
| (hg : β x, (S x,E x) β T.graph) (hdef : E-E.adjoint = S.comp F) (t : β) : | |
| β B : H βL[β] H, (flow T hs t).comp S = S.comp B β§ βBβ β€ Real.exp (βFβ*|t|) := by | |
| let L := (S.comp (flow T hs (-t))).toLinearMap | |
| let Q := L.extendOfNorm S.toLinearMap | |
| have hb (x : H) : βL xβ β€ Real.exp (βFβ*|t|)*βS.toLinearMap xβ := by | |
| simpa only [L,ContinuousLinearMap.coe_coe,ContinuousLinearMap.comp_apply,abs_neg] using | |
| regularizer_flow_bound T hs S E F hS hg hdef (-t) x | |
| have hQ : Q.comp S = S.comp (flow T hs (-t)) := by | |
| ext x | |
| exact L.extendOfNorm_eq hSd β¨_,hbβ© x | |
| have hQa : S.comp Q.adjoint = (flow T hs t).comp S := by | |
| have h := congrArg ContinuousLinearMap.adjoint hQ | |
| simpa only [ContinuousLinearMap.adjoint_comp,show S.adjoint=S from hS,flow_adjoint,neg_neg] using h | |
| refine β¨Q.adjoint,hQa.symm,?_β© | |
| rw [LinearIsometryEquiv.norm_map] | |
| exact L.opNorm_extendOfNorm_le hSd (Real.exp_pos _).le hb | |
| end StronglyRationalVOA.SymmetricOperator | |
| namespace StronglyRationalVOA.HilbertScale | |
| variable {ΞΉ : Type*} {G : ΞΉ β Type*} [β i, NormedAddCommGroup (G i)] | |
| [β i, InnerProductSpace β (G i)] [DecidableEq ΞΉ] [β i, CompleteSpace (G i)] | |
| lemma inverseEnergy_dense (h : ΞΉ β β) (hh : β i, 1 β€ h i) : | |
| DenseRange (inverseEnergy (G := G) h hh) := by | |
| apply finiteCore_dense.mono | |
| intro x hx | |
| refine β¨coreDiagonal (fun i => (h i : β)) β¨x,hxβ©,?_β© | |
| rw [show coreDiagonal (fun i => (h i : β)) β¨x,hxβ© = | |
| (coreMultiplier (fun i => (h i : β)) β¨x,hxβ© : Space G) from rfl,inverseEnergy_core] | |
| exact congrArg Subtype.val (coreMultiplier_inv_cancel h hh β¨x,hxβ©) | |
| omit [DecidableEq ΞΉ] in | |
| lemma inverseEnergy_on_graph (h : ΞΉ β β) (hh : β i, 1 β€ h i) | |
| {x y : Space G} (hxy : (x,y) β (diagonal (fun i => (h i : β))).graph) : | |
| inverseEnergy h hh y = x := by | |
| obtain β¨v,hv,hyβ© := (diagonal (fun i => (h i : β))).mem_graph_iff.mp hxy | |
| dsimp only [Prod.fst,Prod.snd] at hv hy | |
| rw [β hy,inverseEnergy_diagonal,hv] | |
| lemma flow_energy_graph (T : Space G ββ.[β] Space G) (hs : IsSelfAdjoint T) | |
| (h : ΞΉ β β) (hh : β i, 1 β€ h i) (E F : Space G βL[β] Space G) | |
| (hg : β x, (inverseEnergy h hh x,E x) β T.graph) | |
| (hdef : E-E.adjoint = (inverseEnergy h hh).comp F) | |
| (t : β) {x y : Space G} (hxy : (x,y) β (diagonal (fun i => (h i : β))).graph) : | |
| β z, (SymmetricOperator.flow T hs t x,z) β (diagonal (fun i => (h i : β))).graph β§ | |
| βzβ β€ Real.exp (βFβ*|t|)*βyβ := by | |
| obtain β¨B,hB,hboundβ© := SymmetricOperator.flow_regularizer_factor T hs _ E F | |
| (inverseEnergy_selfAdjoint h hh) (inverseEnergy_dense h hh) hg hdef t | |
| refine β¨B y,?_,B.le_of_opNorm_le hbound yβ© | |
| have he := congrArg (fun A : Space G βL[β] Space G => A y) hB | |
| change SymmetricOperator.flow T hs t (inverseEnergy h hh y) = inverseEnergy h hh (B y) at he | |
| rw [inverseEnergy_on_graph h hh hxy] at he | |
| rw [he] | |
| exact inverseEnergy_graph h hh (B y) | |
| end StronglyRationalVOA.HilbertScale | |
| open UniformSpace | |
| namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| {A : CFTTypeVOA V} (U : A.UnitaryStructure) | |
| include U in | |
| lemma physicalMode_power_commutator_bound {a : V} {d p : β} (ha : a β A.grade d) | |
| {C : β} (hC : 0 β€ C) | |
| (hb : β n v, βA.physicalMode a d n vβ β€ C*(1+|(n : β)|)^p*βA.energyShift vβ) | |
| (r : β) (n : β€) (v : V) : | |
| β(A.energyShift^r) (A.physicalMode a d n v)-A.physicalMode a d n ((A.energyShift^r) v)β β€ | |
| (C*r)*(1+|(n : β)|)^(p+r)*β(A.energyShift^r) vβ := by | |
| induction r generalizing v with | |
| | zero => simp only [pow_zero,Module.End.one_apply,sub_self,norm_zero,Nat.cast_zero,mul_zero,zero_mul,le_refl] | |
| | succ r ih => | |
| have he : (A.energyShift^(r+1)) (A.physicalMode a d n v)- | |
| A.physicalMode a d n ((A.energyShift^(r+1)) v) = | |
| (-(n : β)) β’ (A.energyShift^r) (A.physicalMode a d n v)+ | |
| ((A.energyShift^r) (A.physicalMode a d n (A.energyShift v))- | |
| A.physicalMode a d n ((A.energyShift^r) (A.energyShift v))) := by | |
| have hc := congrArg (A.energyShift^r) (A.energyShift_physical_commutator ha n v) | |
| rw [map_sub,map_smul] at hc | |
| simp only [pow_succ,Module.End.mul_apply] | |
| rw [β hc] | |
| abel | |
| have hn : β-(n : β)β = |(n : β)| := by | |
| rw [norm_neg,β Complex.ofReal_intCast,Complex.norm_real,Real.norm_eq_abs] | |
| have hpower : (A.energyShift^r) (A.energyShift v) = (A.energyShift^(r+1)) v := by | |
| rw [pow_succ,Module.End.mul_apply] | |
| have hs := U.physicalMode_sobolev_bound (k := 1) ha hC (by simpa only [pow_one] using hb) r n v | |
| rw [Nat.add_comm 1 r] at hs | |
| have hbase : 1 β€ 1+|(n : β)| := by have := abs_nonneg (n : β); linarith | |
| have hbase0 : 0 β€ 1+|(n : β)| := zero_le_one.trans hbase | |
| rw [he] | |
| calc | |
| _ β€ β(-(n : β)) β’ (A.energyShift^r) (A.physicalMode a d n v)β+ | |
| β(A.energyShift^r) (A.physicalMode a d n (A.energyShift v))- | |
| A.physicalMode a d n ((A.energyShift^r) (A.energyShift v))β := norm_add_le _ _ | |
| _ β€ |(n : β)| *(C*(1+|(n : β)|)^(p+r)*β(A.energyShift^(r+1)) vβ)+ | |
| (C*r)*(1+|(n : β)|)^(p+r)*β(A.energyShift^(r+1)) vβ := by | |
| rw [norm_smul,hn] | |
| exact add_le_add (mul_le_mul_of_nonneg_left hs (abs_nonneg _)) (by simpa only [hpower] using ih (A.energyShift v)) | |
| _ β€ (1+|(n : β)|)*(C*(1+|(n : β)|)^(p+r)*β(A.energyShift^(r+1)) vβ)+ | |
| (1+|(n : β)|)*((C*r)*(1+|(n : β)|)^(p+r)*β(A.energyShift^(r+1)) vβ) := by | |
| apply add_le_add | |
| Β· gcongr; linarith | |
| Β· exact le_mul_of_one_le_left (by positivity) hbase | |
| _ = _ := by rw [Nat.cast_succ,show p+Nat.succ r=p+r+1 by omega,pow_succ]; ring | |
| include U in | |
| lemma energyShift_pow_adjoint (r : β) (x y : V) : | |
| inner β ((A.energyShift^r) x) y = inner β x ((A.energyShift^r) y) := by | |
| induction r generalizing x y with | |
| | zero => simp only [pow_zero,Module.End.one_apply] | |
| | succ r ih => | |
| rw [pow_succ,Module.End.mul_apply,ih,U.energyShift_adjoint,β Module.End.mul_apply,β pow_succ'] | |
| rfl | |
| end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| {A : CFTTypeVOA V} (U : A.UnitaryStructure) | |
| def smearedPowerCommutator {a : V} {d : β} (ha : a β A.grade d) | |
| (he : A.PolynomialEnergyBound a) {f : β€ β β} (hf : RapidCoefficients f) (r : β) : | |
| V ββ[β] Completion V := | |
| U.weightedSmearedMap ha he hf r - (A.smearedMap a d he f hf).comp (A.energyShift^r) | |
| lemma smearedPowerCommutator_apply {a : V} {d : β} (ha : a β A.grade d) | |
| (he : A.PolynomialEnergyBound a) {f : β€ β β} (hf : RapidCoefficients f) (r : β) (v : V) : | |
| U.smearedPowerCommutator ha he hf r v = | |
| β' n : β€, f n β’ (((A.energyShift^r) (A.physicalMode a d n v)- | |
| A.physicalMode a d n ((A.energyShift^r) v) : V) : Completion V) := by | |
| simp only [smearedPowerCommutator,LinearMap.sub_apply,LinearMap.comp_apply, | |
| weightedSmearedMap_apply,smearedMap_apply] | |
| rw [β (U.summable_norm_sobolevSmear ha he hf r v).of_norm.tsum_sub | |
| (A.summable_norm_physicalSmear he d hf ((A.energyShift^r) v)).of_norm] | |
| apply tsum_congr | |
| intro n | |
| change f n β’ (Completion.toComplβα΅’ : V ββα΅’[β] Completion V) _ - | |
| f n β’ (Completion.toComplβα΅’ : V ββα΅’[β] Completion V) _ = | |
| f n β’ (Completion.toComplβα΅’ : V ββα΅’[β] Completion V) (_-_) | |
| rw [map_sub,smul_sub] | |
| lemma smearedPowerCommutator_bound {a : V} {d p : β} (ha : a β A.grade d) | |
| (he : A.PolynomialEnergyBound a) {C : β} (hC : 0 β€ C) | |
| (hb : β n v, βA.physicalMode a d n vβ β€ C*(1+|(n : β)|)^p*βA.energyShift vβ) | |
| {f : β€ β β} (hf : RapidCoefficients f) (r : β) (v : V) : | |
| βU.smearedPowerCommutator ha he hf r vβ β€ | |
| ((β' n : β€, βf nβ*(1+|(n : β)|)^(p+r))*(C*r))*β(A.energyShift^r) vβ := by | |
| let D (n : β€) : V ββ[β] Completion V := | |
| (Completion.toComplβα΅’ : V ββα΅’[β] Completion V).toLinearMap.comp | |
| ((A.energyShift^r).comp (A.physicalMode a d n) - (A.physicalMode a d n).comp (A.energyShift^r)) | |
| have hd (n : β€) : βD n vβ β€ (C*r)*(1+|(n : β)|)^(p+r)*β(A.energyShift^r) vβ := by | |
| simpa only [D,LinearMap.comp_apply,LinearMap.sub_apply,LinearIsometry.coe_toLinearMap, | |
| LinearIsometry.norm_map] using U.physicalMode_power_commutator_bound ha hC hb r n v | |
| have hsum := hf.summable_norm_smul D v hd | |
| rw [U.smearedPowerCommutator_apply ha he hf r v] | |
| change ββ' n : β€, f n β’ D n vβ β€ _ | |
| apply (norm_tsum_le_tsum_norm hsum).trans | |
| calc | |
| _ β€ β' n : β€, (βf nβ*(1+|(n : β)|)^(p+r))*((C*r)*β(A.energyShift^r) vβ) := by | |
| apply Summable.tsum_le_tsum _ hsum ((hf (p+r)).mul_right _) | |
| intro n | |
| rw [norm_smul] | |
| calc | |
| _ β€ βf nβ*((C*r)*(1+|(n : β)|)^(p+r)*β(A.energyShift^r) vβ) := | |
| mul_le_mul_of_nonneg_left (hd n) (norm_nonneg _) | |
| _ = _ := by ring | |
| _ = _ := by rw [tsum_mul_right]; ring | |
| lemma weightedSmearedMap_inner {a : V} {d : β} (ha : a β A.grade d) | |
| (he : A.PolynomialEnergyBound a) {f : β€ β β} (hf : RapidCoefficients f) (r : β) (x y : V) : | |
| inner β (U.weightedSmearedMap ha he hf r x) (y : Completion V) = | |
| inner β (A.smearedMap a d he f hf x) ((A.energyShift^r) y : Completion V) := by | |
| rw [weightedSmearedMap_apply,smearedMap_apply, | |
| inner_tsum_left (U.summable_norm_sobolevSmear ha he hf r x).of_norm, | |
| inner_tsum_left (A.summable_norm_physicalSmear he d hf x).of_norm] | |
| apply tsum_congr | |
| intro n | |
| simp only [inner_smul_left,Completion.inner_coe,U.energyShift_pow_adjoint] | |
| lemma smearedPowerCommutator_pairing {a : V} {d : β} (ha : a β A.grade d) | |
| (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian d a) (he : A.PolynomialEnergyBound a) | |
| {f : β€ β β} (hf : RapidCoefficients f) (hreal : β n, star (f n) = f (-n)) | |
| (r : β) (x y : V) : | |
| inner β (A.smearedMap a d he f hf x) ((A.energyShift^r) y : Completion V)- | |
| inner β ((A.energyShift^r) x : Completion V) (A.smearedMap a d he f hf y) = | |
| inner β (U.smearedPowerCommutator ha he hf r x) (y : Completion V) := by | |
| simp only [smearedPowerCommutator,LinearMap.sub_apply,LinearMap.comp_apply,inner_sub_left] | |
| rw [U.weightedSmearedMap_inner,U.smearedMap_symmetric ha hq hh he hf hreal ((A.energyShift^r) x) y] | |
| end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| open scoped Topology | |
| open Filter MeasureTheory | |
| namespace StronglyRationalVOA.StrongLimit | |
| variable {H : Type*} [NormedAddCommGroup H] [NormedSpace β H] | |
| lemma tendsto_of_denseRange {ΞΉ E : Type*} {l : Filter ΞΉ} | |
| (S : E β H) (hSd : DenseRange S) (F : ΞΉ β H βL[β] H) (L : H βL[β] H) | |
| {C : β} (hC : 0 β€ C) (hF : βαΆ i in l, βF iβ β€ C) | |
| (hcore : β x, Tendsto (fun i => F i (S x)) l (π (L (S x)))) (x : H) : | |
| Tendsto (fun i => F i x) l (π (L x)) := by | |
| classical | |
| let G (i : ΞΉ) : H βL[β] H := if βF iβ β€ C then F i else 0 | |
| have hg : β i, βG iβ β€ C := by | |
| intro i | |
| dsimp [G] | |
| split_ifs with hi | |
| Β· exact hi | |
| Β· simpa only [norm_zero] using hC | |
| have he : βαΆ i in l, G i = F i := hF.mono fun i hi => ite_eq_left hi | |
| have hclosed := (equicontinuous_of_norm_bound G hg).isClosed_setOfPred_tendsto | |
| (l := l) L.continuous | |
| have hlim : Tendsto (fun i => G i x) l (π (L x)) := by | |
| apply hSd.induction_on (p := fun x => Tendsto (fun i => G i x) l (π (L x))) x hclosed | |
| intro v | |
| exact (hcore v).congr' (he.mono fun i hi => congrArg (fun Q : H βL[β] H => Q (S v)) hi.symm) | |
| exact hlim.congr' (he.mono fun i hi => congrArg (fun Q : H βL[β] H => Q x) hi) | |
| end StronglyRationalVOA.StrongLimit | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma selfAdjoint_injective_of_denseRange (S : H βL[β] H) | |
| (hS : IsSelfAdjoint S) (hSd : DenseRange S) : Function.Injective S := by | |
| apply S.toLinearMap.ker_eq_bot.mp | |
| apply LinearMap.ker_eq_bot'.mpr | |
| intro x hx | |
| change S x = 0 at hx | |
| apply ext_inner_left β | |
| intro y | |
| have he : β y : H, inner β y x = 0 := by | |
| intro y | |
| apply hSd.induction_on (p := fun y => inner β y x = 0) | |
| Β· exact isClosed_eq (continuous_id.inner continuous_const) continuous_const | |
| Β· intro z | |
| rw [β ContinuousLinearMap.adjoint_inner_right] | |
| change inner β z (S.adjoint x) = 0 | |
| rw [show S.adjoint = S from hS,hx,inner_zero_right] | |
| simpa only [inner_zero_right] using he y | |
| lemma regularizer_factor_continuous_zero (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (S : H βL[β] H) (hS : IsSelfAdjoint S) (hSd : DenseRange S) | |
| (B : β β H βL[β] H) (hB : β t, (flow T hs t).comp S = S.comp (B t)) | |
| {K : β} (hK : 0 β€ K) (hb : β t, βB tβ β€ Real.exp (K*|t|)) (x : H) : | |
| Tendsto (fun t => B t x) (π 0) (π x) := by | |
| have ha (t : β) : (B t).adjoint.comp S = S.comp (flow T hs (-t)) := by | |
| have h := congrArg ContinuousLinearMap.adjoint (hB t) | |
| rw [ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.adjoint_comp, | |
| show S.adjoint = S from hS,flow_adjoint] at h | |
| exact h.symm | |
| have hbound : βαΆ t in π (0 : β), β(B t).adjointβ β€ Real.exp K := by | |
| filter_upwards [Ioo_mem_nhds (show (-1 : β)<0 by norm_num) (show (0 : β)<1 by norm_num)] with t ht | |
| rw [LinearIsometryEquiv.norm_map] | |
| apply (hb t).trans | |
| apply Real.exp_le_exp.mpr | |
| have ht' : |t| β€ 1 := abs_le.mpr β¨ht.1.le,ht.2.leβ© | |
| nlinarith | |
| have hc (v : H) : Tendsto (fun t => (B t).adjoint (S v)) (π 0) (π (S v)) := by | |
| have he (t : β) : (B t).adjoint (S v) = S (flow T hs (-t) v) := | |
| congrArg (fun Q : H βL[β] H => Q v) (ha t) | |
| simp_rw [he] | |
| have h := S.continuous.continuousAt.tendsto.comp | |
| (((flow_continuous T hs v).comp continuous_neg).tendsto 0) | |
| simpa only [Function.comp_def,neg_zero,flow_zero,one_apply_eq_self] using h | |
| have hc' (v : H) : Tendsto (fun t => (B t).adjoint v) (π 0) (π v) := by | |
| exact StrongLimit.tendsto_of_denseRange S hSd (fun t => (B t).adjoint) 1 | |
| (Real.exp_pos K).le hbound (by simpa only [one_apply_eq_self] using hc) v | |
| have hip : Tendsto (fun t => (inner β (B t x) x).re) (π 0) (π (βxβ^2)) := by | |
| have h : Tendsto (fun t => inner β x ((B t).adjoint x)) (π 0) (π (inner β x x)) := | |
| tendsto_const_nhds.inner (hc' x) | |
| have h' := Complex.continuous_re.continuousAt.tendsto.comp h | |
| have heq : (inner β x x).re = βxβ^2 := by | |
| exact inner_self_eq_norm_sq (π := β) x | |
| simpa only [Function.comp_def,ContinuousLinearMap.adjoint_inner_right,heq] using h' | |
| have hupper : Tendsto (fun t : β => (Real.exp (K*|t|)*βxβ)^2+βxβ^2- | |
| 2*(inner β (B t x) x).re) (π 0) (π 0) := by | |
| have he : Tendsto (fun t : β => (Real.exp (K*|t|)*βxβ)^2) (π 0) (π (βxβ^2)) := by | |
| have hec : Continuous (fun t : β => (Real.exp (K*|t|)*βxβ)^2) := by fun_prop | |
| simpa only [abs_zero,mul_zero,Real.exp_zero,one_mul] using hec.tendsto (0 : β) | |
| have hh := (he.add_const (βxβ^2)).sub (hip.const_mul 2) | |
| have hz : βxβ^2+βxβ^2-2*βxβ^2 = 0 := by ring | |
| simpa only [hz] using hh | |
| have hsquare : Tendsto (fun t => βB t x-xβ^2) (π 0) (π 0) := by | |
| apply squeeze_zero (fun t => sq_nonneg _) _ hupper | |
| intro t | |
| rw [norm_sub_sq (π := β)] | |
| change βB t xβ^2-2*(inner β (B t x) x).re+βxβ^2 β€ _ | |
| have hn := (B t).le_of_opNorm_le (hb t) x | |
| nlinarith [norm_nonneg (B t x), show 0 β€ Real.exp (K*|t|)*βxβ by positivity] | |
| have hn : Tendsto (fun t => βB t x-xβ) (π 0) (π 0) := by | |
| have h := Real.continuous_sqrt.continuousAt.tendsto.comp hsquare | |
| simpa only [Function.comp_def,Real.sqrt_sq_eq_abs,abs_norm,Real.sqrt_zero] using h | |
| exact tendsto_iff_norm_sub_tendsto_zero.mpr hn | |
| end StronglyRationalVOA.SymmetricOperator | |
| end | |
| end OAI | |