import Mathlib
import OAI.RepresentationTheory.VertexAlgebra.BoundedMultiplierSingle
import OAI.RepresentationTheory.VertexAlgebra.CutoffPowerControl

namespace OAI

/-! Vertex algebra, energy bounds and closed smeared-field operators. -/

universe u

noncomputable section
open scoped Topology
open Filter
namespace StronglyRationalVOA.HilbertScale
open Filter
open scoped Topology
variable {ι : Type*} {G : ι → Type u} [∀ i, NormedAddCommGroup (G i)]
  [∀ i, InnerProductSpace ℂ (G i)] [DecidableEq ι] [∀ i, CompleteSpace (G i)]
def regularized (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M : finiteCore (G := G) →ₗ[ℂ] Space G) (n : ℕ) : Space G →L[ℂ] Space G :=
  (energyExtension h M).comp (((n : ℂ)+1) • complement h hh n)

theorem regularized_core (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M : finiteCore (G := G) →ₗ[ℂ] Space G) {C : ℝ}
    (hM : ∀ x, ‖M x‖ ≤ C * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (n : ℕ) (x : finiteCore (G := G)) :
    regularized h hh M n x = M (coreMultiplier (fun i => (resolventWeight h n i : ℂ)) x) := by
  change energyExtension h M (((n : ℂ)+1) • complement h hh n x) = _
  rw [← weighted_resolvent_core h hh n x,energyExtension_weighted h hh M hM]

 
def coreOperator (M : finiteCore (G := G) →ₗ[ℂ] Space G) : Space G →ₗ.[ℂ] Space G where
  domain := finiteCore
  toFun := M

omit [∀ i, CompleteSpace (G i)] in
theorem coreOperator_formalAdjoint (M : finiteCore (G := G) →ₗ[ℂ] Space G)
    (hM : ∀ x y : finiteCore (G := G), inner ℂ (M x) (y : Space G) = inner ℂ (x : Space G) (M y)) :
    (coreOperator M).IsFormalAdjoint (coreOperator M) := hM

theorem coreOperator_closable (M : finiteCore (G := G) →ₗ[ℂ] Space G)
    (hM : ∀ x y : finiteCore (G := G), inner ℂ (M x) (y : Space G) = inner ℂ (x : Space G) (M y)) :
    (coreOperator M).IsClosable :=
  ((coreOperator M).adjoint_isClosed finiteCore_dense).isClosable.leIsClosable
    ((coreOperator_formalAdjoint M hM).le_adjoint finiteCore_dense)

 
theorem regularized_graph_closure (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M : finiteCore (G := G) →ₗ[ℂ] Space G) {C : ℝ}
    (hM : ∀ x, ‖M x‖ ≤ C * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hc : (coreOperator M).IsClosable) (n : ℕ) (x : Space G) :
    (resolvent h hh n x,regularized h hh M n x) ∈ (coreOperator M).closure.graph := by
  have hclosed : IsClosed {z : Space G |
      (resolvent h hh n z,regularized h hh M n z) ∈ (coreOperator M).closure.graph} :=
    hc.closure_isClosed.preimage ((resolvent h hh n).continuous.prodMk (regularized h hh M n).continuous)
  have hin : (finiteCore (G := G) : Set (Space G)) ⊆ {z : Space G |
      (resolvent h hh n z,regularized h hh M n z) ∈ (coreOperator M).closure.graph} := by
    intro z hz
    let v : finiteCore (G := G) := ⟨z,hz⟩
    apply LinearPMap.le_graph_of_le (coreOperator M).le_closure
    apply (coreOperator M).mem_graph_iff.mpr
    refine ⟨coreMultiplier (fun i => (resolventWeight h n i : ℂ)) v,rfl,?_⟩
    exact (regularized_core h hh M hM n v).symm
  exact closure_minimal hin hclosed (finiteCore_dense x)

end StronglyRationalVOA.HilbertScale

open scoped Topology
open Filter

namespace StronglyRationalVOA.HilbertScale
open Filter
open scoped Topology
variable {ι : Type*} {G : ι → Type u} [∀ i, NormedAddCommGroup (G i)]
  [∀ i, InnerProductSpace ℂ (G i)] [DecidableEq ι] [∀ i, CompleteSpace (G i)]

theorem weighted_resolvent_difference (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i) (n : ℕ)
    (x : finiteCore (G := G)) :
    coreDiagonal (fun i => (h i : ℂ))
      (coreMultiplier (fun i => (resolventWeight h n i : ℂ)) x) =
      ((n : ℂ)+1) • (x : Space G) -
        ((n : ℂ)+1) • (coreMultiplier (fun i => (resolventWeight h n i : ℂ)) x : Space G) := by
  rw [weighted_resolvent_core,← smul_sub]
  congr 1
  change complement h hh n x = (x : Space G)-resolvent h hh n x
  exact eq_sub_iff_add_eq.mpr ((add_comm _ _).trans (resolvent_add_complement (G := G) h hh n (x : Space G)))

 

theorem regularized_defect_pairing (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M K : finiteCore (G := G) →ₗ[ℂ] Space G) {C D : ℝ}
    (hM : ∀ x, ‖M x‖ ≤ C * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hK : ∀ x, ‖K x‖ ≤ D * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hs : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (y : Space G) = inner ℂ (x : Space G) (M y))
    (hk : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (coreDiagonal (fun i => (h i : ℂ)) y) -
        inner ℂ (coreDiagonal (fun i => (h i : ℂ)) x) (M y) = inner ℂ (K x) (y : Space G))
    (n : ℕ) (x y : finiteCore (G := G)) :
    inner ℂ (regularized h hh M n x) (y : Space G) -
      inner ℂ (x : Space G) (regularized h hh M n y) =
    inner ℂ (resolvent h hh n (energyExtension h K (complement h hh n x))) (y : Space G) := by
  let rx := coreMultiplier (fun i => (resolventWeight h n i : ℂ)) x
  let ry := coreMultiplier (fun i => (resolventWeight h n i : ℂ)) y
  let t : ℂ := (n : ℂ)+1
  have ht : t ≠ 0 := by dsimp [t]; exact_mod_cast (show n+1 ≠ 0 by omega)
  have htstar : star t = t := by simp [t]
  have htx : coreDiagonal (fun i => (h i : ℂ)) rx = t • (x : Space G)-t • (rx : Space G) :=
    weighted_resolvent_difference h hh n x
  have hty : coreDiagonal (fun i => (h i : ℂ)) ry = t • (y : Space G)-t • (ry : Space G) :=
    weighted_resolvent_difference h hh n y
  have hnormK : K rx = t • energyExtension h K (complement h hh n x) := by
    rw [← energyExtension_weighted h hh K hK rx,weighted_resolvent_core h hh n x,map_smul]
  have hR : (resolvent (G := G) h hh n).adjoint = resolvent h hh n := resolvent_selfAdjoint h hh n
  have hinner : inner ℂ (energyExtension h K (complement h hh n x)) (ry : Space G) =
      inner ℂ (resolvent h hh n (energyExtension h K (complement h hh n x))) (y : Space G) := by
    change inner ℂ _ (resolvent h hh n (y : Space G)) = _
    simpa only [hR] using (ContinuousLinearMap.adjoint_inner_left (resolvent h hh n)
      (y : Space G) (energyExtension h K (complement h hh n x))).symm
  rw [regularized_core h hh M hM n x,regularized_core h hh M hM n y]
  change inner ℂ (M rx) (y : Space G)-inner ℂ (x : Space G) (M ry) = _
  apply mul_left_cancel₀ ht
  calc
    t * (inner ℂ (M rx) (y : Space G)-inner ℂ (x : Space G) (M ry)) =
        inner ℂ (M rx) (coreDiagonal (fun i => (h i : ℂ)) ry)-
          inner ℂ (coreDiagonal (fun i => (h i : ℂ)) rx) (M ry) := by
      rw [htx,hty]
      simp only [inner_sub_right,inner_sub_left,inner_smul_right,inner_smul_left,
        starRingEnd_apply,htstar]
      rw [hs rx ry]
      ring
    _ = inner ℂ (K rx) (ry : Space G) := hk rx ry
    _ = _ := by rw [hnormK,inner_smul_left,starRingEnd_apply,htstar,hinner]

theorem regularized_defect (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M K : finiteCore (G := G) →ₗ[ℂ] Space G) {C D : ℝ}
    (hM : ∀ x, ‖M x‖ ≤ C * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hK : ∀ x, ‖K x‖ ≤ D * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hs : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (y : Space G) = inner ℂ (x : Space G) (M y))
    (hk : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (coreDiagonal (fun i => (h i : ℂ)) y) -
        inner ℂ (coreDiagonal (fun i => (h i : ℂ)) x) (M y) = inner ℂ (K x) (y : Space G))
    (n : ℕ) :
    regularized h hh M n - (regularized h hh M n).adjoint =
      (resolvent h hh n).comp ((energyExtension h K).comp (complement h hh n)) := by
  let B := regularized h hh M n
  let Q := (resolvent h hh n).comp ((energyExtension h K).comp (complement h hh n))
  have hd : DenseRange ((finiteCore (G := G)).subtype) := by simpa [DenseRange] using (finiteCore_dense (G := G))
  have hp : ∀ x y : Space G, inner ℂ (B x) y-inner ℂ x (B y) = inner ℂ (Q x) y := by
    intro x y
    refine hd.induction_on₂ ?_ ?_ x y
    · exact isClosed_eq
        (((B.continuous.comp continuous_fst).inner continuous_snd).sub
          (continuous_fst.inner (B.continuous.comp continuous_snd)))
        ((Q.continuous.comp continuous_fst).inner continuous_snd)
    · intro x y
      exact regularized_defect_pairing h hh M K hM hK hs hk n x y
  apply ContinuousLinearMap.ext
  intro x
  apply ext_inner_right ℂ
  intro y
  change inner ℂ (B x-B.adjoint x) y = inner ℂ (Q x) y
  rw [inner_sub_left,ContinuousLinearMap.adjoint_inner_left]
  exact hp x y

 

theorem coreOperator_essentialSelfAdjoint (h : ι → ℝ) (hh : ∀ i, 1 ≤ h i)
    (M K : finiteCore (G := G) →ₗ[ℂ] Space G) {C D : ℝ}
    (hM : ∀ x, ‖M x‖ ≤ C * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hK : ∀ x, ‖K x‖ ≤ D * ‖coreDiagonal (fun i => (h i : ℂ)) x‖)
    (hs : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (y : Space G) = inner ℂ (x : Space G) (M y))
    (hk : ∀ x y : finiteCore (G := G),
      inner ℂ (M x) (coreDiagonal (fun i => (h i : ℂ)) y) -
        inner ℂ (coreDiagonal (fun i => (h i : ℂ)) x) (M y) = inner ℂ (K x) (y : Space G)) :
    IsSelfAdjoint (coreOperator M).closure := by
  have hc := coreOperator_closable M hs
  have hd : Dense ((coreOperator M).closure.domain : Set (Space G)) :=
    finiteCore_dense.mono (LinearPMap.domain_mono.monotone (coreOperator M).le_closure)
  apply SymmetricOperator.selfAdjoint_of_regularizers hd hc.closure_isClosed
    (SymmetricOperator.formalAdjoint_closure hc hc (coreOperator_formalAdjoint M hs))
    (resolvent h hh) (regularized h hh M) (resolvent_selfAdjoint h hh)
    (regularized_graph_closure h hh M hM hc) (resolvent_strong_one h hh)
  intro x
  simp_rw [regularized_defect h hh M K hM hK hs hk]
  have hk0 : Tendsto (fun n => energyExtension h K (complement h hh n x)) atTop (𝓝 0) := by
    simpa only [Function.comp_def,map_zero] using (energyExtension h K).continuous.continuousAt.tendsto.comp
      (complement_strong_zero h hh x)
  change Tendsto (fun n => resolvent h hh n (energyExtension h K (complement h hh n x))) atTop (𝓝 0)
  apply squeeze_zero_norm
    (a := fun n => ‖energyExtension h K (complement h hh n x)‖)
  · intro n
    simpa only [one_mul] using
      (resolvent (G := G) h hh n).le_of_opNorm_le (resolvent_norm (G := G) h hh n)
        (energyExtension h K (complement h hh n x))
  · simpa only [norm_zero] using hk0.norm

end StronglyRationalVOA.HilbertScale

namespace StronglyRationalVOA.OperatorTransport
variable {H K : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
  [NormedAddCommGroup K] [InnerProductSpace ℂ K]

theorem monotone (E : H ≃ₗᵢ[ℂ] K) : Monotone (transport E) := by
  intro S T hST
  apply LinearPMap.le_of_le_graph
  rw [graph_eq,graph_eq]
  exact Submodule.comap_mono (LinearPMap.le_graph_of_le hST)

theorem closable (E : H ≃ₗᵢ[ℂ] K) {T : K →ₗ.[ℂ] K} (hT : T.IsClosable) :
    (transport E T).IsClosable :=
  (closed E hT.closure_isClosed).isClosable.leIsClosable (monotone E T.le_closure)

theorem closure (E : H ≃ₗᵢ[ℂ] K) {T : K →ₗ.[ℂ] K} (hT : T.IsClosable) :
    (transport E T).closure = transport E T.closure := by
  apply LinearPMap.eq_of_eq_graph
  rw [← (closable E hT).graph_closure_eq_closure_graph,graph_eq,graph_eq,
    ← hT.graph_closure_eq_closure_graph]
  apply SetLike.coe_injective
  change _root_.closure ((graphEquiv E) ⁻¹' (T.graph : Set (K × K))) =
    (graphEquiv E) ⁻¹' _root_.closure (T.graph : Set (K × K))
  exact ((graphEquiv E).preimage_closure _).symm

end StronglyRationalVOA.OperatorTransport

namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure
open UniformSpace
variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
  {A : CFTTypeVOA V} (U : A.UnitaryStructure)

theorem coreEnergy_mem (a : V) :
    U.energyCoordinates (a : Completion V) ∈ HilbertScale.finiteCore := by
  have h : (a : Completion V) ∈ HilbertCore.space V := ⟨a,rfl⟩
  rwa [← U.finiteCore_comap_energyCoordinates] at h

 

def coreEnergyCoordinates : V ≃ₗ[ℂ] HilbertScale.finiteCore (G := fun d => A.grade d) :=
  LinearEquiv.ofBijective
    ((U.energyCoordinates.toLinearEquiv.toLinearMap.comp
      (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap).codRestrict _ U.coreEnergy_mem)
    (by
      constructor
      · intro x y h
        exact (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).injective
          (U.energyCoordinates.injective (congrArg Subtype.val h))
      · intro x
        have hx : U.energyCoordinates.symm x ∈ HilbertCore.space V := by
          rw [← U.finiteCore_comap_energyCoordinates]
          change U.energyCoordinates (U.energyCoordinates.symm x) ∈ HilbertScale.finiteCore
          rw [U.energyCoordinates.apply_symm_apply]
          exact x.property
        obtain ⟨v,hv⟩ := hx
        refine ⟨v,Subtype.ext ?_⟩
        change (v : Completion V) = U.energyCoordinates.symm x at hv
        change U.energyCoordinates (v : Completion V) = x
        rw [hv,U.energyCoordinates.apply_symm_apply])

@[simp] theorem coreEnergyCoordinates_coe (a : V) :
    (U.coreEnergyCoordinates a : HilbertScale.Space (fun d => A.grade d)) =
      U.energyCoordinates (a : Completion V) := rfl

theorem coreEnergyCoordinates_energyShift (a : V) :
    HilbertScale.coreDiagonal (fun d : ℕ => ((1+(d : ℝ) : ℝ) : ℂ)) (U.coreEnergyCoordinates a) =
      U.energyCoordinates (A.energyShift a : Completion V) := by
  apply lp.ext
  funext d
  apply Subtype.ext
  simp only [HilbertScale.coreDiagonal_apply,coreEnergyCoordinates_coe,
    Submodule.coe_smul,U.energyCoordinates_coe]
  simp only [energyShift,LinearMap.add_apply,Module.End.one_apply,map_add,
    A.gradeComponent_energy,Complex.ofReal_add,Complex.ofReal_one,Complex.ofReal_natCast,
    add_smul,one_smul]

 
def spectralCoreMap (T : V →ₗ[ℂ] Completion V) :
    HilbertScale.finiteCore (G := fun d => A.grade d) →ₗ[ℂ] HilbertScale.Space (fun d => A.grade d) :=
  U.energyCoordinates.toLinearEquiv.toLinearMap.comp (T.comp U.coreEnergyCoordinates.symm.toLinearMap)

@[simp] theorem spectralCoreMap_apply (T : V →ₗ[ℂ] Completion V) (a : V) :
    U.spectralCoreMap T (U.coreEnergyCoordinates a) = U.energyCoordinates (T a) := by
  simp [spectralCoreMap]

theorem spectralCoreOperator_transport (T : V →ₗ[ℂ] Completion V) :
    OperatorTransport.transport U.energyCoordinates (HilbertScale.coreOperator (U.spectralCoreMap T)) =
      HilbertCore.operator T := by
  apply LinearPMap.eq_of_eq_graph
  ext z
  rw [OperatorTransport.mem_graph_iff]
  constructor
  · intro h
    obtain ⟨x,hx,hy⟩ := (HilbertScale.coreOperator (U.spectralCoreMap T)).mem_graph_iff.mp h
    obtain ⟨v,rfl⟩ := U.coreEnergyCoordinates.surjective x
    have hv : (v : Completion V) = z.1 := U.energyCoordinates.injective hx
    have hw : T v = z.2 := by
      apply U.energyCoordinates.injective
      change U.spectralCoreMap T (U.coreEnergyCoordinates v) = _ at hy
      simpa only [U.spectralCoreMap_apply] using hy
    apply (HilbertCore.operator T).mem_graph_iff.mpr
    exact ⟨HilbertCore.equiv V v,hv,by simpa only [HilbertCore.operator_apply] using hw⟩
  · intro h
    obtain ⟨x,hx,hy⟩ := (HilbertCore.operator T).mem_graph_iff.mp h
    obtain ⟨v,rfl⟩ := (HilbertCore.equiv V).surjective x
    apply (HilbertScale.coreOperator (U.spectralCoreMap T)).mem_graph_iff.mpr
    refine ⟨U.coreEnergyCoordinates v,congrArg U.energyCoordinates hx,?_⟩
    change U.spectralCoreMap T (U.coreEnergyCoordinates v) = U.energyCoordinates z.2
    rw [U.spectralCoreMap_apply]
    exact congrArg U.energyCoordinates (by simpa only [HilbertCore.operator_apply] using hy)

include U in
 

theorem firstOrder_essentialSelfAdjoint (T K : V →ₗ[ℂ] Completion V) {C D : ℝ}
    (hT : ∀ a, ‖T a‖ ≤ C*‖A.energyShift a‖)
    (hK : ∀ a, ‖K a‖ ≤ D*‖A.energyShift a‖)
    (hs : ∀ x y : V, inner ℂ (T x) (y : Completion V) = inner ℂ (x : Completion V) (T y))
    (hk : ∀ x y : V,
      inner ℂ (T x) (A.energyShift y : Completion V)-
        inner ℂ (A.energyShift x : Completion V) (T y) = inner ℂ (K x) (y : Completion V)) :
    IsSelfAdjoint (HilbertCore.operator T).closure := by
  let : ∀ d, FiniteDimensional ℂ (A.grade d) := A.grade_finite
  have hT' : ∀ x, ‖U.spectralCoreMap T x‖ ≤
      C*‖HilbertScale.coreDiagonal (fun d : ℕ => ((1+(d : ℝ) : ℝ) : ℂ)) x‖ := by
    intro x
    obtain ⟨v,rfl⟩ := U.coreEnergyCoordinates.surjective x
    simpa only [U.spectralCoreMap_apply,U.coreEnergyCoordinates_energyShift,
      U.energyCoordinates.norm_map,Completion.norm_coe] using hT v
  have hK' : ∀ x, ‖U.spectralCoreMap K x‖ ≤
      D*‖HilbertScale.coreDiagonal (fun d : ℕ => ((1+(d : ℝ) : ℝ) : ℂ)) x‖ := by
    intro x
    obtain ⟨v,rfl⟩ := U.coreEnergyCoordinates.surjective x
    simpa only [U.spectralCoreMap_apply,U.coreEnergyCoordinates_energyShift,
      U.energyCoordinates.norm_map,Completion.norm_coe] using hK v
  have hs' : ∀ x y : HilbertScale.finiteCore (G := fun d => A.grade d),
      inner ℂ (U.spectralCoreMap T x) y = inner ℂ (x : HilbertScale.Space _) (U.spectralCoreMap T y) := by
    intro x y
    obtain ⟨v,rfl⟩ := U.coreEnergyCoordinates.surjective x
    obtain ⟨w,rfl⟩ := U.coreEnergyCoordinates.surjective y
    simpa only [U.spectralCoreMap_apply,U.coreEnergyCoordinates_coe,U.energyCoordinates.inner_map_map] using hs v w
  have hk' : ∀ x y : HilbertScale.finiteCore (G := fun d => A.grade d),
      inner ℂ (U.spectralCoreMap T x)
          (HilbertScale.coreDiagonal (fun d : ℕ => ((1+(d : ℝ) : ℝ) : ℂ)) y)-
        inner ℂ (HilbertScale.coreDiagonal (fun d : ℕ => ((1+(d : ℝ) : ℝ) : ℂ)) x)
          (U.spectralCoreMap T y) = inner ℂ (U.spectralCoreMap K x) y := by
    intro x y
    obtain ⟨v,rfl⟩ := U.coreEnergyCoordinates.surjective x
    obtain ⟨w,rfl⟩ := U.coreEnergyCoordinates.surjective y
    simpa only [U.spectralCoreMap_apply,U.coreEnergyCoordinates_coe,
      U.coreEnergyCoordinates_energyShift,U.energyCoordinates.inner_map_map] using hk v w
  have hsa := HilbertScale.coreOperator_essentialSelfAdjoint (fun d : ℕ => 1+(d : ℝ))
    (fun d => by have := Nat.cast_nonneg (α := ℝ) d; linarith) (U.spectralCoreMap T) (U.spectralCoreMap K) hT' hK' hs' hk'
  have hcl := HilbertScale.coreOperator_closable (U.spectralCoreMap T) hs'
  have h := OperatorTransport.selfAdjoint U.energyCoordinates hsa
  rwa [← OperatorTransport.closure U.energyCoordinates hcl,U.spectralCoreOperator_transport] at h

end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure

namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure
open UniformSpace
variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
  {A : CFTTypeVOA V} (U : A.UnitaryStructure)

include U in
 

theorem smearedCore_essentialSelfAdjoint {a : V} {d p : ℕ}
    (ha : a ∈ A.grade d) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian d a)
    (he : A.PolynomialEnergyBound a) {C : ℝ}
    (hb : ∀ n v, ‖A.physicalMode a d n v‖ ≤ C*(1+|(n : ℝ)|)^p*‖A.energyShift v‖)
    {f : ℤ → ℂ} (hf : RapidCoefficients f) (hr : ∀ n, star (f n) = f (-n)) :
    IsSelfAdjoint (HilbertCore.operator (A.smearedMap a d he f hf)).closure := by
  have hf' : RapidCoefficients (fun n => -(n : ℂ)*f n) := by
    simpa only [neg_mul,one_mul] using hf.int_mul.smul (-1)
  apply U.firstOrder_essentialSelfAdjoint (A.smearedMap a d he f hf)
    (A.smearedMap a d he (fun n => -(n : ℂ)*f n) hf')
  · intro v
    simpa only [pow_one] using A.smearedMap_bound (k := 1) he hf
      (by simpa only [pow_one] using hb) v
  · intro v
    simpa only [pow_one] using A.smearedMap_bound (k := 1) he hf'
      (by simpa only [pow_one] using hb) v
  · exact U.smearedMap_symmetric ha hq hh he hf hr
  · exact U.smearedMap_energy_commutator ha hq hh he hf hr

 
theorem current_closedSmearedOperator_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {a : V} (ha : a ∈ A.grade 1) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian 1 a)
    {f : ℤ → ℂ} (hf : RapidCoefficients f) (hr : ∀ n, star (f n) = f (-n)) :
    IsSelfAdjoint (U.closedSmearedOperator hc a 1 f hf) := by
  obtain ⟨C,_hC,hb⟩ := U.current_linear_energyBound hc ha hq hh
  apply U.smearedCore_essentialSelfAdjoint ha hq hh (U.polynomialEnergyBounds hc a)
    (C := C) (p := 1) (by simpa only [pow_one] using hb) hf hr

 

theorem weightTwo_closedSmearedOperator_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {a : V} (ha : a ∈ A.grade 2) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian 2 a)
    {f : ℤ → ℂ} (hf : RapidCoefficients f) (hr : ∀ n, star (f n) = f (-n)) :
    IsSelfAdjoint (U.closedSmearedOperator hc a 2 f hf) := by
  obtain ⟨C,_hC,hb⟩ := U.optimal_quasiPrimary_energyBound hc ha hq hh (by omega)
  apply U.smearedCore_essentialSelfAdjoint ha hq hh (U.polynomialEnergyBounds hc a)
    (C := C) (p := 4) (by simpa only [show 2-1=1 by decide,pow_one] using hb) hf hr

 

theorem stress_closedSmearedOperator_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {f : ℤ → ℂ} (hf : RapidCoefficients f) (hr : ∀ n, star (f n) = f (-n)) :
    IsSelfAdjoint (U.closedSmearedOperator hc A.conformalVector 2 f hf) := by
  have hh : U.IsHermitian 2 A.conformalVector := by
    simp [IsHermitian,U.pct_conformal]
  apply U.smearedCore_essentialSelfAdjoint A.conformal_mem A.conformal_quasiPrimary hh
    (U.polynomialEnergyBounds hc A.conformalVector)
    (C := 1+A.centralCharge.re) (p := 2) ?_ hf hr
  intro n v
  simpa only [A.physicalMode_conformal] using U.virasoro_linear_energy n v

end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure

namespace StronglyRationalVOA.SmoothCircleFunction

def IsReal (f : SmoothCircleFunction) : Prop := ∀ t, star (f t) = f t

theorem coefficient_real {f : SmoothCircleFunction} (hf : f.IsReal) (n : ℤ) :
    star (f.coefficient n) = f.coefficient (-n) := by
  rw [coefficient,coefficient,fourierCoeffOn_eq_integral,fourierCoeffOn_eq_integral]
  simp only [star_smul,star_trivial]
  have hc : star (∫ x in (0 : ℝ)..2*Real.pi,
      fourier (-n) (x : AddCircle (2*Real.pi-0)) • f x) =
      ∫ x in (0 : ℝ)..2*Real.pi,
        star (fourier (-n) (x : AddCircle (2*Real.pi-0)) • f x) := by
    exact (Complex.conjLIE.toLinearIsometry.intervalIntegral_comp_comm _).symm
  rw [hc]
  congr 1
  apply intervalIntegral.integral_congr
  intro t _
  simp only [smul_eq_mul,star_mul,neg_neg]
  rw [hf t, mul_comm]
  rw [show star (fourier (-n) (t : AddCircle (2*Real.pi-0))) =
      fourier n (t : AddCircle (2*Real.pi-0)) from by
        rw [fourier_neg]; exact star_star _]

end StronglyRationalVOA.SmoothCircleFunction

namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure
open UniformSpace
variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
  {A : CFTTypeVOA V} (U : A.UnitaryStructure)

 
theorem stress_closedSmoothField_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {f : SmoothCircleFunction} (hf : f.IsReal) :
    IsSelfAdjoint (U.closedSmoothField hc A.conformalVector 2 f) :=
  U.stress_closedSmearedOperator_selfAdjoint hc f.rapid_coefficients (SmoothCircleFunction.coefficient_real hf)

theorem current_closedSmoothField_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {a : V} (ha : a ∈ A.grade 1) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian 1 a)
    {f : SmoothCircleFunction} (hf : f.IsReal) :
    IsSelfAdjoint (U.closedSmoothField hc a 1 f) :=
  U.current_closedSmearedOperator_selfAdjoint hc ha hq hh f.rapid_coefficients (SmoothCircleFunction.coefficient_real hf)

theorem weightTwo_closedSmoothField_selfAdjoint (hc : A.toVertexAlgebra.C2Cofinite)
    {a : V} (ha : a ∈ A.grade 2) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian 2 a)
    {f : SmoothCircleFunction} (hf : f.IsReal) :
    IsSelfAdjoint (U.closedSmoothField hc a 2 f) :=
  U.weightTwo_closedSmearedOperator_selfAdjoint hc ha hq hh f.rapid_coefficients (SmoothCircleFunction.coefficient_real hf)

end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure

namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure
open UniformSpace
variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
  {A : CFTTypeVOA V} (U : A.UnitaryStructure)

include U in
 

theorem physicalMode_sobolev_bound {a : V} {d k 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^k) v‖)
    (r : ℕ) (n : ℤ) (v : V) :
    ‖(A.energyShift^r) (A.physicalMode a d n v)‖ ≤
      C*(1+|(n : ℝ)|)^(p+r)*‖(A.energyShift^(k+r)) v‖ := by
  induction r generalizing v with
  | zero => simpa only [pow_zero,Module.End.one_apply,Nat.add_zero] using hb n v
  | succ r ih =>
    have he : A.energyShift (A.physicalMode a d n v) =
        (-(n : ℂ)) • A.physicalMode a d n v + A.physicalMode a d n (A.energyShift v) :=
      sub_eq_iff_eq_add.mp (A.energyShift_physical_commutator ha n v)
    rw [pow_succ,Module.End.mul_apply,he,map_add,map_smul]
    have hn : ‖-(n : ℂ)‖ = |(n : ℝ)| := by
      rw [norm_neg,← Complex.ofReal_intCast,Complex.norm_real,Real.norm_eq_abs]
    have hp : (A.energyShift^(k+r)) (A.energyShift v) =
        (A.energyShift^(k+(r+1))) v := by
      rw [show k+(r+1)=k+r+1 by omega,pow_succ,Module.End.mul_apply]
    have hm := U.energyShift_pow_norm_mono (show k+r ≤ k+(r+1) by omega) v
    calc
      _ ≤ ‖(-(n : ℂ)) • (A.energyShift^r) (A.physicalMode a d n v)‖ +
          ‖(A.energyShift^r) (A.physicalMode a d n (A.energyShift v))‖ := norm_add_le _ _
      _ ≤ |(n : ℝ)| *(C*(1+|(n : ℝ)|)^(p+r)*‖(A.energyShift^(k+r)) v‖) +
          C*(1+|(n : ℝ)|)^(p+r)*‖(A.energyShift^(k+r)) (A.energyShift v)‖ := by
        rw [norm_smul,hn]
        exact add_le_add (mul_le_mul_of_nonneg_left (ih v) (abs_nonneg _)) (ih _)
      _ ≤ |(n : ℝ)| *(C*(1+|(n : ℝ)|)^(p+r)*‖(A.energyShift^(k+(r+1))) v‖) +
          C*(1+|(n : ℝ)|)^(p+r)*‖(A.energyShift^(k+(r+1))) v‖ := by
        rw [hp]
        gcongr
      _ = _ := by rw [show p+Nat.succ r=p+r+1 by omega,pow_succ]; ring

end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure

namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure
open UniformSpace Filter
open scoped Topology
variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
  {A : CFTTypeVOA V} (U : A.UnitaryStructure)
end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure

end

end OAI