File size: 17,953 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
import Mathlib
import OAI.MathematicalPhysics.BFSS.OscillatorForms

namespace OAI

/-! Weighted Sobolev form closure and normal oscillator nonnegativity. -/

namespace BFSSSliceSobolev
noncomputable section
open MeasureTheory Set Filter Topology
variable {E F : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F] [CompleteSpace F]
variable (ΞΌ : Measure E) [IsFiniteMeasureOnCompacts ΞΌ]
variable {ΞΉ : Type*} [Fintype ΞΉ] (e : ΞΉ β†’ E)

def weightedToL2 (w : E β†’ ℝ) (hw : Continuous w) (f : Core (E := E) (F := F)) : Lp F 2 ΞΌ :=
  ((hw.smul f.continuous).memLp_of_hasCompactSupport f.hasCompactSupport.smul_left).toLp
    (fun x => w x β€’ f x)

omit [FiniteDimensional ℝ E] [CompleteSpace F] in
lemma weightedToL2_ae (w : E β†’ ℝ) (hw : Continuous w) (f : Core (E := E) (F := F)) :
    (weightedToL2 ΞΌ w hw f : E β†’ F) =ᡐ[ΞΌ] fun x => w x β€’ f x := MemLp.coeFn_toLp _

def weightedClosure (w : E β†’ ℝ) (hw : Continuous w) :
    Set (Lp F 2 ΞΌ Γ— Gradient (F := F) ΞΌ (ΞΉ := ΞΉ) Γ— Lp F 2 ΞΌ) :=
  closure (Set.range fun f : Core (E := E) (F := F) =>
    (toL2 ΞΌ f,gradient ΞΌ e f,weightedToL2 ΞΌ w hw f))

def coreMul (Ο‡ : Core (E := E) (F := ℝ)) (f : Core (E := E) (F := F)) : Core (E := E) (F := F) :=
  ⟨fun x => Ο‡ x β€’ f x,Ο‡.contDiff.smul f.contDiff,f.hasCompactSupport.smul_left,
    by intro x hx; trivial⟩

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] [CompleteSpace F] in
lemma coreMul_apply (Ο‡ : Core (E := E) (F := ℝ)) (f : Core (E := E) (F := F)) (x : E) :
    coreMul Ο‡ f x = Ο‡ x β€’ f x := rfl

omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] [CompleteSpace F] in
lemma coreMul_derivative (Ο‡ : Core (E := E) (F := ℝ)) (f : Core (E := E) (F := F)) (v : E) (x : E) :
    (TestFunction.lineDerivCLM (k := ⊀) ℝ v (coreMul Ο‡ f)) x =
      Ο‡ x β€’ (TestFunction.lineDerivCLM (k := ⊀) ℝ v f) x +
      (TestFunction.lineDerivCLM (k := ⊀) ℝ v Ο‡) x β€’ f x := by
  change fderiv ℝ (fun x => Ο‡ x β€’ f x) x v =
    Ο‡ x β€’ fderiv ℝ (f : E β†’ F) x v + fderiv ℝ (Ο‡ : E β†’ ℝ) x v β€’ f x
  rw [fderiv_fun_smul (Ο‡.contDiff.differentiable (by simp) x)
    (f.contDiff.differentiable (by simp) x)]
  rfl

abbrev scalarMul (Ο‡ : Core (E := E) (F := ℝ)) (u : Lp F 2 ΞΌ) : Lp F 2 ΞΌ :=
  BFSSLocalL2.compactMul Ο‡ Ο‡.continuous Ο‡.hasCompactSupport u

def cutoffGradient (Ο‡ : Core (E := E) (F := ℝ)) (u : Lp F 2 ΞΌ)
    (v : Gradient (F := F) ΞΌ (ΞΉ := ΞΉ)) : Gradient (F := F) ΞΌ (ΞΉ := ΞΉ) :=
  WithLp.toLp 2 (fun j => scalarMul ΞΌ Ο‡ (v j) + scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) Ο‡) u)

def cutoffMoment (w : E β†’ ℝ) (hw : Continuous w) (Ο‡ : Core (E := E) (F := ℝ)) (u : Lp F 2 ΞΌ) : Lp F 2 ΞΌ :=
  BFSSLocalL2.compactMul (fun x => w x * Ο‡ x) (hw.mul Ο‡.continuous) Ο‡.hasCompactSupport.mul_left u

omit [FiniteDimensional ℝ E] [CompleteSpace F] [IsFiniteMeasureOnCompacts ΞΌ] [Fintype ΞΉ] in
lemma cutoffGradient_continuous (Ο‡ : Core (E := E) (F := ℝ)) :
    Continuous (fun p : Lp F 2 ΞΌ Γ— Gradient (F := F) ΞΌ (ΞΉ := ΞΉ) => cutoffGradient ΞΌ e Ο‡ p.1 p.2) := by
  apply (PiLp.continuous_toLp 2 _).comp
  apply continuous_pi
  intro j
  exact ((BFSSLocalL2.compactMul_continuous _ _ _).comp
    ((PiLp.continuous_apply 2 _ j).comp continuous_snd)).add
    ((BFSSLocalL2.compactMul_continuous _ _ _).comp continuous_fst)

omit [FiniteDimensional ℝ E] [CompleteSpace F] [Fintype ΞΉ] in
lemma cutoff_core_tuple (w : E β†’ ℝ) (hw : Continuous w) (Ο‡ : Core (E := E) (F := ℝ))
    (f : Core (E := E) (F := F)) :
    (toL2 ΞΌ (coreMul Ο‡ f),gradient ΞΌ e (coreMul Ο‡ f),weightedToL2 ΞΌ w hw (coreMul Ο‡ f)) =
      (scalarMul ΞΌ Ο‡ (toL2 ΞΌ f),cutoffGradient ΞΌ e Ο‡ (toL2 ΞΌ f) (gradient ΞΌ e f),
        cutoffMoment ΞΌ w hw Ο‡ (toL2 ΞΌ f)) := by
  apply Prod.ext
  Β· apply Lp.ext
    filter_upwards [toL2_ae ΞΌ (coreMul Ο‡ f),BFSSLocalL2.compactMul_ae Ο‡ Ο‡.continuous Ο‡.hasCompactSupport (toL2 ΞΌ f),toL2_ae ΞΌ f] with x h₁ hβ‚‚ h₃
    rw [h₁,hβ‚‚,h₃,coreMul_apply]
  apply Prod.ext
  Β· apply PiLp.ext
    intro j
    apply Lp.ext
    filter_upwards [toL2_ae ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) (coreMul Ο‡ f)),
      BFSSLocalL2.compactMul_ae Ο‡ Ο‡.continuous Ο‡.hasCompactSupport (gradient ΞΌ e f j),
      BFSSLocalL2.compactMul_ae _ _ _ (toL2 ΞΌ f),
      toL2_ae ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) f),toL2_ae ΞΌ f,
      Lp.coeFn_add (scalarMul ΞΌ Ο‡ (gradient ΞΌ e f j))
        (scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) Ο‡) (toL2 ΞΌ f))] with x h₁ hβ‚‚ h₃ hβ‚„ hβ‚… h₆
    change (toL2 ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) (coreMul Ο‡ f)) : E β†’ F) x =
      ((scalarMul ΞΌ Ο‡ (gradient ΞΌ e f j) + scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) Ο‡) (toL2 ΞΌ f) : Lp F 2 ΞΌ) : E β†’ F) x
    rw [h₁,h₆,Pi.add_apply,hβ‚‚,h₃,gradient_apply,hβ‚„,hβ‚…,coreMul_derivative]
  Β· apply Lp.ext
    filter_upwards [weightedToL2_ae ΞΌ w hw (coreMul Ο‡ f),
      BFSSLocalL2.compactMul_ae (fun x => w x*Ο‡ x) (hw.mul Ο‡.continuous) Ο‡.hasCompactSupport.mul_left (toL2 ΞΌ f),
      toL2_ae ΞΌ f] with x h₁ hβ‚‚ h₃
    change (weightedToL2 ΞΌ w hw (coreMul Ο‡ f) : E β†’ F) x =
      (BFSSLocalL2.compactMul (fun x => w x*Ο‡ x) (hw.mul Ο‡.continuous) Ο‡.hasCompactSupport.mul_left (toL2 ΞΌ f) : E β†’ F) x
    rw [h₁,hβ‚‚,h₃,coreMul_apply,mul_smul]

omit [FiniteDimensional ℝ E] [CompleteSpace F] in
lemma cutoff_mem_weightedClosure (w : E β†’ ℝ) (hw : Continuous w) (Ο‡ : Core (E := E) (F := ℝ))
    {u : Lp F 2 μ} {v : Gradient (F := F) μ (ι := ι)} (hp : (u,v) ∈ closedGraph μ e) :
    (scalarMul ΞΌ Ο‡ u,cutoffGradient ΞΌ e Ο‡ u v,cutoffMoment ΞΌ w hw Ο‡ u) ∈ weightedClosure ΞΌ e w hw := by
  change (u,v) ∈ closure (Set.range fun f : Core (E := E) (F := F) => (toL2 μ f,gradient μ e f)) at hp
  obtain ⟨p,hp,ht⟩ := mem_closure_iff_seq_limit.mp hp
  choose f hf using hp
  have hfβ‚‚ : Tendsto (fun n => (toL2 ΞΌ (f n),gradient ΞΌ e (f n))) atTop (𝓝 (u,v)) := by simpa only [hf] using ht
  have hf₁ : Tendsto (fun n => toL2 ΞΌ (f n)) atTop (𝓝 u) :=
    (continuous_fst.tendsto (u,v)).comp hfβ‚‚
  apply mem_closure_of_tendsto (b := (atTop : Filter β„•)) (f := fun n =>
    (scalarMul ΞΌ Ο‡ (toL2 ΞΌ (f n)),cutoffGradient ΞΌ e Ο‡ (toL2 ΞΌ (f n)) (gradient ΞΌ e (f n)),
      cutoffMoment ΞΌ w hw Ο‡ (toL2 ΞΌ (f n))))
  Β· exact ((BFSSLocalL2.compactMul_continuous _ _ _).tendsto u |>.comp hf₁).prodMk_nhds
      (((cutoffGradient_continuous ΞΌ e Ο‡).tendsto (u,v) |>.comp hfβ‚‚).prodMk_nhds
        ((BFSSLocalL2.compactMul_continuous _ _ _).tendsto u |>.comp hf₁))
  Β· exact Eventually.of_forall (fun n => ⟨coreMul Ο‡ (f n),cutoff_core_tuple ΞΌ e w hw Ο‡ (f n)⟩)
end
end BFSSSliceSobolev

namespace BFSSSliceSobolev
noncomputable section
open MeasureTheory Set Filter Topology
variable {E F : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F] [CompleteSpace F]
variable (ΞΌ : Measure E) [IsFiniteMeasureOnCompacts ΞΌ]
variable {ΞΉ : Type*} [Fintype ΞΉ] (e : ΞΉ β†’ E)

def bumpCore (Ο† : ContDiffBump (0 : E)) (h : ℝ) (hh : h β‰  0) : Core (E := E) (F := ℝ) :=
  ⟨fun x => Ο† (h β€’ x),Ο†.contDiff.comp (contDiff_const.smul contDiff_id),
    Ο†.hasCompactSupport.comp_smul hh,by intro x hx; trivial⟩

omit [MeasurableSpace E] [BorelSpace E] in
lemma bumpCore_apply (Ο† : ContDiffBump (0 : E)) (h : ℝ) (hh : h β‰  0) (x : E) :
    bumpCore Ο† h hh x = Ο† (h β€’ x) := rfl

omit [MeasurableSpace E] [BorelSpace E] in
lemma bumpCore_derivative (Ο† : ContDiffBump (0 : E)) (h : ℝ) (hh : h β‰  0) (x a : E) :
    TestFunction.lineDerivCLM (k := ⊀) ℝ a (bumpCore Ο† h hh) x =
      fderiv ℝ (Ο† : E β†’ ℝ) (h β€’ x) (h β€’ a) := by
  change fderiv ℝ (fun x => Ο† (h β€’ x)) x a = _
  have hs : HasFDerivAt (fun y : E => h β€’ y) (h β€’ ContinuousLinearMap.id ℝ E) x :=
    (hasFDerivAt_id x).const_smul h
  have he := (((Ο†.contDiff : ContDiff ℝ 1 (Ο† : E β†’ ℝ)).differentiable (by norm_num) (h β€’ x)).hasFDerivAt.comp x hs).fderiv
  simpa only [Function.comp_def,ContinuousLinearMap.comp_apply,_root_.smul_apply,ContinuousLinearMap.id_apply,map_smul] using congrArg (fun L : E β†’L[ℝ] ℝ => L a) he

omit [CompleteSpace F] [IsFiniteMeasureOnCompacts ΞΌ] in
lemma scalarMul_bump_tendsto (Ο† : ContDiffBump (0 : E)) (h : β„• β†’ ℝ) (hh : βˆ€ n, h n β‰  0)
    (ht : Tendsto h atTop (𝓝 0)) (u : Lp F 2 ΞΌ) :
    Tendsto (fun n => scalarMul ΞΌ (bumpCore Ο† (h n) (hh n)) u) atTop (𝓝 u) := by
  have hm (n : β„•) : AEStronglyMeasurable (fun x : E => Ο† (h n β€’ x)) ΞΌ :=
    (Ο†.continuous.comp (continuous_const.smul continuous_id)).aestronglyMeasurable
  have hb (n : β„•) : βˆ€α΅ x βˆ‚ΞΌ, |Ο† (h n β€’ x)| ≀ 1 :=
    ae_of_all ΞΌ (fun x => by rw [abs_of_nonneg Ο†.nonneg]; exact Ο†.le_one)
  have hl : βˆ€α΅ x βˆ‚ΞΌ, Tendsto (fun n => Ο† (h n β€’ x)) atTop (𝓝 1) := by
    apply ae_of_all
    intro x
    have hhx : Tendsto (fun n => h n β€’ x) atTop (𝓝 (0 : E)) := by simpa only [zero_smul] using ht.smul_const x
    have hφ0 : φ (0 : E) = 1 := φ.one_of_mem_closedBall (by simpa only [Metric.mem_closedBall,dist_self] using φ.rIn_pos.le)
    simpa only [hφ0,Function.comp_def] using φ.continuous.continuousAt.tendsto.comp hhx
  have he (n : β„•) : scalarMul ΞΌ (bumpCore Ο† (h n) (hh n)) u =
      BFSSLocalL2.boundedMul (fun x => Ο† (h n β€’ x)) (hm n) 1 (hb n) u := by
    apply Lp.ext
    filter_upwards [BFSSLocalL2.compactMul_ae _ _ _ u,
      BFSSLocalL2.boundedMul_ae _ (hm n) 1 (hb n) u] with x hx hy
    rw [hx,hy,bumpCore_apply]
  simpa only [he] using BFSSLocalL2.boundedMul_fixed_tendsto
    (fun n x => Ο† (h n β€’ x)) hm 1 (by norm_num) hb hl u

omit [CompleteSpace F] [IsFiniteMeasureOnCompacts ΞΌ] in
lemma scalarMul_bump_derivative_tendsto (Ο† : ContDiffBump (0 : E)) (h : β„• β†’ ℝ)
    (hh : βˆ€ n, h n β‰  0) (ht : Tendsto h atTop (𝓝 0)) (a : E) (u : Lp F 2 ΞΌ) :
    Tendsto (fun n => scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ a
      (bumpCore Ο† (h n) (hh n))) u) atTop (𝓝 0) := by
  have hdc : Continuous (fderiv ℝ (Ο† : E β†’ ℝ)) := (Ο†.contDiff : ContDiff ℝ 1 (Ο† : E β†’ ℝ)).continuous_fderiv (by norm_num)
  obtain ⟨D,hD⟩ := (Ο†.hasCompactSupport.fderiv ℝ).exists_bound_of_continuous hdc
  have hD0 : 0 ≀ D := (norm_nonneg _).trans (hD 0)
  have hb (n : β„•) : β€–scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ a (bumpCore Ο† (h n) (hh n))) uβ€– ≀
      (D*|h n| *β€–aβ€–)*β€–uβ€– := by
    apply BFSSLocalL2.norm_le_mul_of_ae_norm_le _ u (D*|h n| *β€–aβ€–) (by positivity)
    filter_upwards [BFSSLocalL2.compactMul_ae _ _ _ u] with x hx
    rw [hx,norm_smul,bumpCore_derivative]
    apply mul_le_mul_of_nonneg_right _ (norm_nonneg _)
    calc
      _ ≀ β€–fderiv ℝ (Ο† : E β†’ ℝ) (h n β€’ x)β€–*β€–h n β€’ aβ€– := (fderiv ℝ (Ο† : E β†’ ℝ) (h n β€’ x)).le_opNorm _
      _ ≀ D*β€–h n β€’ aβ€– := mul_le_mul_of_nonneg_right (hD _) (norm_nonneg _)
      _ = D*|h n| *β€–aβ€– := by rw [norm_smul,Real.norm_eq_abs,mul_assoc]
  apply tendsto_zero_iff_norm_tendsto_zero.mpr
  apply squeeze_zero (fun n => norm_nonneg _) hb
  simpa only [abs_zero,mul_zero,zero_mul] using (ht.abs.const_mul D).mul_const β€–aβ€– |>.mul_const β€–uβ€–

omit [CompleteSpace F] [IsFiniteMeasureOnCompacts ΞΌ] [Fintype ΞΉ] in
lemma cutoffGradient_bump_tendsto (Ο† : ContDiffBump (0 : E)) (h : β„• β†’ ℝ) (hh : βˆ€ n, h n β‰  0)
    (ht : Tendsto h atTop (𝓝 0)) (u : Lp F 2 ΞΌ) (v : Gradient (F := F) ΞΌ (ΞΉ := ΞΉ)) :
    Tendsto (fun n => cutoffGradient ΞΌ e (bumpCore Ο† (h n) (hh n)) u v) atTop (𝓝 v) := by
  have hp : Tendsto (fun n j => scalarMul ΞΌ (bumpCore Ο† (h n) (hh n)) (v j) +
      scalarMul ΞΌ (TestFunction.lineDerivCLM (k := ⊀) ℝ (e j) (bumpCore Ο† (h n) (hh n))) u)
      atTop (𝓝 (fun j => v j)) := by
    apply tendsto_pi_nhds.mpr
    intro j
    simpa only [add_zero] using (scalarMul_bump_tendsto ΞΌ Ο† h hh ht (v j)).add
      (scalarMul_bump_derivative_tendsto ΞΌ Ο† h hh ht (e j) u)
  exact (PiLp.continuous_toLp 2 _).tendsto (fun j => v j) |>.comp hp

omit [FiniteDimensional ℝ E] [CompleteSpace F] [IsFiniteMeasureOnCompacts ΞΌ] in
lemma cutoffMoment_eq_scalarMul (w : E β†’ ℝ) (hw : Continuous w) (Ο‡ : Core (E := E) (F := ℝ))
    (u : Lp F 2 ΞΌ) (hm : MemLp (fun x => w x β€’ u x) 2 ΞΌ) :
    cutoffMoment ΞΌ w hw Ο‡ u = scalarMul ΞΌ Ο‡ (hm.toLp (fun x => w x β€’ u x)) := by
  apply Lp.ext
  filter_upwards [BFSSLocalL2.compactMul_ae (fun x => w x*Ο‡ x) (hw.mul Ο‡.continuous)
    Ο‡.hasCompactSupport.mul_left u,BFSSLocalL2.compactMul_ae _ _ _ (hm.toLp (fun x => w x β€’ u x)),
    hm.coeFn_toLp] with x hx hy hz
  change (BFSSLocalL2.compactMul (fun x => w x*Ο‡ x) (hw.mul Ο‡.continuous)
    Ο‡.hasCompactSupport.mul_left u : E β†’ F) x = _
  rw [hx,hy,hz,mul_comm,mul_smul]

omit [CompleteSpace F] in
theorem mem_weightedClosure (w : E β†’ ℝ) (hw : Continuous w)
    {u : Lp F 2 μ} {v : Gradient (F := F) μ (ι := ι)} (hp : (u,v) ∈ closedGraph μ e)
    (hm : MemLp (fun x => w x β€’ u x) 2 ΞΌ) :
    (u,v,hm.toLp (fun x => w x β€’ u x)) ∈ weightedClosure ΞΌ e w hw := by
  let Ο† : ContDiffBump (0 : E) := ⟨1,2,by norm_num,by norm_num⟩
  let h : β„• β†’ ℝ := fun n => 1/((n : ℝ)+1)
  have hh : βˆ€ n, h n β‰  0 := fun n => ne_of_gt (by dsimp [h]; positivity)
  have ht : Tendsto h atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
  have h₁ := scalarMul_bump_tendsto ΞΌ Ο† h hh ht u
  have hβ‚‚ := cutoffGradient_bump_tendsto ΞΌ e Ο† h hh ht u v
  have h₃ : Tendsto (fun n => cutoffMoment ΞΌ w hw (bumpCore Ο† (h n) (hh n)) u)
      atTop (𝓝 (hm.toLp (fun x => w x β€’ u x))) := by
    simp only [cutoffMoment_eq_scalarMul ΞΌ w hw _ u hm]
    exact scalarMul_bump_tendsto ΞΌ Ο† h hh ht _
  exact isClosed_closure.mem_of_tendsto (h₁.prodMk_nhds (hβ‚‚.prodMk_nhds h₃))
    (Eventually.of_forall fun n => cutoff_mem_weightedClosure ΞΌ e w hw (bumpCore Ο† (h n) (hh n)) hp)
end
end BFSSSliceSobolev

namespace BFSSQuantum.AlgebraData
noncomputable section
open MeasureTheory Set Filter Topology
variable {N : β„•} (M : AlgebraData N)
attribute [local irreducible] normalSlice gaugeAction coreToL2
local instance formClosureFermionNormedAddCommGroup :
    NormedAddCommGroup (Fermion N β†’L[ℝ] Fermion N) := inferInstance
local instance formClosureFermionNormedSpace :
    NormedSpace ℝ (Fermion N β†’L[ℝ] Fermion N) := inferInstance

def normalMomentWeight (q : Boson N) (x : M.NormalCoordinates q) : ℝ :=
  Real.sqrt (M.normalQuadratic q (M.normalCoordinateIsometry q x : Boson N))

lemma normalMomentWeight_continuous (q : Boson N) : Continuous (M.normalMomentWeight q) :=
  ((M.normalQuadratic_continuous q).comp
    ((continuous_subtype_val).comp (M.normalCoordinateIsometry q).continuous)).sqrt

lemma normalWeightedCore_norm_sq (q : Boson N) (f : M.NormalCore q) :
    β€–BFSSSliceSobolev.weightedToL2 volume (M.normalMomentWeight q) (M.normalMomentWeight_continuous q) fβ€–^2 =
      ∫ x : M.NormalCoordinates q, M.normalQuadratic q (M.normalCoordinateIsometry q x : Boson N)*
        β€–(BFSSSliceSobolev.toL2 volume f) xβ€–^2 := by
  rw [BFSSLocalL2.lp_norm_sq]
  apply integral_congr_ae
  filter_upwards [BFSSSliceSobolev.weightedToL2_ae volume (M.normalMomentWeight q)
    (M.normalMomentWeight_continuous q) f,BFSSSliceSobolev.toL2_ae volume f] with x hw hf
  rw [hw,hf,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,normalMomentWeight,
    Real.sq_sqrt (M.normalQuadratic_nonneg q _)]

theorem normalOscillator_nonneg (q : Boson N) (hq : q ∈ M.massiveZeros)
    (u : Lp (Fermion N) 2 (volume : Measure (M.NormalCoordinates q))) (v : M.NormalGradient q)
    (hd : M.NormalFormDomain q u v) : 0 ≀ M.normalOscillatorForm q u v := by
  let A := M.deformedFermionField 1 1 q
  let C : Set (Lp (Fermion N) 2 (volume : Measure (M.NormalCoordinates q)) Γ—
      M.NormalGradient q Γ— Lp (Fermion N) 2 (volume : Measure (M.NormalCoordinates q))) :=
    {p | 0 ≀ (1/2 : ℝ)*β€–p.2.1β€–^2+β€–p.2.2β€–^2+inner ℝ p.1 (A.compLp p.1)}
  have hC : IsClosed C := by
    apply isClosed_le continuous_const
    exact ((continuous_const.mul (((continuous_fst.comp continuous_snd).norm).pow 2)).add
      (((continuous_snd.comp continuous_snd).norm).pow 2)).add
      (continuous_fst.inner ((A.compLpL 2 volume).continuous.comp continuous_fst))
  have hs : Set.range (fun f : M.NormalCore q =>
      (BFSSSliceSobolev.toL2 volume f,
        BFSSSliceSobolev.gradient volume (EuclideanSpace.basisFun (M.NormalIndex q) ℝ) f,
        BFSSSliceSobolev.weightedToL2 volume (M.normalMomentWeight q) (M.normalMomentWeight_continuous q) f)) βŠ† C := by
    rintro _ ⟨f,rfl⟩
    have hf := M.normalOscillator_core_nonneg q hq f
    change 0 ≀ (1/2 : ℝ)*β€–BFSSSliceSobolev.gradient volume
      (EuclideanSpace.basisFun (M.NormalIndex q) ℝ) fβ€–^2 +
      β€–BFSSSliceSobolev.weightedToL2 volume (M.normalMomentWeight q) (M.normalMomentWeight_continuous q) fβ€–^2 +
      inner ℝ (BFSSSliceSobolev.toL2 volume f) (A.compLp (BFSSSliceSobolev.toL2 volume f))
    rw [M.normalWeightedCore_norm_sq]
    simpa only [normalOscillatorForm,BFSSNormalAnalysis.constant_quadratic_eq,A] using hf
  have hm := BFSSSliceSobolev.mem_weightedClosure volume
    (EuclideanSpace.basisFun (M.NormalIndex q) ℝ) (M.normalMomentWeight q)
    (M.normalMomentWeight_continuous q) hd.1 hd.2
  have hc := closure_minimal hs hC hm
  change 0 ≀ (1/2 : ℝ)*β€–vβ€–^2+β€–hd.2.toLp (fun x => M.normalMomentWeight q x β€’ u x)β€–^2+
    inner ℝ u (A.compLp u) at hc
  rw [normalOscillatorForm,←M.normalPotential_norm_sq q u hd.2,
    BFSSNormalAnalysis.constant_quadratic_eq]
  exact hc
end
end BFSSQuantum.AlgebraData

end OAI