Add lean source and binary files (part 90)

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum.lean

@@ -0,0 +1,93 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralAngularParameter
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralBoundaryNeighborhood
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralC1HarmonicMembership
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCanonicalParameterL2
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCanonicalParameterSmooth
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralChainCoreC1
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralChainCorePower
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralChainRobinC1
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClassicalContinuousTest
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClassicalObservationLine
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClassicalSlopePairing
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClosedDerivative
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactKernelLift
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactObservedChain
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactPencilDerivative
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCoreBoundaryLinear
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCoupledGreenFull
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCrossFluxLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralDilationBoundaryEstimate
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralDilationDecomposition
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralDirichletGreenData
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralEventualSimple
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFixedGaugeAnalytic
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFluxChainGauge
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFluxRobinLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeBasisParameter
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeBoundaryMultiplicity
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeChainCore
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeCollarUniqueness
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeInterfaceRoot
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreePhysicalIdentification
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFreeRadiusLog
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeClassicalSourceFlux
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeComponentEnergy
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeCoreLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeCrossBound
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeFirstBoundary
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralGaugeFirstMass
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralHolomorphicFixedLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralHolomorphicRobinLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralInwardDecay
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralJointNonzero
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralJointUniformLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralKernelCoefficientLine
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralLogGaugeCoefficients
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralLowerOrderConvergence
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMassConvergence
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchedBases
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchedCaseIIShell
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchedEscapeExclusion
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchedWeight
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchingAnalytic
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMatchingGluing
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralODESmoothness
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralObservedSourceEquation
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilExclusion
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilFlux
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilFluxSystem
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilJointLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilRobin
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPhysicalGaugeTransfer
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPhysicalParameterBounds
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPhysicalSourceBoundary
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPowerPressureAway
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralQuotientDecay
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialCoreWeak
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialGaugeEnergyUpper
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialPenalty
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialPoincare
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialRealGauge
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialRealSourceGauge
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRemoteScaleSymbols
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRobinSourcePlane
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarBoundaryNorm
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarOutgoingBound
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEnergyLinear
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEnergyPair
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailOutgoingSelection
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningCentralTransfer
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningForbiddenGreenUniform
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningGreenSmallness
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningLogarithmicLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningNegativeTransfer
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningOutgoingRobin
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningShellDecay
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralUniformWeightBounds
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeakRobinC1
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightExt
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightedGaugeBoundary
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightedProductLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightedSourceBalance
+
+/-! Outgoing spectral estimates and symmetry-mode classification. -/

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondClassicalFlux.lean

@@ -0,0 +1,92 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondFluxDerivative
+
+namespace OAI
+
+/-! The weak flux equals the flux of the classical radial representative. -/
+
+open Set MeasureTheory
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+noncomputable def spectralSecondClassicalFlux (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (x : ℝ) : ℂ :=
+  (x : ℂ)^11*((w.density x : ℂ)*deriv (spectralHarmonicRepresentative ell R hR u.snd) x+
+    (a.density x : ℂ)*spectralHarmonicRepresentative ell R hR u.fst x)
+
+theorem spectralSecondDerivativeValue_continuousOn (ell : ℕ) (R l r : ℝ) (hR : 0 < R)
+    (hl : 0 < l) (hr : r ≤ R) (w a : SpectralHarmonicWeight R)
+    (u : SpectralHarmonicPair ell R) (P : ℝ → ℂ)
+    (hw : ContinuousOn w.density (Ioo l r)) (ha : ContinuousOn a.density (Ioo l r))
+    (hpos : ∀ x ∈ Ioo l r, 0 < w.density x) (hP : ContinuousOn P (Ioo l r)) :
+    ContinuousOn (spectralSecondDerivativeValue ell R hR w a u P) (Ioo l r) := by
+  have hs : Ioo l r ⊆ Ioo 0 R := fun t ht => ⟨hl.trans ht.1,ht.2.trans_le hr⟩
+  exact ((hP.div (Complex.continuous_ofReal.continuousOn.pow 11)
+    (fun t ht => pow_ne_zero _ (by exact_mod_cast (hl.trans ht.1).ne'))).sub
+      ((Complex.continuous_ofReal.comp_continuousOn ha).mul
+        ((spectralHarmonicRepresentative_continuousOn ell R hR u.fst).mono hs))).div
+          (Complex.continuous_ofReal.comp_continuousOn hw)
+          (fun t ht => by exact_mod_cast (hpos t ht).ne')
+
+theorem spectralSecondClassicalFlux_eq (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (P : ℝ → ℂ)
+    (x : ℝ) (hx : x ≠ 0) (hw : w.density x ≠ 0)
+    (hd : HasDerivAt (spectralHarmonicRepresentative ell R hR u.snd)
+      (spectralSecondDerivativeValue ell R hR w a u P x) x) :
+    spectralSecondClassicalFlux ell R hR w a u x=P x := by
+  unfold spectralSecondClassicalFlux
+  rw [hd.deriv]
+  dsimp only [spectralSecondDerivativeValue]
+  have hx' : (x : ℂ) ≠ 0 := by exact_mod_cast hx
+  have hw' : (w.density x : ℂ) ≠ 0 := by exact_mod_cast hw
+  field_simp
+  ring
+
+theorem spectralSecond_classical (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (B : ℂ × ℂ →L[ℂ] ℂ × ℂ)
+    (hw : ContinuousOn w.density (Ioo 0 R)) (ha : ContinuousOn a.density (Ioo 0 R))
+    (hpos : ∀ x ∈ Ioo 0 R, 0 < w.density x)
+    (he : ∀ f : 𝓢(ℝ,ℂ),
+      spectralHarmonicPairComplexForm ell R w u (spectralSecondTest ell R f)=
+      inner ℂ (spectralLowerOrderOperator ell R hR
+        (spectralRadialWeightMultiplier R w) (spectralRadialWeightMultiplier R a) c ζ B
+        (spectralHarmonicObservation ell R hR u)) (spectralSecondTest ell R f)) :
+    DifferentiableOn ℝ (spectralHarmonicRepresentative ell R hR u.snd) (Ioo 0 R) ∧
+      ContinuousOn (deriv (spectralHarmonicRepresentative ell R hR u.snd)) (Ioo 0 R) ∧
+      ∀ x ∈ Ioo 0 R, HasDerivAt (spectralSecondClassicalFlux ell R hR w a u)
+        (spectralSecondContinuousSource ell R hR w u c ζ x) x := by
+  have hlocal (x : ℝ) (hx : x ∈ Ioo 0 R) :
+      DifferentiableAt ℝ (spectralHarmonicRepresentative ell R hR u.snd) x ∧
+      ContinuousAt (deriv (spectralHarmonicRepresentative ell R hR u.snd)) x ∧
+      HasDerivAt (spectralSecondClassicalFlux ell R hR w a u)
+        (spectralSecondContinuousSource ell R hR w u c ζ x) x := by
+    let l := x/2
+    let r := (x+R)/2
+    have hl : 0 < l := by dsimp only [l]; linarith [hx.1]
+    have hxl : l < x := by dsimp only [l]; linarith [hx.1]
+    have hxr : x < r := by dsimp only [r]; linarith [hx.2]
+    have hr : r < R := by dsimp only [r]; linarith [hx.2]
+    have hs : Ioo l r ⊆ Ioo 0 R := fun t ht => ⟨hl.trans ht.1,ht.2.trans hr⟩
+    obtain ⟨P,hP,hflux⟩ := spectralSecondFlux_primitive ell R l r hR hl (hxl.trans hxr) hr
+      w a u c ζ B hw ha he
+    have hPc : ContinuousOn P (Ioo l r) := fun t ht => (hP t ht).continuousAt.continuousWithinAt
+    have hd (t : ℝ) (ht : t ∈ Ioo l r) := spectralSecondFlux_hasDerivAt ell R l r hR
+      hl hr.le w a u P (hw.mono hs) (ha.mono hs) (fun s hs' => hpos s (hs hs')) hPc hflux t ht
+    have heq (t : ℝ) (ht : t ∈ Ioo l r) :
+        spectralSecondClassicalFlux ell R hR w a u t=P t :=
+      spectralSecondClassicalFlux_eq ell R hR w a u P t (hl.trans ht.1).ne'
+        (hpos t (hs ht)).ne' (hd t ht)
+    refine ⟨(hd x ⟨hxl,hxr⟩).differentiableAt,?_,?_⟩
+    · have hDc := spectralSecondDerivativeValue_continuousOn ell R l r hR hl hr.le
+        w a u P (hw.mono hs) (ha.mono hs) (fun s hs' => hpos s (hs hs')) hPc
+      exact (hDc.congr (fun t ht => (hd t ht).deriv)).continuousAt
+        (Ioo_mem_nhds hxl hxr)
+    · apply (hP x ⟨hxl,hxr⟩).congr_of_eventuallyEq
+      filter_upwards [Ioo_mem_nhds hxl hxr] with t ht
+      exact heq t ht
+  exact ⟨fun x hx => (hlocal x hx).1.differentiableWithinAt,
+    fun x hx => (hlocal x hx).2.1.continuousWithinAt,fun x hx => (hlocal x hx).2.2⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondClosedBoundary.lean

@@ -0,0 +1,55 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClassicalFluxAE
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralClosedSource
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCutoffFluxTrace
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralEndpointTest
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralBoundaryFlux
+
+namespace OAI
+
+/-! The second scalar weak equation gives its exact classical outer flux trace. -/
+
+open Set MeasureTheory
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+theorem spectralSecond_closedBoundary (ell : ℕ) (R δ : ℝ) (hR : 0 < R)
+    (hδ : 0 < δ) (hδR : δ < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (B : ℂ × ℂ →L[ℂ] ℂ × ℂ)
+    (hw : ContinuousOn w.density (Ioo 0 R)) (ha : ContinuousOn a.density (Ioo 0 R))
+    (hwc : ContinuousOn w.density (Icc δ R))
+    (hpos : ∀ x ∈ Ioo 0 R, 0 < w.density x)
+    (he : ∀ f : 𝓢(ℝ,ℂ),
+      spectralHarmonicPairComplexForm ell R w u (spectralSecondTest ell R f)=
+      inner ℂ (spectralLowerOrderOperator ell R hR
+        (spectralRadialWeightMultiplier R w) (spectralRadialWeightMultiplier R a) c ζ B
+        (spectralHarmonicObservation ell R hR u)) (spectralSecondTest ell R f)) :
+    ∃ P : ℝ → ℂ, Continuous P ∧
+      (∀ x ∈ Icc δ R, HasDerivAt P (spectralSecondContinuousSource ell R hR w u c ζ x) x) ∧
+      EqOn (spectralSecondClassicalFlux ell R hR w a u) P (Ioo δ R) ∧
+      (∀ᵐ x, x ∈ Icc δ R → spectralSecondFlux ell R w a u x=P x) ∧
+      P R=(B (spectralHarmonicPairTraces ell R hR u)).2 := by
+  have hs : Ioo δ R ⊆ Ioo 0 R := fun x hx => ⟨hδ.trans hx.1,hx.2⟩
+  have hG := spectralSecondContinuousSource_closed ell R δ hR hδ w u c ζ hwc
+  have hclass := (spectralSecond_classical ell R hR w a u c ζ B hw ha hpos he).2.2
+  have hae := spectralSecondClassicalFlux_ae ell R hR w a u c ζ B hw ha hpos he
+  obtain ⟨P,hP,hd,hEq,hFP⟩ := spectralClosedFlux_ae_primitive δ R hδR
+    (spectralSecondFlux ell R w a u) (spectralSecondClassicalFlux ell R hR w a u)
+    (spectralSecondContinuousSource ell R hR w u c ζ) hG
+    (fun x hx => hclass x (hs hx)) (by
+      filter_upwards [hae] with x hx hxr
+      exact hx (hs hxr))
+  refine ⟨P,hP,hd,hEq,hFP,?_⟩
+  obtain ⟨f,hfR,hf,hdf⟩ := spectralEndpointTest δ R hδR
+  apply spectralCutoffFlux_trace δ R hδ.le hδR
+    (spectralSecondFlux ell R w a u) (spectralSecondSource ell R w u c ζ) P
+    (spectralSecondContinuousSource ell R hR w u c ζ) hP hG hd hFP _ f hfR hf hdf
+    (B (spectralHarmonicPairTraces ell R hR u)).2
+  · simpa only [hfR,star_one,one_mul] using spectralSecond_boundaryFlux ell R hR w a u c ζ B f (he f)
+  · have hsource := (ae_restrict_iff' measurableSet_Icc).mp (spectralSecondSource_ae ell R hR w u c ζ)
+    filter_upwards [hsource] with x hx hxr
+    exact hx ⟨hδ.le.trans hxr.1,hxr.2⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondCorePower.lean

@@ -0,0 +1,87 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondClassicalFlux
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralEulerRegularBranch
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialCoreLocality
+
+namespace OAI
+
+/-! A limiting weak kernel is a regular harmonic power inside the constrained core. -/
+
+open Set MeasureTheory Filter Topology
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+theorem spectralHarmonicCore_representative_zero (ell : ℕ) (R l : ℝ) (hR : 0 < R)
+    (hlR : l ≤ R) (u : SpectralHarmonicPair ell R)
+    (hu : u ∈ spectralHarmonicCoreSubspace ell R l) (x : ℝ) (hx : x ∈ Ioc 0 l) :
+    spectralHarmonicRepresentative ell R hR u.fst x=0 := by
+  rw [spectralHarmonicCore_mem] at hu
+  change spectralRadialRepresentative R hR (spectralHarmonicRadialForget ell R u.fst) x=0
+  rw [spectralRadialRepresentative,dite_eq_left hx.1]
+  exact spectralRadialCore_point_zero_of_le R l x hR hx.1 hx.2 hlR _ hu
+
+theorem spectralSecond_core_power (ell : ℕ) (R l : ℝ) (hR : 0 < R)
+    (hl : 0 < l) (hlR : l < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (B : ℂ × ℂ →L[ℂ] ℂ × ℂ)
+    (hu : u ∈ spectralHarmonicCoreSubspace ell R l)
+    (hw : ContinuousOn w.density (Ioo 0 R)) (ha : ContinuousOn a.density (Ioo 0 R))
+    (hpos : ∀ x ∈ Ioo 0 R, 0 < w.density x)
+    (hcore : ∀ x ∈ Ioc 0 l, w.density x=1)
+    (he : ∀ f : 𝓢(ℝ,ℂ),
+      spectralHarmonicPairComplexForm ell R w u (spectralSecondTest ell R f)=
+      inner ℂ (spectralLowerOrderOperator ell R hR
+        (spectralRadialWeightMultiplier R w) (spectralRadialWeightMultiplier R a) c ζ B
+        (spectralHarmonicObservation ell R hR u)) (spectralSecondTest ell R f)) :
+    ∃ C : ℂ, (∀ x ∈ Ioc 0 l, spectralHarmonicRepresentative ell R hR u.snd x=C*(x : ℂ)^ell) ∧
+      deriv (spectralHarmonicRepresentative ell R hR u.snd) l=
+        (ell : ℂ)*spectralHarmonicRepresentative ell R hR u.snd l/(l : ℂ) := by
+  let g := spectralHarmonicRepresentative ell R hR u.snd
+  let P := spectralSecondClassicalFlux ell R hR w a u
+  obtain ⟨hg,hgc,hP⟩ := spectralSecond_classical ell R hR w a u c ζ B hw ha hpos he
+  have hsub : Ioc 0 l ⊆ Ioo 0 R := fun x hx => ⟨hx.1,hx.2.trans_lt hlR⟩
+  have hz (x : ℝ) (hx : x ∈ Ioc 0 l) :=
+    spectralHarmonicCore_representative_zero ell R l hR hlR.le u hu x hx
+  have hflux (x : ℝ) (hx : x ∈ Ioc 0 l) : P x=(x : ℂ)^11*deriv g x := by
+    dsimp only [P,spectralSecondClassicalFlux,g]
+    rw [hcore x hx,hz x hx]
+    simp
+  have hdg (x : ℝ) (hx : x ∈ Ioo 0 l) : HasDerivAt g (P x/(x : ℂ)^11) x := by
+    have hd := (hg x (hsub (Ioo_subset_Ioc_self hx))).differentiableAt
+      (Ioo_mem_nhds hx.1 (hx.2.trans hlR))
+    have hxn : (x : ℂ)^11 ≠ 0 := pow_ne_zero _ (by exact_mod_cast hx.1.ne')
+    rw [hflux x (Ioo_subset_Ioc_self hx),mul_div_cancel_left₀ _ hxn]
+    exact hd.hasDerivAt
+  have hdP (x : ℝ) (hx : x ∈ Ioo 0 l) :
+      HasDerivAt P ((ell : ℂ)*((ell : ℂ)+10)*(x : ℂ)^9*g x) x := by
+    have hp := hP x (hsub (Ioo_subset_Ioc_self hx))
+    simpa only [spectralSecondContinuousSource,hcore x (Ioo_subset_Ioc_self hx),
+      hz x (Ioo_subset_Ioc_self hx),one_smul,smul_zero,mul_zero,add_zero,
+      Complex.ofReal_mul,Complex.ofReal_add,Complex.ofReal_natCast,Complex.ofReal_ofNat] using hp
+  obtain ⟨C,hC⟩ := spectralEuler_regular_branch ell l hl g P hdg hdP
+    (spectralRadialRepresentative_origin_decay R hR (spectralHarmonicRadialForget ell R u.snd) ell)
+  have hclosed : Ioc (0 : ℝ) l ⊆ closure (Ioo 0 l) := by
+    rw [closure_Ioo hl.ne]
+    exact Ioc_subset_Icc_self
+  have hCE : EqOn g (fun x : ℝ => C*(x : ℂ)^ell) (Ioo 0 l) := hC
+  have hCfull : EqOn g (fun x : ℝ => C*(x : ℂ)^ell) (Ioc 0 l) :=
+    hCE.of_subset_closure ((spectralHarmonicRepresentative_continuousOn ell R hR u.snd).mono hsub)
+      (by fun_prop) Ioo_subset_Ioc_self hclosed
+  refine ⟨C,hCfull,?_⟩
+  have hderiv : EqOn (deriv g) (fun x : ℝ => (ell : ℂ)*g x/(x : ℂ)) (Ioo 0 l) := by
+    intro x hx
+    have heq : g =ᶠ[𝓝 x] fun y : ℝ => C*(y : ℂ)^ell := by
+      filter_upwards [Ioo_mem_nhds hx.1 hx.2] with y hy
+      exact hC y hy
+    have hd := ((spectralRadialPower_hasDerivAt ell x hx.1.ne').const_mul C).congr_of_eventuallyEq heq
+    rw [hd.deriv]
+    change C*((ell : ℂ)*(x : ℂ)^ell/(x : ℂ))=(ell : ℂ)*g x/(x : ℂ)
+    rw [hC x hx]
+    ring
+  have hfcont : ContinuousOn (fun x : ℝ => (ell : ℂ)*g x/(x : ℂ)) (Ioc 0 l) :=
+    (continuousOn_const.mul ((spectralHarmonicRepresentative_continuousOn ell R hR u.snd).mono hsub)).div
+      Complex.continuous_ofReal.continuousOn (fun x hx => by exact_mod_cast hx.1.ne')
+  exact (hderiv.of_subset_closure (hgc.mono hsub) hfcont Ioo_subset_Ioc_self hclosed) ⟨hl,le_rfl⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondFluxDerivative.lean

@@ -0,0 +1,52 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondFluxPrimitive
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialLocalDerivative
+
+namespace OAI
+
+/-! Recover the classical second derivative coordinate from its continuous weighted flux. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+noncomputable def spectralSecondDerivativeValue (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R)
+    (P : ℝ → ℂ) (x : ℝ) : ℂ :=
+  (P x/(x : ℂ)^11 - (a.density x : ℂ)*spectralHarmonicRepresentative ell R hR u.fst x)/
+    (w.density x : ℂ)
+
+theorem spectralSecondFlux_hasDerivAt (ell : ℕ) (R l r : ℝ) (hR : 0 < R)
+    (hl : 0 < l) (hr : r ≤ R) (w a : SpectralHarmonicWeight R)
+    (u : SpectralHarmonicPair ell R) (P : ℝ → ℂ)
+    (hw : ContinuousOn w.density (Ioo l r)) (ha : ContinuousOn a.density (Ioo l r))
+    (hpos : ∀ x ∈ Ioo l r, 0 < w.density x) (hP : ContinuousOn P (Ioo l r))
+    (hflux : ∀ᵐ x, x ∈ Ioo l r → spectralSecondFlux ell R w a u x=P x)
+    (x : ℝ) (hx : x ∈ Ioo l r) :
+    HasDerivAt (spectralHarmonicRepresentative ell R hR u.snd)
+      (spectralSecondDerivativeValue ell R hR w a u P x) x := by
+  have hs : Ioo l r ⊆ Ioo 0 R := fun t ht => ⟨hl.trans ht.1,ht.2.trans_le hr⟩
+  have hn (t : ℝ) (ht : t ∈ Ioo l r) : (t : ℂ)^11 ≠ 0 :=
+    pow_ne_zero _ (by exact_mod_cast (hl.trans ht.1).ne')
+  have hm (t : ℝ) (ht : t ∈ Ioo l r) : (w.density t : ℂ) ≠ 0 :=
+    by exact_mod_cast (hpos t ht).ne'
+  have hF : ContinuousOn (spectralSecondDerivativeValue ell R hR w a u P) (Ioo l r) :=
+    ((hP.div (Complex.continuous_ofReal.continuousOn.pow 11) hn).sub
+      ((Complex.continuous_ofReal.comp_continuousOn ha).mul
+        ((spectralHarmonicRepresentative_continuousOn ell R hR u.fst).mono hs))).div
+          (Complex.continuous_ofReal.comp_continuousOn hw) hm
+  have hf := (ae_restrict_iff' measurableSet_Icc).mp
+    (spectralHarmonicRepresentative_ae ell R hR u.fst)
+  apply spectralRadialRepresentative_hasDerivAt_local R l r hR hl hr
+    (spectralHarmonicRadialForget ell R u.snd) _ hF _ x hx
+  filter_upwards [hflux,hf] with t ht hf htmem
+  have hft := hf (Ioo_subset_Icc_self (hs htmem))
+  change spectralHarmonicDerivative ell R u.snd t = _
+  apply (eq_div_iff (hm t htmem)).mpr
+  have he : (w.density t : ℂ)*spectralHarmonicDerivative ell R u.snd t +
+      (a.density t : ℂ)*spectralHarmonicRepresentative ell R hR u.fst t = P t/(t : ℂ)^11 := by
+    apply (eq_div_iff (hn t htmem)).mpr
+    simpa only [spectralSecondFlux,Complex.real_smul,← hft,mul_comm] using ht htmem
+  linear_combination he
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondFluxPrimitive.lean

@@ -0,0 +1,56 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondFluxRegularity
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactRadialTest
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralLocalFluxPrimitive
+
+namespace OAI
+
+/-! The actual second weak equation gives a continuous flux across every interior radius. -/
+
+open Set MeasureTheory
+open scoped SchwartzMap ContDiff
+namespace DefocusingNLS
+
+theorem spectralSecondFlux_primitive (ell : ℕ) (R l r : ℝ) (hR : 0 < R)
+    (hl : 0 < l) (hlr : l < r) (hr : r < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (B : ℂ × ℂ →L[ℂ] ℂ × ℂ)
+    (hw : ContinuousOn w.density (Ioo 0 R)) (ha : ContinuousOn a.density (Ioo 0 R))
+    (he : ∀ f : 𝓢(ℝ,ℂ),
+      spectralHarmonicPairComplexForm ell R w u (spectralSecondTest ell R f)=
+      inner ℂ (spectralLowerOrderOperator ell R hR
+        (spectralRadialWeightMultiplier R w) (spectralRadialWeightMultiplier R a) c ζ B
+        (spectralHarmonicObservation ell R hR u)) (spectralSecondTest ell R f)) :
+    ∃ P : ℝ → ℂ,
+      (∀ x ∈ Ioo l r, HasDerivAt P (spectralSecondContinuousSource ell R hR w u c ζ x) x) ∧
+      ∀ᵐ x, x ∈ Ioo l r → spectralSecondFlux ell R w a u x=P x := by
+  apply spectralLocalFlux_primitive R l r hl hlr hr
+    (spectralSecondFlux ell R w a u) (spectralSecondContinuousSource ell R hR w u c ζ)
+    (spectralSecondFlux_locallyIntegrableOn ell R w a u hw ha)
+    (spectralSecondContinuousSource_continuousOn ell R hR w u c ζ hw)
+  intro φ hφ hφc hφs
+  let f := spectralRealSchwartzTest φ hφ hφc
+  have hφR : φ R=0 := image_eq_zero_of_notMem_tsupport
+    (fun h => (lt_irrefl R) (hφs h).2)
+  have hfR : f R=0 := by simp only [f,spectralRealSchwartzTest_apply,hφR,Complex.ofReal_zero]
+  have hbal := spectralSecondTest_balance ell R hR w a u c ζ B f hfR (he f)
+  have ht := spectralSecondBalance_to_flux ell R hR w a u c ζ f hbal
+  simp only [f,spectralRealSchwartzTest_deriv,spectralRealSchwartzTest_apply,
+    Complex.star_def,Complex.conj_ofReal,← Complex.real_smul] at ht
+  rw [spectralCompactTest_integral R (deriv φ) _ (tsupport_deriv_subset.trans hφs),
+    spectralCompactTest_integral R φ _ hφs] at ht
+  have hs : (∫ x, φ x • spectralSecondSource ell R w u c ζ x)=
+      ∫ x, φ x • spectralSecondContinuousSource ell R hR w u c ζ x := by
+    apply integral_congr_ae
+    have hae := (ae_restrict_iff' measurableSet_Icc).mp
+      (spectralSecondSource_ae ell R hR w u c ζ)
+    filter_upwards [hae] with x hx
+    by_cases hmem : x ∈ Icc (0 : ℝ) R
+    · rw [hx hmem]
+    · have hz : φ x=0 := image_eq_zero_of_notMem_tsupport
+        (fun h => hmem (Ioo_subset_Icc_self (hφs h)))
+      simp only [hz,zero_smul]
+  rwa [hs] at ht
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondFluxRegularity.lean

@@ -0,0 +1,49 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondFluxTesting
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralHarmonicRepresentative
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRadialLocalIntegrable
+
+namespace OAI
+
+/-! The weak flux is locally integrable and its source has a continuous representative. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+noncomputable def spectralSecondContinuousSource (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ) (r : ℝ) : ℂ :=
+  (((ell : ℝ)*(ell+10) : ℝ) : ℂ)*(r : ℂ)^9*
+    (w.density r • spectralHarmonicRepresentative ell R hR u.snd r) +
+  (c-ζ)*(r : ℂ)^11*(w.density r • spectralHarmonicRepresentative ell R hR u.fst r)
+
+theorem spectralSecondContinuousSource_continuousOn (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (hw : ContinuousOn w.density (Ioo 0 R)) :
+    ContinuousOn (spectralSecondContinuousSource ell R hR w u c ζ) (Ioo 0 R) := by
+  have hf := spectralHarmonicRepresentative_continuousOn ell R hR u.fst
+  have hg := spectralHarmonicRepresentative_continuousOn ell R hR u.snd
+  exact ((continuousOn_const.mul (Complex.continuous_ofReal.continuousOn.pow 9)).mul
+    (hw.smul hg)).add
+      ((continuousOn_const.mul (Complex.continuous_ofReal.continuousOn.pow 11)).mul (hw.smul hf))
+
+theorem spectralSecondSource_ae (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ) :
+    spectralSecondSource ell R w u c ζ =ᵐ[volume.restrict (Icc 0 R)]
+      spectralSecondContinuousSource ell R hR w u c ζ := by
+  filter_upwards [spectralHarmonicRepresentative_ae ell R hR u.fst,
+    spectralHarmonicRepresentative_ae ell R hR u.snd] with r hf hg
+  simp only [spectralSecondSource,spectralSecondContinuousSource,hf,hg]
+
+theorem spectralSecondFlux_locallyIntegrableOn (ell : ℕ) (R : ℝ)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R)
+    (hw : ContinuousOn w.density (Ioo 0 R)) (ha : ContinuousOn a.density (Ioo 0 R)) :
+    LocallyIntegrableOn (spectralSecondFlux ell R w a u) (Ioo 0 R) := by
+  have hd := spectralRadialL2_locallyIntegrableOn R (spectralHarmonicDerivative ell R u.snd)
+  have hv := spectralRadialL2_locallyIntegrableOn R (spectralHarmonicValue ell R u.fst)
+  have h1 := hd.continuousOn_smul isOpen_Ioo.isLocallyClosed hw
+  have h2 := hv.continuousOn_smul isOpen_Ioo.isLocallyClosed ha
+  exact (h1.add h2).continuousOn_smul isOpen_Ioo.isLocallyClosed
+    (Complex.continuous_ofReal.continuousOn.pow 11)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondFluxTesting.lean

@@ -0,0 +1,100 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSecondBalance
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightedTestIntegrable
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralMeasureIntegrability
+
+namespace OAI
+
+/-! The scalar balance is the ordinary weak derivative equation for the weighted flux. -/
+
+open MeasureTheory
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+noncomputable def spectralSecondFlux (ell : ℕ) (R : ℝ) (w a : SpectralHarmonicWeight R)
+    (u : SpectralHarmonicPair ell R) (r : ℝ) : ℂ :=
+  (r : ℂ)^11*(w.density r • spectralHarmonicDerivative ell R u.snd r +
+    a.density r • spectralHarmonicValue ell R u.fst r)
+
+noncomputable def spectralSecondSource (ell : ℕ) (R : ℝ) (w : SpectralHarmonicWeight R)
+    (u : SpectralHarmonicPair ell R) (c ζ : ℂ) (r : ℝ) : ℂ :=
+  (((ell : ℝ)*(ell+10) : ℝ) : ℂ)*(r : ℂ)^9*
+    (w.density r • spectralHarmonicValue ell R u.snd r) +
+  (c-ζ)*(r : ℂ)^11*(w.density r • spectralHarmonicValue ell R u.fst r)
+
+theorem spectralSecondBalance_to_flux (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w a : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R) (c ζ : ℂ)
+    (f : 𝓢(ℝ,ℂ))
+    (hbal :
+      (∫ r, star (deriv f r)*(w.density r • spectralHarmonicDerivative ell R u.snd r)
+        ∂radialPressureMeasure R) +
+      (((ell : ℝ)*(ell+10) : ℝ) : ℂ)*
+        (∫ r, star (f r)*(w.density r • spectralHarmonicValue ell R u.snd r)
+          ∂spectralAngularMeasure R) +
+      (c-ζ)*(∫ r, star (f r)*(w.density r • spectralHarmonicValue ell R u.fst r)
+        ∂radialPressureMeasure R) +
+      (∫ r, star (deriv f r)*(a.density r • spectralHarmonicValue ell R u.fst r)
+        ∂radialPressureMeasure R)=0) :
+    (∫ r in (0 : ℝ)..R, star (deriv f r)*spectralSecondFlux ell R w a u r)=
+      -(∫ r in (0 : ℝ)..R, star (f r)*spectralSecondSource ell R w u c ζ r) := by
+  let J₁ := fun r => star (deriv f r)*(w.density r • spectralHarmonicDerivative ell R u.snd r)
+  let J₂ := fun r => star (deriv f r)*(a.density r • spectralHarmonicValue ell R u.fst r)
+  let J₃ := fun r => star (f r)*(w.density r • spectralHarmonicValue ell R u.snd r)
+  let J₄ := fun r => star (f r)*(w.density r • spectralHarmonicValue ell R u.fst r)
+  let η : ℂ := (((ell : ℝ)*(ell+10) : ℝ) : ℂ)
+  have hd (v : SpectralRadialL2 R) (b : SpectralHarmonicWeight R) :
+      Integrable (fun r => star (deriv f r)*(b.density r • v r)) (radialPressureMeasure R) :=
+    spectralWeightedTest_integrable _ _ b.radial_measurable b.bound b.radial_bound v
+      (spectralHarmonicDerivative ell R (spectralHarmonicSmoothEmbedding ell R f))
+      (deriv f) (spectralHarmonicDerivative_smooth_ae ell R f)
+  have hv (v : SpectralRadialL2 R) :
+      Integrable (fun r => star (f r)*(w.density r • v r)) (radialPressureMeasure R) :=
+    spectralWeightedTest_integrable _ _ w.radial_measurable w.bound w.radial_bound v
+      (spectralHarmonicValue ell R (spectralHarmonicSmoothEmbedding ell R f))
+      f (spectralHarmonicValue_smooth_ae ell R f)
+  have hi₁ : IntervalIntegrable (fun r => (r : ℂ)^11*J₁ r) volume 0 R :=
+    (intervalIntegrable_iff_integrableOn_Icc_of_le hR.le).mpr
+      (spectralRadial_integrableOn R J₁ (hd _ w))
+  have hi₂ : IntervalIntegrable (fun r => (r : ℂ)^11*J₂ r) volume 0 R :=
+    (intervalIntegrable_iff_integrableOn_Icc_of_le hR.le).mpr
+      (spectralRadial_integrableOn R J₂ (hd _ a))
+  have hi₄ : IntervalIntegrable (fun r => (r : ℂ)^11*J₄ r) volume 0 R :=
+    (intervalIntegrable_iff_integrableOn_Icc_of_le hR.le).mpr
+      (spectralRadial_integrableOn R J₄ (hv _))
+  have hi₃ : IntervalIntegrable (fun r => η*((r : ℂ)^9*J₃ r)) volume 0 R := by
+    have hi := (intervalIntegrable_iff_integrableOn_Icc_of_le hR.le).mpr
+      (spectralAngular_integrableOn R _ (spectralAngularTest_integrable ell R w u.snd f))
+    convert hi using 1
+    funext r
+    dsimp only [η,J₃]
+    ring
+  have hflux : (∫ r in (0 : ℝ)..R, star (deriv f r)*spectralSecondFlux ell R w a u r)=
+      (∫ r in (0 : ℝ)..R, (r : ℂ)^11*J₁ r)+
+        ∫ r in (0 : ℝ)..R, (r : ℂ)^11*J₂ r := by
+    rw [← intervalIntegral.integral_add hi₁ hi₂]
+    apply intervalIntegral.integral_congr
+    intro r _
+    dsimp only [spectralSecondFlux,J₁,J₂]
+    ring
+  have hsource : (∫ r in (0 : ℝ)..R, star (f r)*spectralSecondSource ell R w u c ζ r)=
+      η*(∫ r in (0 : ℝ)..R, (r : ℂ)^9*J₃ r)+
+        (c-ζ)*(∫ r in (0 : ℝ)..R, (r : ℂ)^11*J₄ r) := by
+    rw [← intervalIntegral.integral_const_mul,← intervalIntegral.integral_const_mul,
+      ← intervalIntegral.integral_add hi₃ (hi₄.const_mul (c-ζ))]
+    apply intervalIntegral.integral_congr
+    intro r _
+    dsimp only [spectralSecondSource,J₃,J₄,η]
+    ring
+  rw [hflux,hsource]
+  change (∫ r, J₁ r ∂radialPressureMeasure R)+
+    η*(∫ r, J₃ r ∂spectralAngularMeasure R)+
+    (c-ζ)*(∫ r, J₄ r ∂radialPressureMeasure R)+
+    (∫ r, J₂ r ∂radialPressureMeasure R)=0 at hbal
+  rw [spectral_radial_complex_integral R hR.le,
+    spectral_angular_complex_integral R hR.le,
+    spectral_radial_complex_integral R hR.le,
+    spectral_radial_complex_integral R hR.le] at hbal
+  linear_combination hbal
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSecondTest.lean

@@ -0,0 +1,71 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilComplexEquation
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralHarmonicScalarPairing
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralLowerOrderOperator
+
+namespace OAI
+
+/-! The second scalar equation may be tested across the constrained core boundary. -/
+
+open MeasureTheory
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+noncomputable def spectralSecondTest (ell : ℕ) (R : ℝ) (f : 𝓢(ℝ,ℂ)) :
+    SpectralHarmonicPair ell R :=
+  (WithLp.prodContinuousLinearEquiv 2 ℂ (SpectralHarmonicEnergy ell R)
+    (SpectralHarmonicEnergy ell R)).symm (0,spectralHarmonicSmoothEmbedding ell R f)
+
+theorem spectralSecondTest_core (ell : ℕ) (R l : ℝ) (f : 𝓢(ℝ,ℂ)) :
+    spectralSecondTest ell R f ∈ spectralHarmonicCoreSubspace ell R l := by
+  rw [spectralHarmonicCore_mem]
+  change (fun r => spectralHarmonicValue ell R 0 r)=ᵐ[_] 0
+  simp only [map_zero]
+  exact ae_restrict_of_ae (Lp.coeFn_zero ℂ 2 (radialPressureMeasure R))
+
+theorem spectralSecondTest_values (ell : ℕ) (R : ℝ) (f : 𝓢(ℝ,ℂ)) :
+    spectralHarmonicPairValues ell R (spectralSecondTest ell R f)=
+      (0,spectralHarmonicValue ell R (spectralHarmonicSmoothEmbedding ell R f)) := by
+  change (spectralHarmonicValue ell R 0,_)=_
+  rw [map_zero]
+  rfl
+
+theorem spectralSecondTest_derivatives (ell : ℕ) (R : ℝ) (f : 𝓢(ℝ,ℂ)) :
+    spectralHarmonicPairDerivatives ell R (spectralSecondTest ell R f)=
+      (0,spectralHarmonicDerivative ell R (spectralHarmonicSmoothEmbedding ell R f)) := by
+  change (spectralHarmonicDerivative ell R 0,_)=_
+  rw [map_zero]
+  rfl
+
+theorem spectralSecondTest_traces (ell : ℕ) (R : ℝ) (hR : 0 < R) (f : 𝓢(ℝ,ℂ)) :
+    spectralHarmonicPairTraces ell R hR (spectralSecondTest ell R f)=(0,f R) := by
+  change (spectralRadialTrace R hR 0,
+    spectralRadialTrace R hR (spectralRadialSmoothEmbedding R f))=_
+  rw [map_zero,spectralRadialTrace_smooth]
+
+theorem spectralSecondTest_equation (ell : ℕ) (R : ℝ) (hR : 0 < R)
+    (w : SpectralHarmonicWeight R) (u : SpectralHarmonicPair ell R)
+    (Q A : SpectralRadialL2 R →L[ℂ] SpectralRadialL2 R) (c ζ : ℂ)
+    (B : ℂ × ℂ →L[ℂ] ℂ × ℂ) (z : SpectralRadialObservationSpace R)
+    (f : 𝓢(ℝ,ℂ))
+    (he : spectralHarmonicPairComplexForm ell R w u (spectralSecondTest ell R f)=
+      inner ℂ (spectralLowerOrderOperator ell R hR Q A c ζ B z) (spectralSecondTest ell R f)) :
+    star (spectralHarmonicComplexForm ell R w u.snd (spectralHarmonicSmoothEmbedding ell R f))=
+      inner ℂ (spectralHarmonicValue ell R (spectralHarmonicSmoothEmbedding ell R f)) (Q z.1.2)-
+      (c-ζ)*inner ℂ (spectralHarmonicValue ell R (spectralHarmonicSmoothEmbedding ell R f)) (Q z.1.1)-
+      inner ℂ (spectralHarmonicDerivative ell R (spectralHarmonicSmoothEmbedding ell R f)) (A z.1.1)+
+      star (f R)*(B z.2).2 := by
+  have hs := congrArg star he
+  rw [spectral_star_inner,spectralLowerOrderOperator_inner] at hs
+  change star (spectralHarmonicComplexForm ell R w u.fst 0+
+    spectralHarmonicComplexForm ell R w u.snd (spectralHarmonicSmoothEmbedding ell R f))=_ at hs
+  have hz : spectralHarmonicComplexForm ell R w u.fst 0=0 := by
+    simp only [spectralHarmonicComplexForm,map_zero,inner_zero_right,add_zero]
+  rw [hz,zero_add] at hs
+  unfold spectralWeakPairing at hs
+  rw [spectralSecondTest_values,spectralSecondTest_derivatives,spectralSecondTest_traces] at hs
+  simpa only [inner_zero_left,zero_add,zero_sub,add_zero,RCLike.inner_apply',
+    sub_eq_add_neg,mul_neg,neg_mul,zero_mul,star_zero,starRingEnd_apply] using hs
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellAbsorption.lean

@@ -0,0 +1,74 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCouplingEstimate
+import Mathlib.Topology.Order.Compact
+import Mathlib.Topology.Order.Lattice
+
+namespace OAI
+
+/-! A compact-shell maximum makes the small Green and Robin corrections absorbable.
+No a priori bound on the size of a particular solution is required. -/
+
+open Set
+namespace DefocusingNLS
+
+theorem spectralShellPairNorm_add_le (kp km : ℝ) (hp : 0≤ kp) (hm : 0≤ km)
+    (u v : (ℂ × ℂ) × (ℂ × ℂ)) :
+    spectralShellPairNorm kp km (u+v)≤ spectralShellPairNorm kp km u+spectralShellPairNorm kp km v := by
+  apply max_le
+  · exact (spectralShellNorm_add_le kp hp u.1 v.1).trans
+      (add_le_add (le_max_left _ _) (le_max_left _ _))
+  · exact (spectralShellNorm_add_le km hm u.2 v.2).trans
+      (add_le_add (le_max_right _ _) (le_max_right _ _))
+
+theorem spectralShellPairNorm_continuousOn (R E : ℝ) (kp km : ℝ → ℝ)
+    (u : ℝ → (ℂ × ℂ) × (ℂ × ℂ))
+    (hkp : ContinuousOn kp (Icc R E)) (hkm : ContinuousOn km (Icc R E))
+    (hp : ∀ r ∈ Icc R E, kp r≠0) (hm : ∀ r ∈ Icc R E, km r≠0)
+    (hu : ContinuousOn u (Icc R E)) :
+    ContinuousOn (fun r => spectralShellPairNorm (kp r) (km r) (u r)) (Icc R E) := by
+  exact ((hkp.mul hu.fst.fst.norm).add ((hkp.inv₀ hp).mul hu.fst.snd.norm)).sup
+    ((hkm.mul hu.snd.fst.norm).add ((hkm.inv₀ hm).mul hu.snd.snd.norm))
+
+theorem spectralShellPairNorm_exists_max (R E : ℝ) (hRE : R≤ E)
+    (kp km : ℝ → ℝ) (u : ℝ → (ℂ × ℂ) × (ℂ × ℂ))
+    (hkp : ContinuousOn kp (Icc R E)) (hkm : ContinuousOn km (Icc R E))
+    (hp : ∀ r ∈ Icc R E, 0<kp r) (hm : ∀ r ∈ Icc R E, 0<km r)
+    (hu : ContinuousOn u (Icc R E)) :
+    ∃ M : ℝ, 0≤ M ∧ (∀ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (u r)≤ M) ∧
+      ∃ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (u r)=M := by
+  obtain ⟨r,hr,hmax⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr hRE)
+    (spectralShellPairNorm_continuousOn R E kp km u hkp hkm
+      (fun r hr => (hp r hr).ne') (fun r hr => (hm r hr).ne') hu)
+  exact ⟨_,spectralShellPairNorm_nonneg _ _ (hp r hr).le _,hmax,r,hr,rfl⟩
+
+theorem spectralShellPairNorm_absorb (R E B theta : ℝ) (hRE : R≤ E)
+    (htheta : 0≤ theta) (htheta1 : theta≤ 1/2)
+    (kp km : ℝ → ℝ) (u v : ℝ → (ℂ × ℂ) × (ℂ × ℂ))
+    (hkp : ContinuousOn kp (Icc R E)) (hkm : ContinuousOn km (Icc R E))
+    (hp : ∀ r ∈ Icc R E, 0<kp r) (hm : ∀ r ∈ Icc R E, 0<km r)
+    (hu : ContinuousOn u (Icc R E))
+    (hv : ∀ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (v r)≤ B)
+    (herror : ∀ M : ℝ, 0≤ M → (∀ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (u r)≤ M) →
+      ∀ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (u r-v r)≤ theta*M) :
+    ∀ r ∈ Icc R E, spectralShellPairNorm (kp r) (km r) (u r)≤ 2*B ∧
+      spectralShellPairNorm (kp r) (km r) (u r-v r)≤ 2*theta*B := by
+  obtain ⟨M,hM,hbound,s,hs,heq⟩ := spectralShellPairNorm_exists_max R E hRE kp km u
+    hkp hkm hp hm hu
+  have herr := herror M hM hbound
+  have hmax : M≤ theta*M+B := by
+    calc
+      M = spectralShellPairNorm (kp s) (km s) (u s) := heq.symm
+      _ = spectralShellPairNorm (kp s) (km s) ((u s-v s)+v s) := by rw [sub_add_cancel]
+      _ ≤ spectralShellPairNorm (kp s) (km s) (u s-v s)+
+          spectralShellPairNorm (kp s) (km s) (v s) :=
+        spectralShellPairNorm_add_le _ _ (hp s hs).le (hm s hs).le _ _
+      _ ≤ theta*M+B := add_le_add (herr s hs) (hv s hs)
+  have hMB : M≤ 2*B := by nlinarith
+  intro r hr
+  refine ⟨(hbound r hr).trans hMB, (herr r hr).trans ?_⟩
+  calc
+    theta*M≤ theta*(2*B) := mul_le_mul_of_nonneg_left hMB htheta
+    _ = _ := by ring
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellForcingContinuity.lean

@@ -0,0 +1,34 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralShellMatchedCoupling
+
+namespace OAI
+
+/-! Continuity of the actual two channel forcings on a positive shell. -/
+
+open Set
+namespace DefocusingNLS
+
+theorem spectralShellForcing_continuousOn (m : ℕ) (R E : ℝ) (hR : 0<R)
+    (Q : ℝ → ℂ) (u : ℝ → (ℂ × ℂ) × (ℂ × ℂ))
+    (hQ : ContinuousOn Q (Icc R E)) (hu : ContinuousOn u (Icc R E)) :
+    ContinuousOn (fun r => spectralShellPlusForcing m (Q r) r (u r)) (Icc R E) ∧
+      ContinuousOn (fun r => spectralShellMinusForcing m (Q r) r (u r)) (Icc R E) := by
+  have hfac (h : ℝ) : ContinuousOn (homogeneousSpectralLocalizationFactor h) (Icc R E) := by
+    intro r hr
+    exact (homogeneousSpectralLocalizationFactor_hasDerivAt h r
+      (hR.trans_le hr.1)).continuousAt.continuousWithinAt
+  have hne (h r : ℝ) : homogeneousSpectralLocalizationFactor h r≠0 := Complex.exp_ne_zero _
+  have hp := (hfac 1).div (hfac (-1)) (fun r _ => hne (-1) r)
+  have hm := (hfac (-1)).div (hfac 1) (fun r _ => hne 1 r)
+  have hD : ContinuousOn (fun r => spectralDiagonalCoefficient m (Q r)) (Icc R E) := by
+    dsimp only [spectralDiagonalCoefficient]
+    fun_prop
+  have hC : ContinuousOn (fun r => spectralCrossCoefficient m (Q r)) (Icc R E) := by
+    dsimp only [spectralCrossCoefficient]
+    fun_prop
+  constructor
+  · exact (hD.mul hu.fst.fst).add ((hC.mul hp).mul hu.snd.fst)
+  · exact (hD.star.mul hu.snd.fst).add ((hC.star.mul hm).mul hu.fst.fst)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellGoodPoint.lean

@@ -0,0 +1,43 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralRobinNormBounds
+import Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
+import Mathlib.Topology.Order.Compact
+
+namespace OAI
+
+/-! Select bounded Cauchy data in the first half of the shell from its
+integrated energy and the coercive local Robin relation. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+theorem spectral_interval_energy_point (a b K : ℝ) (hab : a < b)
+    (e : ℝ → ℝ) (he : ContinuousOn e (Icc a b)) (hbound : (∫ r in a..b, e r) ≤ K) :
+    ∃ r ∈ Icc a b, e r ≤ K/(b-a) := by
+  obtain ⟨r,hr,hmin⟩ := isCompact_Icc.exists_isMinOn (nonempty_Icc.mpr hab.le) he
+  refine ⟨r,hr,?_⟩
+  have hi := intervalIntegral.integral_mono_on (μ := volume) hab.le
+    (intervalIntegrable_const (c := e r)) (he.intervalIntegrable_of_Icc hab.le) (fun x hx => hmin hx)
+  rw [intervalIntegral.integral_const] at hi
+  simp only [smul_eq_mul] at hi
+  exact (le_div_iff₀ (sub_pos.mpr hab)).mpr (by nlinarith)
+
+theorem spectral_shell_good_point (a b K mu : ℝ) (hab : a < b) (hmu : 0 ≤ mu)
+    (q : ℝ → (ℂ × ℂ) × (ℂ × ℂ)) (hq : ContinuousOn q (Icc a b))
+    (hrobin : ∀ r ∈ Icc a b,
+      mu*(‖(q r).1.1‖+‖(q r).2.1‖) ≤ 2*(‖(q r).1.2‖+‖(q r).2.2‖))
+    (hbound : (∫ r in a..b, ‖(q r).1.2‖^2+‖(q r).2.2‖^2) ≤ K) :
+    ∃ r ∈ Icc a b, ‖(q r).1.2‖^2+‖(q r).2.2‖^2 ≤ K/(b-a) ∧
+      mu^2*(‖(q r).1.1‖^2+‖(q r).2.1‖^2) ≤ 8*(K/(b-a)) := by
+  obtain ⟨r,hr,hb⟩ := spectral_interval_energy_point a b K hab
+    (fun r => ‖(q r).1.2‖^2+‖(q r).2.2‖^2)
+    ((hq.fst.snd.norm.pow 2).add (hq.snd.snd.norm.pow 2)) hbound
+  refine ⟨r,hr,hb,?_⟩
+  have hc := hrobin r hr
+  have hs := pow_le_pow_left₀ (mul_nonneg hmu (by positivity)) hc 2
+  have hcross := sq_nonneg (‖(q r).1.2‖-‖(q r).2.2‖)
+  have hp : 0 ≤ mu^2*‖(q r).1.1‖*‖(q r).2.1‖ := by positivity
+  nlinarith only [hs,hcross,hp,hb]
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellGreenBounds.lean

@@ -0,0 +1,77 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralShellNorm
+import Mathlib.Analysis.SpecialFunctions.ExpDeriv
+
+namespace OAI
+
+/-! The two action factors in the scalar Green kernel stay in their own channel.
+No comparison between the actions of distinct channels is needed. -/
+
+namespace DefocusingNLS
+
+private theorem action_ratio (C c k H A B : ℝ)
+    (hc : c≠0) (hk : k≠0) :
+    (C*Real.exp A/k)/(c*Real.exp H)*(C*Real.exp (H-B))=
+      C^2/(c*k)*Real.exp (A-B) := by
+  have he : Real.exp A*Real.exp (H-B)=Real.exp H*Real.exp (A-B) := by
+    rw [← Real.exp_add,← Real.exp_add]
+    congr 1
+    ring
+  field_simp
+  linear_combination C^2*he
+
+theorem spectralShellNorm_green_factor (kr kt C c HR Hr Ht : ℝ)
+    (hkr : 0≤ kr) (hkt : 0<kt) (hC : 0≤ C) (hc : 0<c)
+    (D U : ℂ × ℂ) (W : ℂ)
+    (hD : spectralShellNorm kr D≤ C*Real.exp (HR-Hr))
+    (hU : spectralShellNorm kt U≤ C*Real.exp Ht)
+    (hW : c*Real.exp HR≤‖W‖) :
+    spectralShellNorm kr ((U.1/W) • D)≤ C^2/(c*kt)*Real.exp (Ht-Hr) := by
+  have hw : 0<‖W‖ := lt_of_lt_of_le (mul_pos hc (Real.exp_pos _)) hW
+  have hD0 := spectralShellNorm_nonneg kr hkr D
+  have hU0 := spectralShellNorm_nonneg kt hkt.le U
+  have hv := spectralShellNorm_value kt hkt U
+  rw [spectralShellNorm_smul,norm_div]
+  calc
+    _ ≤ (spectralShellNorm kt U/kt)/‖W‖*spectralShellNorm kr D := by
+      gcongr
+    _ ≤ (C*Real.exp Ht/kt)/(c*Real.exp HR)*(C*Real.exp (HR-Hr)) := by
+      gcongr
+    _ = _ := action_ratio C c kt HR Ht Hr hc.ne' hkt.ne'
+
+theorem spectralScalarGreenState_shell_bound
+    (D U : ℝ → ℂ × ℂ) (W : ℂ) (k H : ℝ → ℝ)
+    (C c HR r t : ℝ) (hC : 0≤ C) (hc : 0<c)
+    (hkr : 0<k r) (hkt : 0<k t)
+    (hD : ∀ s ∈ ({r,t} : Set ℝ), spectralShellNorm (k s) (D s)≤ C*Real.exp (HR-H s))
+    (hU : ∀ s ∈ ({r,t} : Set ℝ), spectralShellNorm (k s) (U s)≤ C*Real.exp (H s))
+    (hW : c*Real.exp HR≤‖W‖)
+    (hH : AntitoneOn H (Set.Icc (min r t) (max r t))) :
+    spectralShellNorm (k r) (spectralScalarGreenState D U W r t)≤ C^2/(c*k t) := by
+  have hrmem : r ∈ Set.Icc (min r t) (max r t) := ⟨min_le_left _ _,le_max_left _ _⟩
+  have htmem : t ∈ Set.Icc (min r t) (max r t) := ⟨min_le_right _ _,le_max_right _ _⟩
+  have hrr : r ∈ ({r,t} : Set ℝ) := by simp only [Set.mem_insert_iff,true_or]
+  have htt : t ∈ ({r,t} : Set ℝ) := by simp only [Set.mem_insert_iff,Set.mem_singleton_iff,or_true]
+  have hconst : 0≤ C^2/(c*k t) := by positivity
+  by_cases hrt : r≤ t
+  · rw [spectralScalarGreenState,ite_eq_left hrt]
+    apply (spectralShellNorm_green_factor (k r) (k t) C c HR (H r) (H t)
+      hkr.le hkt hC hc (D r) (U t) W (hD r hrr) (hU t htt) hW).trans
+    calc
+      _ ≤ C^2/(c*k t)*1 := mul_le_mul_of_nonneg_left
+        (Real.exp_le_one_iff.mpr (sub_nonpos.mpr (hH hrmem htmem hrt))) hconst
+      _ = _ := mul_one _
+  · rw [spectralScalarGreenState,ite_eq_right hrt]
+    have hb := spectralShellNorm_green_factor (k r) (k t) C c HR
+      (HR-H r) (HR-H t) hkr.le hkt hC hc (U r) (D t) W
+      (by simpa only [sub_sub_cancel] using hU r hrr) (hD t htt) hW
+    have he : (HR-H t)-(HR-H r)=H r-H t := by ring
+    rw [he] at hb
+    apply hb.trans
+    calc
+      _ ≤ C^2/(c*k t)*1 := mul_le_mul_of_nonneg_left
+        (Real.exp_le_one_iff.mpr (sub_nonpos.mpr (hH htmem hrmem (le_of_not_ge hrt)))) hconst
+      _ = _ := mul_one _
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellInnerRobin.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCoupledBoundarySystem
+
+namespace OAI
+
+/-! The coupled Green error gives both local Robin errors, including when
+one of the channel values is zero. -/
+
+open Set
+namespace DefocusingNLS
+
+theorem spectralCoupled_inner_robin_bound {R E A : ℝ}
+    (Sp Sm : SpectralScalarBoundarySystem R E A) (hRE : R ≤ E)
+    (q : (ℂ × ℂ) × (ℂ × ℂ)) (eps : ℝ)
+    (herr : spectralShellPairNorm (Sp.k R) (Sm.k R)
+      (q-(Sp.extension q.1.1 R,Sm.extension q.2.1 R)) ≤
+      eps*max (Sp.k R*‖q.1.1‖) (Sm.k R*‖q.2.1‖)) :
+    ‖q.1.2-((Sp.U R).2/(Sp.U R).1)*q.1.1‖ ≤
+      Sp.k R*(eps*max (Sp.k R*‖q.1.1‖) (Sm.k R*‖q.2.1‖)) ∧
+    ‖q.2.2-((Sm.U R).2/(Sm.U R).1)*q.2.1‖ ≤
+      Sm.k R*(eps*max (Sp.k R*‖q.1.1‖) (Sm.k R*‖q.2.1‖)) := by
+  constructor
+  · apply Sp.inner_slope_bound hRE q.1
+    exact (le_max_left _ _).trans herr
+  · apply Sm.inner_slope_bound hRE q.2
+    exact (le_max_right _ _).trans herr
+
+theorem spectralCoupled_inner_robin_scaled {R E A : ℝ}
+    (Sp Sm : SpectralScalarBoundarySystem R E A) (hRE : R ≤ E)
+    (q : (ℂ × ℂ) × (ℂ × ℂ)) (eps C : ℝ) (heps : 0 ≤ eps)
+    (hp : (Sp.k R)^2 ≤ C) (hm : (Sm.k R)^2 ≤ C)
+    (herr : spectralShellPairNorm (Sp.k R) (Sm.k R)
+      (q-(Sp.extension q.1.1 R,Sm.extension q.2.1 R)) ≤
+      eps*max (Sp.k R*‖q.1.1‖) (Sm.k R*‖q.2.1‖)) :
+    ‖q.1.2-((Sp.U R).2/(Sp.U R).1)*q.1.1‖ ≤ eps*C*(‖q.1.1‖+‖q.2.1‖) ∧
+    ‖q.2.2-((Sm.U R).2/(Sm.U R).1)*q.2.1‖ ≤ eps*C*(‖q.1.1‖+‖q.2.1‖) := by
+  have hkp := (Sp.positive_k R ⟨le_rfl,hRE⟩).le
+  have hkm := (Sm.positive_k R ⟨le_rfl,hRE⟩).le
+  have hc : Sp.k R*Sm.k R ≤ C := by nlinarith [sq_nonneg (Sp.k R-Sm.k R)]
+  have hmax : max (Sp.k R*‖q.1.1‖) (Sm.k R*‖q.2.1‖) ≤
+      Sp.k R*‖q.1.1‖+Sm.k R*‖q.2.1‖ :=
+    max_le (le_add_of_nonneg_right (mul_nonneg hkm (norm_nonneg _)))
+      (le_add_of_nonneg_left (mul_nonneg hkp (norm_nonneg _)))
+  have hb := spectralCoupled_inner_robin_bound Sp Sm hRE q eps herr
+  constructor
+  · apply hb.1.trans
+    calc
+      _ ≤ Sp.k R*(eps*(Sp.k R*‖q.1.1‖+Sm.k R*‖q.2.1‖)) := by gcongr
+      _ = eps*((Sp.k R)^2*‖q.1.1‖+(Sp.k R*Sm.k R)*‖q.2.1‖) := by ring
+      _ ≤ eps*(C*‖q.1.1‖+C*‖q.2.1‖) := by gcongr
+      _ = _ := by ring
+  · apply hb.2.trans
+    calc
+      _ ≤ Sm.k R*(eps*(Sp.k R*‖q.1.1‖+Sm.k R*‖q.2.1‖)) := by gcongr
+      _ = eps*((Sp.k R*Sm.k R)*‖q.1.1‖+(Sm.k R)^2*‖q.2.1‖) := by ring
+      _ ≤ eps*(C*‖q.1.1‖+C*‖q.2.1‖) := by gcongr
+      _ = _ := by ring
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellIntegral.lean

@@ -0,0 +1,41 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralShellNorm
+
+namespace OAI
+
+/-! Integration in the scaled value/derivative norm on a finite interval. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+theorem spectralShellNorm_integral_le (a b k : ℝ) (hab : a≤ b) (hk : 0≤ k)
+    (F : ℝ → ℂ × ℂ) (hF : ContinuousOn F (Icc a b)) :
+    spectralShellNorm k (∫ t in a..b, F t)≤∫ t in a..b, spectralShellNorm k (F t) := by
+  have hi := ContinuousOn.intervalIntegrable_of_Icc (μ := volume) hab hF
+  have hif := ContinuousOn.intervalIntegrable_of_Icc (μ := volume) hab hF.fst.norm
+  have hig := ContinuousOn.intervalIntegrable_of_Icc (μ := volume) hab hF.snd.norm
+  have hf := (ContinuousLinearMap.fst ℝ ℂ ℂ).intervalIntegral_comp_comm hi
+  have hg := (ContinuousLinearMap.snd ℝ ℂ ℂ).intervalIntegral_comp_comm hi
+  change (∫ t in a..b, (F t).1)=(∫ t in a..b, F t).1 at hf
+  change (∫ t in a..b, (F t).2)=(∫ t in a..b, F t).2 at hg
+  dsimp only [spectralShellNorm]
+  rw [← hf,← hg,intervalIntegral.integral_add (hif.const_mul k) (hig.const_mul k⁻¹),
+    intervalIntegral.integral_const_mul,intervalIntegral.integral_const_mul]
+  exact add_le_add
+    (mul_le_mul_of_nonneg_left (intervalIntegral.norm_integral_le_integral_norm hab) hk)
+    (mul_le_mul_of_nonneg_left (intervalIntegral.norm_integral_le_integral_norm hab) (inv_nonneg.mpr hk))
+
+theorem spectralShellNorm_integral_bound (a b k : ℝ) (hab : a≤ b) (hk : 0≤ k)
+    (F : ℝ → ℂ × ℂ) (B : ℝ → ℝ)
+    (hF : ContinuousOn F (Icc a b)) (hB : ContinuousOn B (Icc a b))
+    (hbound : ∀ t ∈ Icc a b, spectralShellNorm k (F t)≤ B t) :
+    spectralShellNorm k (∫ t in a..b, F t)≤∫ t in a..b, B t := by
+  apply (spectralShellNorm_integral_le a b k hab hk F hF).trans
+  have hN : ContinuousOn (fun t => spectralShellNorm k (F t)) (Icc a b) :=
+    (continuousOn_const.mul hF.fst.norm).add (continuousOn_const.mul hF.snd.norm)
+  exact intervalIntegral.integral_mono_on hab
+    (ContinuousOn.intervalIntegrable_of_Icc (μ := volume) hab hN)
+    (ContinuousOn.intervalIntegrable_of_Icc (μ := volume) hab hB) hbound
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellInwardLimit.lean

@@ -0,0 +1,109 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCoupledInwardLimit
+
+namespace OAI
+
+/-! A uniformly small local Robin error and bounded oscillatory channel
+force the rescaled inward channel to vanish at the far end of a shell. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralShell_inward_limit
+    (omega : ℕ → ℝ) (R B D A M : ℝ) (hRB : R < B)
+    (hD : 0 ≤ D) (_hA : 0 ≤ A) (hM : 0 ≤ M)
+    (hw : Tendsto omega atTop atTop)
+    (q dq w : ℕ → ℝ → ℂ)
+    (hc : ∀ n, ContinuousOn (q n) (Icc R B))
+    (hd : ∀ n r, r ∈ Ioo R B → HasDerivAt (q n) (dq n r) r)
+    (hg : ∀ᶠ n in atTop, ∃ a ∈ Icc R ((R+B)/2),
+      omega n*‖q n a‖^2 ≤ M ∧ ∀ r ∈ Icc a B, omega n*‖w n r‖^2 ≤ M)
+    (hs : ∀ delta : ℝ, 0 < delta → ∀ᶠ n in atTop, ∀ r ∈ Icc R B,
+      ∃ alpha : ℂ, alpha.re ≤ -Real.sqrt (omega n)/48 ∧
+        ‖alpha‖ ≤ A*Real.sqrt (omega n) ∧
+        ‖dq n r-alpha*q n r‖ ≤ delta*D*Real.sqrt (omega n)*(‖q n r‖+‖w n r‖)) :
+    ∃ φ : ℕ → ℕ, StrictMono φ ∧
+      Tendsto (fun n => (Real.sqrt (omega (φ n)) : ℂ)*q (φ n) B) atTop (𝓝 0) ∧
+      Tendsto (fun n => dq (φ n) B) atTop (𝓝 0) := by
+  classical
+  let delta := fun n : ℕ => 1/((n : ℝ)+1)
+  have hdelta : ∀ n, 0 < delta n := by intro n; dsimp only [delta]; positivity
+  have hdelta0 : Tendsto delta atTop (𝓝 0) := by
+    simpa only [delta] using tendsto_one_div_add_atTop_nhds_zero_nat
+  obtain ⟨φ,hφ,hall⟩ := extraction_forall_of_eventually (fun n =>
+    (hw.eventually (eventually_gt_atTop 0)).and (hg.and (hs (delta n) (hdelta n))))
+  choose a ha hqa hwa using fun n => (hall n).2.1
+  let nu := fun n => Real.sqrt (omega (φ n))
+  have hnu : ∀ n, 0 < nu n := fun n => Real.sqrt_pos.mpr (hall n).1
+  have hnu2 : ∀ n, (nu n)^2 = omega (φ n) := fun n => Real.sq_sqrt (hall n).1.le
+  have hnulim : Tendsto nu atTop atTop := Real.tendsto_sqrt_atTop.comp (hw.comp hφ.tendsto_atTop)
+  have hals : ∀ n r, r ∈ Icc R B → ∃ alpha : ℂ,
+      alpha.re ≤ -nu n/48 ∧ ‖alpha‖ ≤ A*nu n ∧
+      ‖dq (φ n) r-alpha*q (φ n) r‖ ≤ delta n*D*nu n*(‖q (φ n) r‖+‖w (φ n) r‖) :=
+    fun n => (hall n).2.2
+  let alpha := fun n r => if hr : r ∈ Icc R B then (hals n r hr).choose else 0
+  have halpha n r (hr : r ∈ Icc R B) :
+      (alpha n r).re ≤ -nu n/48 ∧ ‖alpha n r‖ ≤ A*nu n ∧
+      ‖dq (φ n) r-alpha n r*q (φ n) r‖ ≤ delta n*D*nu n*(‖q (φ n) r‖+‖w (φ n) r‖) := by
+    simpa only [alpha,dite_eq_left hr] using (hals n r hr).choose_spec
+  let Q := fun n r => (nu n : ℂ)*q (φ n) r
+  let dQ := fun n r => (nu n : ℂ)*dq (φ n) r
+  let W := fun n r => (nu n : ℂ)*w (φ n) r
+  have hQnorm n r : ‖Q n r‖ = nu n*‖q (φ n) r‖ := by
+    simp only [Q,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (hnu n)]
+  have hWnorm n r : ‖W n r‖ = nu n*‖w (φ n) r‖ := by
+    simp only [W,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (hnu n)]
+  have hinit n : ‖Q n (a n)‖ ≤ Real.sqrt M := by
+    apply (Real.le_sqrt (norm_nonneg _) hM).mpr
+    rw [hQnorm,mul_pow,hnu2]
+    exact hqa n
+  have hbound n r (hr : r ∈ Icc (a n) B) : ‖W n r‖ ≤ Real.sqrt M := by
+    apply (Real.le_sqrt (norm_nonneg _) hM).mpr
+    rw [hWnorm,mul_pow,hnu2]
+    exact hwa n r hr
+  have hscaled n r (hr : r ∈ Icc R B) :
+      ‖dQ n r-alpha n r*Q n r‖ ≤ (48*D*delta n)*(nu n/48)*(‖Q n r‖+‖W n r‖) := by
+    have heq : dQ n r-alpha n r*Q n r =
+        (nu n : ℂ)*(dq (φ n) r-alpha n r*q (φ n) r) := by dsimp only [dQ,Q]; ring
+    rw [heq,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (hnu n)]
+    calc
+      _ ≤ nu n*(delta n*D*nu n*(‖q (φ n) r‖+‖w (φ n) r‖)) :=
+        mul_le_mul_of_nonneg_left (halpha n r hr).2.2 (hnu n).le
+      _ = _ := by rw [hQnorm,hWnorm]; ring
+  have hlimit : Tendsto (fun n => Q n B) atTop (𝓝 0) := by
+    apply spectralComplex_coupled_inward_limit a (fun n => nu n/48) (fun n => 48*D*delta n)
+      B ((B-R)/2) (Real.sqrt M) (by linarith) (Real.sqrt_nonneg _)
+      (hnulim.atTop_div_const (by norm_num)) (by simpa using hdelta0.const_mul (48*D)) Q dQ W alpha
+    apply Eventually.of_forall
+    intro n
+    refine ⟨by linarith [(ha n).2],by positivity,?_,hinit n,?_,?_,?_,?_⟩
+    · exact continuousOn_const.mul ((hc (φ n)).mono (by intro r hr; exact ⟨(ha n).1.trans hr.1,hr.2⟩))
+    · intro r hr
+      exact (hd (φ n) r ⟨lt_of_le_of_lt (ha n).1 hr.1,hr.2⟩).const_mul _
+    · intro r hr
+      simpa only [neg_div] using (halpha n r ⟨(ha n).1.trans hr.1.le,hr.2.le⟩).1
+    · intro r hr
+      exact hscaled n r ⟨(ha n).1.trans hr.1.le,hr.2.le⟩
+    · intro r hr
+      exact hbound n r ⟨hr.1.le,hr.2.le⟩
+  refine ⟨φ,hφ,hlimit,?_⟩
+  have hBn : B ∈ Icc R B := ⟨hRB.le,le_rfl⟩
+  have hBbound n : ‖W n B‖ ≤ Real.sqrt M := hbound n B ⟨by linarith [(ha n).2],le_rfl⟩
+  have hnormlim := tendsto_zero_iff_norm_tendsto_zero.mp hlimit
+  have hrhs : Tendsto (fun n => A*‖Q n B‖+delta n*D*(‖Q n B‖+Real.sqrt M)) atTop (𝓝 0) := by
+    convert (hnormlim.const_mul A).add ((hdelta0.mul_const D).mul (hnormlim.add_const (Real.sqrt M))) using 1
+    simp
+  apply tendsto_zero_iff_norm_tendsto_zero.mpr
+  apply squeeze_zero' (Eventually.of_forall (fun n => norm_nonneg _)) _ hrhs
+  apply Eventually.of_forall
+  intro n
+  calc
+    ‖dq (φ n) B‖ ≤ ‖alpha n B*q (φ n) B‖+‖dq (φ n) B-alpha n B*q (φ n) B‖ := norm_le_insert' _ _
+    _ ≤ (A*nu n)*‖q (φ n) B‖+delta n*D*nu n*(‖q (φ n) B‖+‖w (φ n) B‖) :=
+      add_le_add (by rw [norm_mul]; exact mul_le_mul_of_nonneg_right (halpha n B hBn).2.1 (norm_nonneg _))
+        (halpha n B hBn).2.2
+    _ = A*‖Q n B‖+delta n*D*(‖Q n B‖+‖W n B‖) := by rw [hQnorm,hWnorm]; ring
+    _ ≤ _ := by gcongr; exact hBbound n
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellMatchedCoupling.lean

@@ -0,0 +1,64 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCouplingEstimate
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousSpectralLocalizationPotential
+
+namespace OAI
+
+/-! The small coefficient in the shell Green argument is supplied by the
+actual matched profile, uniformly in both spectral and angular parameters. -/
+
+open Set Filter
+namespace DefocusingNLS
+open ProfileCertificate
+
+noncomputable def spectralShellPlusForcing (m : ℕ) (Q : ℂ) (r : ℝ)
+    (u : (ℂ × ℂ) × (ℂ × ℂ)) : ℂ :=
+  spectralDiagonalCoefficient m Q*u.1.1+
+    spectralCrossCoefficient m Q*(homogeneousSpectralLocalizationFactor 1 r/
+      homogeneousSpectralLocalizationFactor (-1) r)*u.2.1
+
+noncomputable def spectralShellMinusForcing (m : ℕ) (Q : ℂ) (r : ℝ)
+    (u : (ℂ × ℂ) × (ℂ × ℂ)) : ℂ :=
+  star (spectralDiagonalCoefficient m Q)*u.2.1+
+    star (spectralCrossCoefficient m Q)*(homogeneousSpectralLocalizationFactor (-1) r/
+      homogeneousSpectralLocalizationFactor 1 r)*u.1.1
+
+theorem spectralShellForcing_bound (m : ℕ) (Q : ℂ) (r kp km k C : ℝ)
+    (hr : 0<r) (hk : 0<k) (hkp : k≤ kp) (hkm : k≤ km)
+    (u : (ℂ × ℂ) × (ℂ × ℂ))
+    (hcoef : ‖spectralDiagonalCoefficient m Q‖+‖spectralCrossCoefficient m Q‖≤ C/r^2) :
+    ‖spectralShellPlusForcing m Q r u‖≤ C/(k*r^2)*spectralShellPairNorm kp km u ∧
+    ‖spectralShellMinusForcing m Q r u‖≤ C/(k*r^2)*spectralShellPairNorm kp km u := by
+  obtain ⟨hp,hm⟩ := spectralShellPairNorm_values kp km k hk hkp hkm u
+  have hN := spectralShellPairNorm_nonneg kp km (hk.trans_le hkp).le u
+  have hcoef0 : 0 ≤ C/r^2 := (add_nonneg (norm_nonneg _) (norm_nonneg _)).trans hcoef
+  have hmax : max ‖u.1.1‖ ‖u.2.1‖≤ spectralShellPairNorm kp km u/k := max_le hp hm
+  have hbound : (‖spectralDiagonalCoefficient m Q‖+‖spectralCrossCoefficient m Q‖)*
+      max ‖u.1.1‖ ‖u.2.1‖≤ C/(k*r^2)*spectralShellPairNorm kp km u := by
+    calc
+      _ ≤ (C/r^2)*(spectralShellPairNorm kp km u/k) := by gcongr
+      _ = _ := by ring
+  constructor
+  · exact (homogeneousSpectralLocalization_coupling_bound 1 r hr
+      (spectralDiagonalCoefficient m Q) (spectralCrossCoefficient m Q) u.1.1 u.2.1).trans hbound
+  · have hh := homogeneousSpectralLocalization_coupling_bound (-1) r hr
+      (star (spectralDiagonalCoefficient m Q)) (star (spectralCrossCoefficient m Q)) u.2.1 u.1.1
+    simpa only [spectralShellMinusForcing,norm_star,neg_neg,max_comm] using hh.trans (by simpa only [norm_star,max_comm] using hbound)
+
+theorem radialMatched_shell_forcing_bound (C : ℝ) (hC : 0<C) :
+    ∀ᶠ n in atTop, ∀ z : ProfileMatchingBall, ∀ r kp km k : ℝ,
+      innerBoundaryRadius<r → 0<k → k≤ kp → k≤ km →
+      ∀ u : (ℂ × ℂ) × (ℂ × ℂ),
+      ‖spectralShellPlusForcing (n+radialInnerShootingThreshold)
+        (radialMatchedProfile n z r) r u‖≤ C/(k*r^2)*spectralShellPairNorm kp km u ∧
+      ‖spectralShellMinusForcing (n+radialInnerShootingThreshold)
+        (radialMatchedProfile n z r) r u‖≤ C/(k*r^2)*spectralShellPairNorm kp km u := by
+  filter_upwards [homogeneousSpectralLocalization_uniform_potential C hC] with n hn
+  intro z r kp km k hr hk hp hm u
+  have hr0 : 0<r := by linarith [innerBoundaryRadius_bounds.1]
+  apply spectralShellForcing_bound (n+radialInnerShootingThreshold)
+    (radialMatchedProfile n z r) r kp km k C hr0 hk hp hm u
+  exact (le_div_iff₀ (sq_pos_of_pos hr0)).mpr (by simpa only [mul_comm] using (hn z r hr).le)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellNorm.lean

@@ -0,0 +1,63 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarGreen
+
+namespace OAI
+
+/-! The scaled value/derivative norm in the fixed-shell transfer estimate.
+Here `k` is the square root of the regularized frequency magnitude. -/
+
+namespace DefocusingNLS
+
+noncomputable def spectralShellNorm (k : ℝ) (u : ℂ × ℂ) : ℝ :=
+  k * ‖u.1‖ + k⁻¹ * ‖u.2‖
+
+theorem spectralShellNorm_nonneg (k : ℝ) (hk : 0≤ k) (u : ℂ × ℂ) :
+    0≤ spectralShellNorm k u := by
+  exact add_nonneg (mul_nonneg hk (norm_nonneg _))
+    (mul_nonneg (inv_nonneg.mpr hk) (norm_nonneg _))
+
+theorem spectralShellNorm_smul (k : ℝ) (c : ℂ) (u : ℂ × ℂ) :
+    spectralShellNorm k (c • u)=‖c‖*spectralShellNorm k u := by
+  simp only [spectralShellNorm,Prod.smul_fst,Prod.smul_snd,norm_smul]
+  ring
+
+theorem spectralShellNorm_add_le (k : ℝ) (hk : 0≤ k) (u v : ℂ × ℂ) :
+    spectralShellNorm k (u+v)≤ spectralShellNorm k u+spectralShellNorm k v := by
+  dsimp only [spectralShellNorm,Prod.fst_add,Prod.snd_add]
+  calc
+    _ ≤ k*(‖u.1‖+‖v.1‖)+k⁻¹*(‖u.2‖+‖v.2‖) :=
+      add_le_add (mul_le_mul_of_nonneg_left (norm_add_le _ _) hk)
+        (mul_le_mul_of_nonneg_left (norm_add_le _ _) (inv_nonneg.mpr hk))
+    _ = _ := by ring
+
+theorem spectralShellNorm_value (k : ℝ) (hk : 0<k) (u : ℂ × ℂ) :
+    ‖u.1‖ ≤ spectralShellNorm k u/k := by
+  apply (le_div_iff₀ hk).mpr
+  dsimp only [spectralShellNorm]
+  nlinarith [mul_nonneg (inv_nonneg.mpr hk.le) (norm_nonneg u.2)]
+
+theorem spectralShellNorm_slope (k : ℝ) (hk : 0<k) (u : ℂ × ℂ) :
+    ‖u.2‖ ≤ k*spectralShellNorm k u := by
+  dsimp only [spectralShellNorm]
+  have he : k*k⁻¹=1 := mul_inv_cancel₀ hk.ne'
+  rw [mul_add,← mul_assoc k k⁻¹,he,one_mul]
+  exact le_add_of_nonneg_left (by positivity)
+
+theorem spectralShellNorm_zero (k : ℝ) : spectralShellNorm k 0=0 := by
+  simp only [spectralShellNorm,Prod.fst_zero,Prod.snd_zero,norm_zero,mul_zero,add_zero]
+
+theorem spectralShellNorm_eq_zero (k : ℝ) (hk : 0<k) (u : ℂ × ℂ) :
+    spectralShellNorm k u=0 ↔ u=0 := by
+  constructor
+  · intro h
+    have hf := spectralShellNorm_value k hk u
+    have hg := spectralShellNorm_slope k hk u
+    rw [h,zero_div] at hf
+    rw [h,mul_zero] at hg
+    exact Prod.ext (norm_eq_zero.mp (le_antisymm hf (norm_nonneg _)))
+      (norm_eq_zero.mp (le_antisymm hg (norm_nonneg _)))
+  · rintro rfl
+    exact spectralShellNorm_zero k
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralShellPositiveForm.lean

@@ -0,0 +1,68 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralShellMatchedCoupling
+
+namespace OAI
+
+/-! The defocusing coefficient matrix remains nonnegative after the two
+Liouville phase changes. This is the interior sign used for high angular modes. -/
+
+namespace DefocusingNLS
+
+theorem spectralDiagonalCoefficient_real (m : ℕ) (q : ℂ) :
+    spectralDiagonalCoefficient m q = (((m : ℝ)+1)*‖q‖^(2*m) : ℝ) := by
+  calc
+    _ = ((m+1 : ℕ) : ℂ)*(q*star q)^m := by
+      rw [spectralDiagonalCoefficient,mul_pow]
+      ring
+    _ = ((m+1 : ℕ) : ℂ)*((‖q‖ : ℂ)^2)^m := by
+      rw [Complex.star_def,Complex.mul_conj']
+    _ = _ := by push_cast; rw [← pow_mul]
+
+private theorem real_diagonal_form (d : ℝ) (u : ℂ) :
+    (star u*((d : ℂ)*u)).re = d*‖u‖^2 := by
+  rw [Complex.sq_norm]
+  simp only [Complex.star_def,Complex.mul_re,Complex.mul_im,Complex.ofReal_re,
+    Complex.ofReal_im,Complex.conj_re,Complex.conj_im,Complex.normSq_apply]
+  ring
+
+private theorem positive_pair (d : ℝ) (cp cm u v : ℂ)
+    (hd : 0 ≤ d) (hp : ‖cp‖ ≤ d) (hm : ‖cm‖ ≤ d) :
+    0 ≤ (star u*((d : ℂ)*u+cp*v)).re+(star v*((d : ℂ)*v+cm*u)).re := by
+  have hpn : ‖star u*(cp*v)‖ ≤ d*‖u‖*‖v‖ := by
+    rw [norm_mul,norm_star,norm_mul]
+    nlinarith [mul_le_mul_of_nonneg_right hp (mul_nonneg (norm_nonneg u) (norm_nonneg v))]
+  have hmn : ‖star v*(cm*u)‖ ≤ d*‖u‖*‖v‖ := by
+    rw [norm_mul,norm_star,norm_mul]
+    nlinarith [mul_le_mul_of_nonneg_right hm (mul_nonneg (norm_nonneg u) (norm_nonneg v))]
+  have hpr := (abs_le.mp (Complex.abs_re_le_norm (star u*(cp*v)))).1
+  have hmr := (abs_le.mp (Complex.abs_re_le_norm (star v*(cm*u)))).1
+  rw [mul_add,mul_add,Complex.add_re,Complex.add_re,real_diagonal_form,real_diagonal_form]
+  nlinarith [mul_nonneg hd (sq_nonneg (‖u‖-‖v‖))]
+
+theorem spectralShellForcing_nonnegative (m : ℕ) (hm : 1 ≤ m) (Q : ℂ)
+    (r : ℝ) (hr : 0 < r) (u : (ℂ × ℂ) × (ℂ × ℂ)) :
+    0 ≤ (star u.1.1*spectralShellPlusForcing m Q r u).re+
+      (star u.2.1*spectralShellMinusForcing m Q r u).re := by
+  let d := ((m : ℝ)+1)*‖Q‖^(2*m)
+  have hd : 0 ≤ d := by dsimp only [d]; positivity
+  have hD : spectralDiagonalCoefficient m Q = (d : ℂ) := spectralDiagonalCoefficient_real m Q
+  have hC : ‖spectralCrossCoefficient m Q‖ ≤ d := by
+    rw [spectralCrossCoefficient_norm m hm]
+    dsimp only [d]
+    nlinarith [pow_nonneg (norm_nonneg Q) (2*m)]
+  have hp : ‖spectralCrossCoefficient m Q*(homogeneousSpectralLocalizationFactor 1 r/
+      homogeneousSpectralLocalizationFactor (-1) r)‖ ≤ d := by
+    rw [norm_mul,homogeneousSpectralLocalization_phase_norm 1 r hr,mul_one]
+    exact hC
+  have hn : ‖star (spectralCrossCoefficient m Q)*(homogeneousSpectralLocalizationFactor (-1) r/
+      homogeneousSpectralLocalizationFactor 1 r)‖ ≤ d := by
+    have hphase := homogeneousSpectralLocalization_phase_norm (-1) r hr
+    norm_num only [neg_neg] at hphase
+    rw [norm_mul,hphase,norm_star,mul_one]
+    exact hC
+  have h := positive_pair d _ _ u.1.1 u.2.1 hd hp hn
+  simpa only [spectralShellPlusForcing,spectralShellMinusForcing,hD,
+    Complex.star_def,Complex.conj_ofReal] using h
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSimpleKernelEstimate.lean

@@ -0,0 +1,114 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactKernelLimit
+
+namespace OAI
+
+/-! The estimate on a fixed complement of a simple compact-pencil kernel.
+This is the quantitative input for excluding nearby additional roots. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem compact_approximate_kernel_limit {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (K : E →L[ℂ] E) (hK : IsCompactOperator K) (v : ℕ → E)
+    (hv : ∀ n, ‖v n‖ = 1) (he : Tendsto (fun n => v n - K (v n)) atTop (𝓝 0)) :
+    ∃ v₀ : E, ‖v₀‖ = 1 ∧ K v₀ = v₀ ∧
+      ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (fun n => v (φ n)) atTop (𝓝 v₀) := by
+  have hb (n : ℕ) : v n ∈ Metric.closedBall (0 : E) 1 := by
+    simpa only [Metric.mem_closedBall, dist_zero_right, hv n] using (le_refl (1 : ℝ))
+  have hcomp := hK.isCompact_closure_image_closedBall 1
+  obtain ⟨v₀, _, φ, hφ, ht⟩ := hcomp.tendsto_subseq
+    (fun n => subset_closure (mem_image_of_mem K (hb n)))
+  have ht' : Tendsto (fun n => v (φ n)) atTop (𝓝 v₀) := by
+    have hs := (he.comp hφ.tendsto_atTop).add ht
+    simpa only [Function.comp_def, sub_add_cancel, zero_add] using hs
+  have hn : ‖v₀‖ = 1 := by
+    apply tendsto_nhds_unique ht'.norm
+    simpa only [hv] using (tendsto_const_nhds : Tendsto (fun _ : ℕ => (1 : ℝ)) atTop (𝓝 1))
+  have hfix : K v₀ = v₀ :=
+    tendsto_nhds_unique (K.continuous.continuousAt.tendsto.comp ht') ht
+  exact ⟨v₀, hn, hfix, φ, hφ, ht'⟩
+
+theorem compact_simple_kernel_estimate {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (K : E →L[ℂ] E) (hK : IsCompactOperator K) (v : E)
+    (L : E →L[ℂ] ℂ) (hLv : L v ≠ 0)
+    (hker : ∀ u : E, K u = u → ∃ a : ℂ, u = a • v) :
+    ∃ c : ℝ, 0 < c ∧ ∀ u : E, L u = 0 → c * ‖u‖ ≤ ‖u - K u‖ := by
+  by_contra hfail
+  push Not at hfail
+  let ε : ℕ → ℝ := fun n => 1 / ((n : ℝ) + 1)
+  have hε (n : ℕ) : 0 < ε n := by dsimp [ε]; positivity
+  choose u hu using fun n => hfail (ε n) (hε n)
+  have hu0 (n : ℕ) : u n ≠ 0 := by
+    intro h
+    have hh := (hu n).2
+    simp [h] at hh
+  have hun (n : ℕ) : ‖u n‖ ≠ 0 := norm_ne_zero_iff.mpr (hu0 n)
+  let w := fun n => ((‖u n‖ : ℂ)⁻¹) • u n
+  have hw (n : ℕ) : ‖w n‖ = 1 := by
+    dsimp [w]
+    rw [norm_smul, norm_inv, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg (norm_nonneg _), inv_mul_cancel₀ (hun n)]
+  have hLw (n : ℕ) : L (w n) = 0 := by
+    dsimp only [w]
+    rw [map_smul, (hu n).1, smul_zero]
+  have hres (n : ℕ) : ‖w n - K (w n)‖ ≤ ε n := by
+    have hn : 0 < ‖u n‖ := norm_pos_iff.mpr (hu0 n)
+    have hid : w n - K (w n) = ((‖u n‖ : ℂ)⁻¹) • (u n - K (u n)) := by
+      simp only [w, map_smul, smul_sub]
+    rw [hid, norm_smul, norm_inv, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg hn.le]
+    calc
+      ‖u n‖⁻¹ * ‖u n - K (u n)‖ ≤ ‖u n‖⁻¹ * (ε n * ‖u n‖) :=
+        mul_le_mul_of_nonneg_left (hu n).2.le (inv_nonneg.mpr hn.le)
+      _ = ε n := by field_simp
+  have hεlim : Tendsto ε atTop (𝓝 0) := by
+    have ht : Tendsto (fun n : ℕ => (n : ℝ) + 1) atTop atTop :=
+      tendsto_atTop_mono (fun n : ℕ => by simp only [le_add_iff_nonneg_right]; norm_num)
+        tendsto_natCast_atTop_atTop
+    simpa only [ε, one_div, Function.comp_def] using tendsto_inv_atTop_zero.comp ht
+  obtain ⟨v₀, hv₀, hfix, φ, _hφ, ht⟩ := compact_approximate_kernel_limit K hK w hw
+    (squeeze_zero_norm hres hεlim)
+  have hL₀ : L v₀ = 0 := by
+    apply tendsto_nhds_unique (L.continuous.continuousAt.tendsto.comp ht)
+    change Tendsto (fun n => L (w (φ n))) atTop (𝓝 (0 : ℂ))
+    simpa only [hLw] using
+      (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0 : ℂ)) atTop (𝓝 0))
+  obtain ⟨a, ha⟩ := hker v₀ hfix
+  have ha0 : a = 0 := by
+    rw [ha, map_smul, smul_eq_mul] at hL₀
+    exact (mul_eq_zero.mp hL₀).resolve_right hLv
+  rw [ha, ha0, zero_smul, norm_zero] at hv₀
+  norm_num at hv₀
+
+theorem kernel_complement_perturbation_estimate {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (K₀ K : E →L[ℂ] E) (L : E →L[ℂ] ℂ) (c : ℝ)
+    (hbase : ∀ u : E, L u = 0 → c * ‖u‖ ≤ ‖u - K₀ u‖)
+    (hK : ‖K - K₀‖ ≤ c / 2) (u : E) (hu : L u = 0) :
+    c / 2 * ‖u‖ ≤ ‖u - K u‖ := by
+  have hb := hbase u hu
+  have hop := (K - K₀).le_opNorm u
+  have he : u - K₀ u = (u - K u) + (K - K₀) u := by
+    simp only [sub_apply]
+    abel
+  have ht := norm_add_le (u - K u) ((K - K₀) u)
+  rw [← he] at ht
+  have hm := mul_le_mul_of_nonneg_right hK (norm_nonneg u)
+  linarith
+
+theorem kernel_unique_with_normalization {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (K : E →L[ℂ] E) (L : E →L[ℂ] ℂ) (c : ℝ) (hc : 0 < c)
+    (hbound : ∀ u : E, L u = 0 → c * ‖u‖ ≤ ‖u - K u‖)
+    (u v : E) (hu : K u = u) (hv : K v = v) (hL : L u = L v) : u = v := by
+  have hzero : L (u - v) = 0 := by rw [map_sub, hL, sub_self]
+  have hh := hbound (u - v) hzero
+  rw [map_sub, hu, hv, sub_self, norm_zero] at hh
+  have hn : ‖u - v‖ = 0 := le_antisymm (by nlinarith) (norm_nonneg _)
+  exact sub_eq_zero.mp (norm_eq_zero.mp hn)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSimpleLimitNoJordan.lean

@@ -0,0 +1,70 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSimpleLimitNoSplitting
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCompactJordanLimit
+
+namespace OAI
+
+/-! First analytic chains cannot persist near a simple limiting root. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+
+theorem spectral_simple_limit_no_jordan
+    (F : ℕ → ℂ → E →L[ℂ] E) (f : ℂ → E →L[ℂ] E)
+    (U : Set ℂ) (hU : IsOpen U)
+    (hF : TendstoLocallyUniformlyOn F f atTop U)
+    (hd : ∀ᶠ n in atTop, DifferentiableOn ℂ (F n) U)
+    (z : ℂ) (hz : z ∈ U) (hcompact : IsCompactOperator (f z))
+    (x : ℕ → ℂ) (hx : Tendsto x atTop (𝓝 z)) (u v : ℕ → E)
+    (hu : ∀ᶠ n in atTop, F n (x n) (u n)=u n ∧ u n ≠ 0)
+    (hv : ∀ᶠ n in atTop, v n-F n (x n) (v n)=deriv (F n) (x n) (u n))
+    (hker : ∀ u₀ : E, u₀ ≠ 0 → f z u₀=u₀ →
+      ∀ w : E, f z w=w → ∃ a : ℂ, w=a • u₀)
+    (hno : ∀ u₀ : E, u₀ ≠ 0 → f z u₀=u₀ →
+      ∀ w : E, w-f z w ≠ deriv f z u₀) : False := by
+  have hdf := hF.differentiableOn hd hU
+  have hj := spectral_locallyUniform_joint_tendsto F f U hU hF z hz
+    (hdf.differentiableAt (hU.mem_nhds hz)).continuousAt
+  have hK := hj.comp (tendsto_id.prodMk hx)
+  have hdj := spectral_locallyUniform_joint_tendsto (fun n => deriv (F n)) (deriv f)
+    U hU (hF.deriv hd hU) z hz ((hdf.deriv hU).continuousOn.continuousAt (hU.mem_nhds hz))
+  have hD := hdj.comp (tendsto_id.prodMk hx)
+  obtain ⟨u₀,hnorm,hfix⟩ := compact_kernel_limit_of_eventually_nonzero
+    (fun n => F n (x n)) (f z) hK hcompact u hu
+  have hu₀ : u₀ ≠ 0 := by
+    intro he
+    rw [he,norm_zero] at hnorm
+    norm_num at hnorm
+  obtain ⟨L,_hLnorm,hLu⟩ := exists_dual_vector ℂ u₀ (by rw [hnorm]; norm_num)
+  have hL₀ : L u₀=1 := by simpa [hnorm] using hLu
+  obtain ⟨c,hc,hbase⟩ := compact_simple_kernel_estimate (f z) hcompact u₀ L
+    (by rw [hL₀]; norm_num) (hker u₀ hu₀ hfix)
+  have heK : ∀ᶠ n in atTop, ‖F n (x n)-f z‖ ≤ c/2 :=
+    ((tendsto_iff_norm_sub_tendsto_zero.mp hK).eventually
+      (gt_mem_nhds (half_pos hc))).mono (fun _ h => h.le)
+  obtain ⟨N,hN⟩ := eventually_atTop.mp (heK.and (hu.and hv))
+  let k := fun n => n+N
+  have hk : Tendsto k atTop atTop := tendsto_add_atTop_nat N
+  have hg (n : ℕ) := hN (n+N) (Nat.le_add_left N n)
+  have hLn (n : ℕ) : L (u (k n)) ≠ 0 :=
+    spectral_kernel_functional_ne_zero (f z) _ L c hc hbase (hg n).1 _
+      (hg n).2.1.1 (hg n).2.1.2
+  let a := fun n => (L (u (k n)))⁻¹ • u (k n)
+  let b := fun n => (L (u (k n)))⁻¹ • v (k n)
+  have ha (n : ℕ) : F (k n) (x (k n)) (a n)=a n ∧ L (a n)=1 :=
+    spectral_normalize_kernel _ L _ (hg n).2.1.1 (hLn n)
+  have halim : Tendsto a atTop (𝓝 u₀) :=
+    spectral_normalized_kernel_tendsto (fun n => F (k n) (x (k n))) (f z)
+      (hK.comp hk) L c hc hbase (fun n => (hg n).1) u₀ a hfix
+      (fun n => (ha n).1) (fun n => (ha n).2.trans hL₀.symm)
+  have hb (n : ℕ) : b n-F (k n) (x (k n)) (b n)=deriv (F (k n)) (x (k n)) (a n) := by
+    dsimp only [a,b]
+    rw [map_smul,map_smul,← smul_sub,(hg n).2.2]
+  exact compact_pencil_no_jordan_sequence (fun n => F (k n) (x (k n)))
+    (fun n => deriv (F (k n)) (x (k n))) (f z) (deriv f z)
+    (hK.comp hk) hcompact (hD.comp hk) L c hc hbase (fun n => (hg n).1)
+    a b u₀ halim (fun n => (ha n).1) (fun n => (ha n).2) hb (hno u₀ hu₀ hfix)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSimpleLimitNoSplitting.lean

@@ -0,0 +1,46 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralEventualNoSplitting
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralNonzeroKernelLimit
+import Mathlib.Analysis.Normed.Module.HahnBanach
+
+namespace OAI
+
+/-! A one-dimensional limiting kernel with no first chain prevents distinct nearby roots. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+
+theorem spectral_simple_limit_no_splitting
+    (F : ℕ → ℂ → E →L[ℂ] E) (f : ℂ → E →L[ℂ] E)
+    (U : Set ℂ) (hU : IsOpen U)
+    (hF : TendstoLocallyUniformlyOn F f atTop U)
+    (hd : ∀ᶠ n in atTop, DifferentiableOn ℂ (F n) U)
+    (z : ℂ) (hz : z ∈ U) (hcompact : IsCompactOperator (f z))
+    (x y : ℕ → ℂ) (hx : Tendsto x atTop (𝓝 z)) (hy : Tendsto y atTop (𝓝 z))
+    (hne : ∀ᶠ n in atTop, x n ≠ y n)
+    (u v : ℕ → E)
+    (hu : ∀ᶠ n in atTop, F n (x n) (u n)=u n ∧ u n ≠ 0)
+    (hv : ∀ᶠ n in atTop, F n (y n) (v n)=v n ∧ v n ≠ 0)
+    (hker : ∀ u₀ : E, u₀ ≠ 0 → f z u₀=u₀ →
+      ∀ w : E, f z w=w → ∃ a : ℂ, w=a • u₀)
+    (hno : ∀ u₀ : E, u₀ ≠ 0 → f z u₀=u₀ →
+      ∀ w : E, w-f z w ≠ deriv f z u₀) : False := by
+  have hdf := hF.differentiableOn hd hU
+  have hj := spectral_locallyUniform_joint_tendsto F f U hU hF z hz
+    (hdf.differentiableAt (hU.mem_nhds hz)).continuousAt
+  obtain ⟨u₀,hnorm,hfix⟩ := compact_kernel_limit_of_eventually_nonzero
+    (fun n => F n (x n)) (f z) (hj.comp (tendsto_id.prodMk hx)) hcompact u hu
+  have hu₀ : u₀ ≠ 0 := by
+    intro he
+    rw [he,norm_zero] at hnorm
+    norm_num at hnorm
+  obtain ⟨L,_hLnorm,hLu⟩ := exists_dual_vector ℂ u₀ (by rw [hnorm]; norm_num)
+  have hL₀ : L u₀=1 := by simpa [hnorm] using hLu
+  obtain ⟨c,hc,hbase⟩ := compact_simple_kernel_estimate (f z) hcompact u₀ L
+    (by rw [hL₀]; norm_num) (hker u₀ hu₀ hfix)
+  exact spectral_eventual_no_splitting F f U hU hF hd z hz hcompact x y hx hy hne
+    L c hc hbase u₀ hfix hL₀ u v hu hv (hno u₀ hu₀ hfix)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSmoothCutoff.lean

@@ -0,0 +1,51 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralHarmonicJetMultiplier
+import Mathlib.Analysis.Complex.RealDeriv
+
+namespace OAI
+
+/-! Smooth cutoffs on Schwartz functions and their exact L² product identities. -/
+
+open MeasureTheory
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+noncomputable def spectralSmoothCutoff (q : ℝ → ℝ) : 𝓢(ℝ,ℂ) →L[ℂ] 𝓢(ℝ,ℂ) :=
+  SchwartzMap.smulLeftCLM ℂ (fun r => (q r : ℂ))
+
+theorem spectralSmoothCutoff_apply (q : ℝ → ℝ) (hq : q.HasTemperateGrowth)
+    (f : 𝓢(ℝ,ℂ)) (r : ℝ) : spectralSmoothCutoff q f r=(q r : ℂ)*f r := by
+  have hqc : (fun r => (q r : ℂ)).HasTemperateGrowth := Complex.hasTemperateGrowth_ofReal.comp hq
+  rw [spectralSmoothCutoff,SchwartzMap.smulLeftCLM_apply_apply hqc]
+  rfl
+
+theorem spectralSmoothCutoff_derivative (q dq : ℝ → ℝ) (hq : q.HasTemperateGrowth)
+    (hd : ∀ r, HasDerivAt q (dq r) r) (f : 𝓢(ℝ,ℂ)) (r : ℝ) :
+    SchwartzMap.derivCLM ℂ ℂ (spectralSmoothCutoff q f) r=
+      (dq r : ℂ)*f r+(q r : ℂ)*SchwartzMap.derivCLM ℂ ℂ f r := by
+  have he : (spectralSmoothCutoff q f : ℝ → ℂ)=(fun s => (q s : ℂ)*f s) :=
+    funext (spectralSmoothCutoff_apply q hq f)
+  rw [SchwartzMap.derivCLM_apply,he,SchwartzMap.derivCLM_apply]
+  exact ((hd r).ofReal_comp.mul (f.hasDerivAt r)).deriv
+
+theorem spectralSmoothCutoff_L2 (μ : Measure ℝ) [IsFiniteMeasure μ]
+    (q : ℝ → ℝ) (hq : q.HasTemperateGrowth) (hqm : AEStronglyMeasurable q μ)
+    (M : ℝ) (hqb : ∀ᵐ r ∂μ, ‖q r‖ ≤ M) (f : 𝓢(ℝ,ℂ)) :
+    spectralL2ComplexMultiplier μ q hqm M hqb
+      (BoundedContinuousFunction.toLp 2 μ ℂ (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ f))=
+    BoundedContinuousFunction.toLp 2 μ ℂ
+      (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ (spectralSmoothCutoff q f)) := by
+  apply Lp.ext
+  filter_upwards [spectralL2ComplexMultiplier_ae μ q hqm M hqb
+      (BoundedContinuousFunction.toLp 2 μ ℂ (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ f)),
+    BoundedContinuousFunction.coeFn_toLp 2 μ ℂ
+      (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ f),
+    BoundedContinuousFunction.coeFn_toLp 2 μ ℂ
+      (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ (spectralSmoothCutoff q f))]
+    with r hm hf hg
+  rw [hm,hf,hg]
+  change q r • f r = spectralSmoothCutoff q f r
+  simpa only [Complex.real_smul] using (spectralSmoothCutoff_apply q hq f r).symm
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSmoothHarmonicBound.lean

@@ -0,0 +1,67 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWeightedPairing
+
+namespace OAI
+
+/-! Uniform C1 control on the ball bounds the completed harmonic energy. -/
+
+open Set MeasureTheory
+open scoped SchwartzMap ENNReal
+namespace DefocusingNLS
+
+theorem spectralHarmonicNorm_le_sum (ell : ℕ) (R : ℝ)
+    (u : SpectralHarmonicEnergy ell R) :
+    ‖u‖ ≤ ‖spectralHarmonicValue ell R u‖+‖spectralHarmonicDerivative ell R u‖+
+      ‖spectralHarmonicAngularValue ell R u‖ := by
+  have he := spectralHarmonicEnergy_norm_sq ell R u
+  rw [spectralRadialEnergy_norm_sq] at he
+  change ‖u‖^2=‖spectralHarmonicValue ell R u‖^2+
+    ‖spectralHarmonicDerivative ell R u‖^2+‖spectralHarmonicAngularValue ell R u‖^2 at he
+  have hv := norm_nonneg (spectralHarmonicValue ell R u)
+  have hd := norm_nonneg (spectralHarmonicDerivative ell R u)
+  have ha := norm_nonneg (spectralHarmonicAngularValue ell R u)
+  nlinarith [norm_nonneg u,mul_nonneg hv hd,mul_nonneg hv ha,mul_nonneg hd ha]
+
+theorem spectralSmoothHarmonic_uniform_bound (ell : ℕ) (R : ℝ) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (f : 𝓢(ℝ,ℂ)) (d : ℝ), 0 ≤ d →
+      (∀ r ∈ Icc 0 R, ‖f r‖ ≤ d) → (∀ r ∈ Icc 0 R, ‖deriv f r‖ ≤ d) →
+      ‖spectralHarmonicSmoothEmbedding ell R f‖ ≤ C*d := by
+  let c : ℝ := (measureUnivNNReal (radialPressureMeasure R) : ℝ)^((2 : ℝ≥0∞).toReal)⁻¹
+  let a : ℝ := (measureUnivNNReal (spectralAngularMeasure R) : ℝ)^((2 : ℝ≥0∞).toReal)⁻¹
+  let k : ℝ := ‖(Real.sqrt ((ell : ℝ)*(ell+10)) : ℂ)‖
+  have hc : 0 ≤ c := Real.rpow_nonneg (by positivity) _
+  have ha : 0 ≤ a := Real.rpow_nonneg (by positivity) _
+  have hk : 0 ≤ k := norm_nonneg _
+  refine ⟨2*c+k*a+1,by positivity,fun f d hd hf hdf => ?_⟩
+  let u := spectralHarmonicSmoothEmbedding ell R f
+  have hV : ‖spectralHarmonicValue ell R u‖ ≤ c*d := by
+    apply Lp.norm_le_of_ae_bound hd
+    filter_upwards [spectralHarmonicValue_smooth_ae ell R f,
+      radialPressureMeasure_ae_positive R] with r hr hp
+    rw [hr]
+    exact hf r ⟨hp.1.le,hp.2⟩
+  have hD : ‖spectralHarmonicDerivative ell R u‖ ≤ c*d := by
+    apply Lp.norm_le_of_ae_bound hd
+    filter_upwards [spectralHarmonicDerivative_smooth_ae ell R f,
+      radialPressureMeasure_ae_positive R] with r hr hp
+    rw [hr]
+    exact hdf r ⟨hp.1.le,hp.2⟩
+  have hA : ‖spectralSmoothAngularValue R f‖ ≤ a*d := by
+    apply Lp.norm_le_of_ae_bound hd
+    filter_upwards [BoundedContinuousFunction.coeFn_toLp 2 (spectralAngularMeasure R) ℂ
+      (SchwartzMap.toBoundedContinuousFunctionCLM ℂ ℝ ℂ f),
+      (spectralAngularMeasure_absolutelyContinuous R).ae_le (radialPressureMeasure_ae_positive R)]
+      with r hr hp
+    change spectralSmoothAngularValue R f r=f r at hr
+    rw [hr]
+    exact hf r ⟨hp.1.le,hp.2⟩
+  have hG : ‖spectralHarmonicAngularValue ell R u‖ ≤ k*(a*d) := by
+    rw [spectralHarmonicAngularValue_smooth,norm_smul]
+    exact mul_le_mul_of_nonneg_left hA hk
+  apply (spectralHarmonicNorm_le_sum ell R u).trans
+  calc
+    _ ≤ c*d+c*d+k*(a*d) := add_le_add (add_le_add hV hD) hG
+    _ ≤ (2*c+k*a+1)*d := by nlinarith
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSmoothPairTesting.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFirstTest
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralPencilVariational
+
+namespace OAI
+
+/-! Schwartz tests in both coordinates determine the complete weak equation. -/
+
+open scoped SchwartzMap
+namespace DefocusingNLS
+
+theorem spectralPairFunctional_ext (ell : ℕ) (R : ℝ)
+    (L M : SpectralHarmonicPair ell R →L[ℝ] ℝ)
+    (hf : ∀ f : 𝓢(ℝ,ℂ), L (spectralFirstTest ell R f)=M (spectralFirstTest ell R f))
+    (hg : ∀ f : 𝓢(ℝ,ℂ), L (spectralSecondTest ell R f)=M (spectralSecondTest ell R f)) :
+    L=M := by
+  let J := (WithLp.prodContinuousLinearEquiv 2 ℂ
+    (SpectralHarmonicEnergy ell R) (SpectralHarmonicEnergy ell R)).symm
+  have hfirst : (fun v : SpectralHarmonicEnergy ell R => L (J (v,0)))=
+      (fun v : SpectralHarmonicEnergy ell R => M (J (v,0))) :=
+    (spectralHarmonicSmooth_dense ell R).equalizer
+      (L.continuous.comp (J.continuous.comp (continuous_id.prodMk continuous_const)))
+      (M.continuous.comp (J.continuous.comp (continuous_id.prodMk continuous_const))) (funext hf)
+  have hsecond : (fun v : SpectralHarmonicEnergy ell R => L (J (0,v)))=
+      (fun v : SpectralHarmonicEnergy ell R => M (J (0,v))) :=
+    (spectralHarmonicSmooth_dense ell R).equalizer
+      (L.continuous.comp (J.continuous.comp (continuous_const.prodMk continuous_id)))
+      (M.continuous.comp (J.continuous.comp (continuous_const.prodMk continuous_id))) (funext hg)
+  apply DFunLike.ext
+  intro v
+  have hv : v=J (v.fst,0)+J (0,v.snd) := by
+    change v=WithLp.toLp 2 (v.fst,0)+WithLp.toLp 2 (0,v.snd)
+    apply (WithLp.prodContinuousLinearEquiv 2 ℂ
+      (SpectralHarmonicEnergy ell R) (SpectralHarmonicEnergy ell R)).injective
+    change (v.fst,v.snd)=(v.fst+0,0+v.snd)
+    simp
+  rw [hv,map_add,map_add,congrFun hfirst,congrFun hsecond]
+
+namespace SpectralPenaltyFamily
+variable {R l : ℝ}
+
+theorem compactPencil_of_smooth_tests (s : SpectralPenaltyFamily R l) (ell n : ℕ)
+    (hR : 0 < R) (K : SpectralRadialObservationSpace R →L[ℂ] SpectralHarmonicPair ell R)
+    (u : SpectralHarmonicPair ell R)
+    (hf : ∀ f : 𝓢(ℝ,ℂ), s.penaltyForm ell n u (spectralFirstTest ell R f)=
+      inner ℝ (K (spectralHarmonicObservation ell R hR u)) (spectralFirstTest ell R f))
+    (hg : ∀ f : 𝓢(ℝ,ℂ), s.penaltyForm ell n u (spectralSecondTest ell R f)=
+      inner ℝ (K (spectralHarmonicObservation ell R hR u)) (spectralSecondTest ell R f)) :
+    s.compactPencil ell hR n K (spectralHarmonicObservation ell R hR u)=
+      spectralHarmonicObservation ell R hR u := by
+  apply (s.compactPencil_variational ell n hR K _).mpr
+  refine ⟨u,rfl,?_⟩
+  have he := spectralPairFunctional_ext ell R (s.penaltyForm ell n u)
+    (InnerProductSpace.toDual ℝ (SpectralHarmonicPair ell R)
+      (K (spectralHarmonicObservation ell R hR u))) hf hg
+  exact fun v => DFunLike.congr_fun he v
+
+end SpectralPenaltyFamily
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSubunitCoefficients.lean

@@ -0,0 +1,75 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCoefficientContinuity
+import OAI.MathematicalPhysics.DefocusingNLS.Profile.RadialUniformAnnulus
+import Mathlib.Analysis.SpecificLimits.Normed
+
+namespace OAI
+
+/-! Uniform decay of the actual two spectral potential coefficients on the
+exterior subunit annulus. The polynomial factor in the power is retained. -/
+
+open Filter Topology Set
+namespace DefocusingNLS
+open ProfileCertificate
+local notation "E₄" => (ℂ × ℂ) × (ℂ × ℂ)
+
+theorem spectralSubunitCoefficient_decay (ρ : ℝ) (hρ : 0 ≤ ρ) (hρ1 : ρ < 1) :
+    Tendsto (fun n : ℕ => (2*(n : ℝ)+1)*ρ^(2*n)) atTop (𝓝 0) := by
+  have hq : ρ^2 < 1 := pow_lt_one₀ hρ hρ1 (by decide : 2 ≠ 0)
+  have hp := tendsto_pow_atTop_nhds_zero_of_lt_one (sq_nonneg ρ) hq
+  have hn := tendsto_self_mul_const_pow_of_lt_one (sq_nonneg ρ) hq
+  convert (hn.const_mul 2).add hp using 1
+  · funext n
+    rw [pow_mul]
+    ring
+  · norm_num
+
+theorem spectralCoefficient_norm_sum (m : ℕ) (hm : 1 ≤ m) (q : ℂ) :
+    ‖spectralDiagonalCoefficient m q‖+‖spectralCrossCoefficient m q‖=
+      (2*(m : ℝ)+1)*‖q‖^(2*m) := by
+  rw [spectralDiagonalCoefficient_norm,spectralCrossCoefficient_norm m hm]
+  ring
+
+theorem spectralCoefficient_subunit_bound (m : ℕ) (hm : 1 ≤ m) (q : ℂ)
+    (ρ : ℝ) (hq : ‖q‖ ≤ ρ) :
+    ‖spectralDiagonalCoefficient m q‖+‖spectralCrossCoefficient m q‖ ≤
+      (2*(m : ℝ)+1)*ρ^(2*m) := by
+  rw [spectralCoefficient_norm_sum m hm]
+  exact mul_le_mul_of_nonneg_left
+    (pow_le_pow_left₀ (norm_nonneg _) hq _) (by positivity)
+
+theorem spectralCoefficient_zero (m : ℕ) (hm : 1 ≤ m) :
+    spectralDiagonalCoefficient m 0=0 ∧ spectralCrossCoefficient m 0=0 := by
+  have hmn : m ≠ 0 := by omega
+  simp [spectralDiagonalCoefficient,spectralCrossCoefficient,hmn]
+
+theorem circularBoundedField_subunit_bound (νp νm η : ℂ) (m : ℕ) (hm : 1 ≤ m)
+    (q : ℂ) (ρ : ℝ) (hq : ‖q‖ ≤ ρ) (z : E₄) :
+    ‖circularBoundedField νp νm η m q z-circularBoundedField νp νm η m 0 z‖ ≤
+      ((2*(m : ℝ)+1)*ρ^(2*m))*‖z‖ := by
+  rw [circularBoundedField_coefficient_difference,
+    (spectralCoefficient_zero m hm).1,(spectralCoefficient_zero m hm).2,sub_zero,sub_zero]
+  exact (circularCoefficientAction_norm _ _ z).trans
+    (mul_le_mul_of_nonneg_right (spectralCoefficient_subunit_bound m hm q ρ hq) (norm_nonneg z))
+
+theorem radialShooting_spectralCoefficients_uniform_small :
+    ∃ δ : ℕ → ℝ, (∀ n, 0 ≤ δ n) ∧ Tendsto δ atTop (𝓝 0) ∧
+      ∀ᶠ n in atTop, ∀ z : ProfileMatchingBall, ∀ t : ℝ,
+        Real.log innerBoundaryRadius ≤ t →
+          ‖spectralDiagonalCoefficient n
+            (radialExteriorCanonical (radialShootingNu n z) n (radialShootingM z)
+              (Real.log innerBoundaryRadius) t).1‖+
+          ‖spectralCrossCoefficient n
+            (radialExteriorCanonical (radialShootingNu n z) n (radialShootingM z)
+              (Real.log innerBoundaryRadius) t).1‖ ≤ δ n := by
+  obtain ⟨κ,ρ,hκ,hρ,he⟩ := radialShooting_uniform_annulus
+  let σ := max ρ 0
+  have hσ : 0 ≤ σ := le_max_right _ _
+  have hσ1 : σ < 1 := max_lt hρ (by norm_num)
+  refine ⟨fun n => (2*(n : ℝ)+1)*σ^(2*n),fun n => by positivity,
+    spectralSubunitCoefficient_decay σ hσ hσ1,?_⟩
+  filter_upwards [he,eventually_ge_atTop 1] with n hn hm z t ht
+  exact spectralCoefficient_subunit_bound n hm _ σ ((hn z t ht).2.trans (le_max_left _ _))
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSubunitDifference.lean

@@ -0,0 +1,138 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralSubunitCoefficients
+
+namespace OAI
+
+/-! A quantitative Lipschitz constant for the spectral coefficient pair.
+It tends to zero on a fixed subunit disk, even after division by the
+exponential order of the profile remainder. -/
+
+open Filter Topology
+namespace DefocusingNLS
+
+theorem spectral_power_difference_bound (n : ℕ) (ρ : ℝ) (hρ : 0 < ρ)
+    (z w : ℂ) (hz : ‖z‖ ≤ ρ) (hw : ‖w‖ ≤ ρ) :
+    ‖z^n-w^n‖ ≤ ((n : ℝ)*ρ^n/ρ)*‖z-w‖ := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    have he : z^(n+1)-w^(n+1)=z^n*(z-w)+(z^n-w^n)*w := by ring
+    rw [he]
+    calc
+      _ ≤ ‖z^n*(z-w)‖+‖(z^n-w^n)*w‖ := norm_add_le _ _
+      _ = ‖z‖^n*‖z-w‖+‖z^n-w^n‖*‖w‖ := by simp only [norm_mul,norm_pow]
+      _ ≤ ρ^n*‖z-w‖+(((n : ℝ)*ρ^n/ρ)*‖z-w‖)*ρ := by
+        gcongr
+      _ = (((n+1 : ℕ) : ℝ)*ρ^(n+1)/ρ)*‖z-w‖ := by
+        rw [pow_succ,Nat.cast_add,Nat.cast_one]
+        field_simp
+        ring
+
+theorem spectral_mixed_power_difference_bound (a b : ℕ) (ρ : ℝ) (hρ : 0 < ρ)
+    (z w : ℂ) (hz : ‖z‖ ≤ ρ) (hw : ‖w‖ ≤ ρ) :
+    ‖z^a*(star z)^b-w^a*(star w)^b‖ ≤ (((a+b : ℕ) : ℝ)*ρ^(a+b)/ρ)*‖z-w‖ := by
+  have hp := spectral_power_difference_bound a ρ hρ z w hz hw
+  have hs := spectral_power_difference_bound b ρ hρ (star z) (star w)
+    (by simpa only [norm_star] using hz) (by simpa only [norm_star] using hw)
+  simp only [← star_sub,norm_star] at hs
+  have he : z^a*(star z)^b-w^a*(star w)^b=
+      (z^a-w^a)*(star z)^b+w^a*((star z)^b-(star w)^b) := by ring
+  rw [he]
+  calc
+    _ ≤ ‖(z^a-w^a)*(star z)^b‖+‖w^a*((star z)^b-(star w)^b)‖ := norm_add_le _ _
+    _ = ‖z^a-w^a‖*‖z‖^b+‖w‖^a*‖(star z)^b-(star w)^b‖ := by
+      simp only [norm_mul,norm_pow,norm_star]
+    _ ≤ (((a : ℝ)*ρ^a/ρ)*‖z-w‖)*ρ^b+ρ^a*(((b : ℝ)*ρ^b/ρ)*‖z-w‖) := by
+      gcongr
+    _ = _ := by rw [pow_add,Nat.cast_add]; ring
+
+theorem spectralCoefficient_subunit_difference (m : ℕ) (hm : 1 ≤ m)
+    (ρ : ℝ) (hρ : 0 < ρ) (z w : ℂ) (hz : ‖z‖ ≤ ρ) (hw : ‖w‖ ≤ ρ) :
+    ‖spectralDiagonalCoefficient m z-spectralDiagonalCoefficient m w‖+
+      ‖spectralCrossCoefficient m z-spectralCrossCoefficient m w‖ ≤
+      (2*(m : ℝ)*(2*(m : ℝ)+1)*ρ^(2*m)/ρ)*‖z-w‖ := by
+  have hp := spectral_mixed_power_difference_bound m m ρ hρ z w hz hw
+  have hmixed := spectral_mixed_power_difference_bound (m+1) (m-1) ρ hρ z w hz hw
+  have he : m+1+(m-1)=2*m := by omega
+  have he' : m+m=2*m := by omega
+  rw [he'] at hp
+  rw [he] at hmixed
+  have hdiag : ‖spectralDiagonalCoefficient m z-spectralDiagonalCoefficient m w‖ ≤
+      ((m : ℝ)+1)*(((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖ := by
+    have heq : spectralDiagonalCoefficient m z-spectralDiagonalCoefficient m w=
+        ((m+1 : ℕ) : ℂ)*(z^m*(star z)^m-w^m*(star w)^m) := by
+      simp only [spectralDiagonalCoefficient]
+      ring
+    rw [heq,norm_mul,Complex.norm_natCast,Nat.cast_add,Nat.cast_one]
+    calc
+      _ ≤ ((m : ℝ)+1)*((((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖) := by gcongr
+      _ = _ := by ring
+  have hcross : ‖spectralCrossCoefficient m z-spectralCrossCoefficient m w‖ ≤
+      (m : ℝ)*(((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖ := by
+    have heq : spectralCrossCoefficient m z-spectralCrossCoefficient m w=
+        (m : ℂ)*(z^(m+1)*(star z)^(m-1)-w^(m+1)*(star w)^(m-1)) := by
+      simp only [spectralCrossCoefficient]
+      ring
+    rw [heq,norm_mul,Complex.norm_natCast]
+    calc
+      _ ≤ (m : ℝ)*((((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖) := by gcongr
+      _ = _ := by ring
+  calc
+    _ ≤ ((m : ℝ)+1)*(((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖+
+        (m : ℝ)*(((2*m : ℕ) : ℝ)*ρ^(2*m)/ρ)*‖z-w‖ := add_le_add hdiag hcross
+    _ = _ := by push_cast; ring
+
+theorem spectralCoefficient_difference_rate_tendsto (ρ : ℝ) (hρ : 0 < ρ) (hρ1 : ρ < 1) :
+    Tendsto (fun n : ℕ => 2*(n : ℝ)*(2*(n : ℝ)+1)*ρ^(2*n)/ρ) atTop (𝓝 0) := by
+  have hq : ρ^2 < 1 := pow_lt_one₀ hρ.le hρ1 (by decide : 2 ≠ 0)
+  have h₂ := tendsto_pow_const_mul_const_pow_of_lt_one 2 (sq_nonneg ρ) hq
+  have h₁ := tendsto_self_mul_const_pow_of_lt_one (sq_nonneg ρ) hq
+  convert ((h₂.const_mul 4).add (h₁.const_mul 2)).div_const ρ using 1
+  · funext n
+    rw [pow_mul]
+    ring
+  · norm_num
+
+theorem spectralCoefficient_weighted_difference (m : ℕ) (hm : 1 ≤ m)
+    (ρ : ℝ) (hρ : 0 < ρ) (q p e : ℂ) (κ t : ℝ)
+    (hq : ‖q‖ ≤ ρ) (hp : ‖p‖ ≤ ρ)
+    (he : q-p=(Real.exp (-κ*t) : ℂ)*e) :
+    ‖(Real.exp (κ*t) : ℂ)*(spectralDiagonalCoefficient m q-spectralDiagonalCoefficient m p)‖+
+      ‖(Real.exp (κ*t) : ℂ)*(spectralCrossCoefficient m q-spectralCrossCoefficient m p)‖ ≤
+      (2*(m : ℝ)*(2*(m : ℝ)+1)*ρ^(2*m)/ρ)*‖e‖ := by
+  have hb := spectralCoefficient_subunit_difference m hm ρ hρ q p hq hp
+  have hn : ‖q-p‖=Real.exp (-κ*t)*‖e‖ := by
+    rw [he,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
+  have hh := mul_le_mul_of_nonneg_left hb (Real.exp_nonneg (κ*t))
+  have hexp : Real.exp (κ*t)*Real.exp (-κ*t)=1 := by rw [← Real.exp_add]; simp
+  rw [hn] at hh
+  simp only [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
+  calc
+    _ = Real.exp (κ*t)*(‖spectralDiagonalCoefficient m q-spectralDiagonalCoefficient m p‖+
+        ‖spectralCrossCoefficient m q-spectralCrossCoefficient m p‖) := by ring
+    _ ≤ Real.exp (κ*t)*((2*(m : ℝ)*(2*(m : ℝ)+1)*ρ^(2*m)/ρ)*(Real.exp (-κ*t)*‖e‖)) := hh
+    _ = (Real.exp (κ*t)*Real.exp (-κ*t))*
+        (2*(m : ℝ)*(2*(m : ℝ)+1)*ρ^(2*m)/ρ)*‖e‖ := by ring
+    _ = _ := by rw [hexp,one_mul]
+
+theorem radialShooting_spectralDifference_uniform_small :
+    ∃ ρ : ℝ, 0 < ρ ∧ ρ < 1 ∧ ∃ δ : ℕ → ℝ,
+      (∀ n, 0 ≤ δ n) ∧ Tendsto δ atTop (𝓝 0) ∧
+      ∀ᶠ n in atTop, ∀ z : ProfileCertificate.ProfileMatchingBall, ∀ t : ℝ,
+        Real.log innerBoundaryRadius ≤ t → ∀ p : ℂ, ‖p‖ ≤ ρ →
+          let q := (radialExteriorCanonical (radialShootingNu n z) n (radialShootingM z)
+            (Real.log innerBoundaryRadius) t).1
+          ‖spectralDiagonalCoefficient n q-spectralDiagonalCoefficient n p‖+
+            ‖spectralCrossCoefficient n q-spectralCrossCoefficient n p‖ ≤ δ n*‖q-p‖ := by
+  obtain ⟨κ,σ,hκ,hσ,he⟩ := radialShooting_uniform_annulus
+  let ρ := max σ (1/2)
+  have hρ : 0 < ρ := lt_of_lt_of_le (by norm_num) (le_max_right _ _)
+  have hρ1 : ρ < 1 := max_lt hσ (by norm_num)
+  refine ⟨ρ,hρ,hρ1,fun n => 2*(n : ℝ)*(2*(n : ℝ)+1)*ρ^(2*n)/ρ,
+    fun n => by positivity,spectralCoefficient_difference_rate_tendsto ρ hρ hρ1,?_⟩
+  filter_upwards [he,eventually_ge_atTop 1] with n hn hmn z t ht p hp
+  exact spectralCoefficient_subunit_difference n hmn ρ hρ _ p
+    ((hn z t ht).2.trans (le_max_left _ _)) hp
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSubunitFieldLimit.lean

@@ -0,0 +1,27 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralFieldParameterLimit
+
+namespace OAI
+
+/-! The elementary contraction bound also converges on a fixed subunit
+profile ball, so the limiting gap holds for every sufficiently large power. -/
+
+open Filter Topology
+namespace DefocusingNLS
+
+theorem circularFieldBound_subunit_tendsto (νp νm : ℕ → ℂ) (μp μm η : ℂ)
+    (hp : Tendsto νp atTop (𝓝 μp)) (hm : Tendsto νm atTop (𝓝 μm))
+    (m : ℕ → ℕ) (hmTop : Tendsto m atTop atTop)
+    (ρ : ℝ) (hρ : 0 ≤ ρ) (hρ1 : ρ < 1) :
+    Tendsto (fun n => circularFieldBound (νp n) (νm n) η (m n) ρ) atTop
+      (𝓝 (circularFieldBound μp μm η 1 0)) := by
+  have h1 := ((hp.const_mul 2).add_const 10).norm
+  have h2 := ((hm.const_mul 2).add_const 10).norm
+  have h3 := ((hp.mul (hp.add_const 10)).sub_const η).norm
+  have h4 := ((hm.mul (hm.add_const 10)).sub_const η).norm
+  have h5 := (spectralSubunitCoefficient_decay ρ hρ hρ1).comp hmTop
+  simpa only [Function.comp_def,circularFieldBound,pow_succ,pow_zero,zero_mul,mul_zero,add_zero]
+    using ((((h1.const_add 1).add h2).add h3).add h4).add h5
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralSubunitPressure.lean

@@ -0,0 +1,35 @@
+import Mathlib.Analysis.SpecificLimits.Normed
+import Mathlib.Topology.UniformSpace.UniformConvergence
+
+namespace OAI
+
+/-! The pressure divided by its small scale vanishes uniformly where the limiting amplitude is subunit. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralSubunit_scaled_power_uniform {s : Set ℝ} (H : ℕ → ℝ → ℝ) (H₀ : ℝ → ℝ)
+    (hH : TendstoUniformlyOn H H₀ atTop s) (ρ : ℝ) (hρ : 0 ≤ ρ) (hρ1 : ρ < 1)
+    (hbound : ∀ r ∈ s, ‖H₀ r‖ ≤ ρ) (p : ℕ → ℕ) (hp : Tendsto p atTop atTop) :
+    TendstoUniformlyOn (fun n r => (p n : ℝ)*(H n r)^(p n)) (fun _ => 0) atTop s := by
+  let q := (ρ+1)/2
+  have hq0 : 0 ≤ q := by dsimp [q]; positivity
+  have hq1 : q < 1 := by dsimp [q]; linarith
+  have hgap : 0 < q-ρ := by dsimp [q]; linarith
+  have hclose : ∀ᶠ n in atTop, ∀ r ∈ s, ‖H n r‖ ≤ q := by
+    filter_upwards [(Metric.tendstoUniformlyOn_iff.mp hH) (q-ρ) hgap] with n hn r hr
+    have hd : ‖H n r-H₀ r‖ < q-ρ := by
+      simpa only [dist_eq_norm,norm_sub_rev] using hn r hr
+    exact (norm_le_norm_sub_add (H n r) (H₀ r)).trans (by linarith [hbound r hr])
+  have hdecay : Tendsto (fun n => (p n : ℝ)*q^(p n)) atTop (𝓝 0) :=
+    (tendsto_self_mul_const_pow_of_lt_one hq0 hq1).comp hp
+  rw [Metric.tendstoUniformlyOn_iff]
+  intro ε hε
+  filter_upwards [hclose,hdecay.eventually (Iio_mem_nhds hε)] with n hn hb r hr
+  rw [dist_zero_left,norm_mul,norm_pow,Real.norm_natCast]
+  exact (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (norm_nonneg _) (hn r hr) (p n))
+    (Nat.cast_nonneg (p n))).trans_lt hb
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailEnergyLinear.lean

@@ -0,0 +1,40 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEnergyOperations
+
+namespace OAI
+
+/-! Finite linear combinations preserve the weighted top energy on a tail. -/
+
+open Set Filter Topology MeasureTheory
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+theorem spectralWeighted_top_smul_integrable (u : ℝ → V) (R : ℝ) (N : ℕ) (c : ℂ)
+    (hu : IntegrableOn (fun r => r^11*‖iteratedDeriv N u r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖iteratedDeriv N (fun s => c • u s) r‖^2) (Ioi R) := by
+  simpa only [iteratedDeriv_fun_const_smul_field] using
+    spectralWeighted_square_smul_integrable (iteratedDeriv N u) R c hu
+
+theorem spectralWeighted_top_add_integrable (u v : ℝ → V) (R : ℝ) (hR : 0≤R) (N : ℕ)
+    (hcU : ContDiffOn ℝ ∞ u (Ioi R)) (hcV : ContDiffOn ℝ ∞ v (Ioi R))
+    (hu : IntegrableOn (fun r => r^11*‖iteratedDeriv N u r‖^2) (Ioi R))
+    (hv : IntegrableOn (fun r => r^11*‖iteratedDeriv N v r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖iteratedDeriv N (fun s => u s+v s) r‖^2) (Ioi R) := by
+  have hn := spectralWeighted_top_smul_integrable v R N (-1) hv
+  have hh := spectralWeighted_top_sub_integrable u (fun s => (-1 : ℂ) • v s) R hR N
+    hcU (hcV.const_smul (-1 : ℂ)) hu hn
+  simpa only [neg_one_smul,sub_neg_eq_add] using hh
+
+theorem spectralWeighted_top_combination_integrable (u v : ℝ → V)
+    (R : ℝ) (hR : 0≤R) (N : ℕ) (a b : ℂ)
+    (hcU : ContDiffOn ℝ ∞ u (Ioi R)) (hcV : ContDiffOn ℝ ∞ v (Ioi R))
+    (hu : IntegrableOn (fun r => r^11*‖iteratedDeriv N u r‖^2) (Ioi R))
+    (hv : IntegrableOn (fun r => r^11*‖iteratedDeriv N v r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖iteratedDeriv N (fun s => a • u s+b • v s) r‖^2) (Ioi R) :=
+  spectralWeighted_top_add_integrable _ _ R hR N (hcU.const_smul a) (hcV.const_smul b)
+    (spectralWeighted_top_smul_integrable u R N a hu)
+    (spectralWeighted_top_smul_integrable v R N b hv)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailEnergyOperations.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailWeightedL2
+
+namespace OAI
+
+/-! Weighted top energy is preserved by subtracting an outgoing parameter correction. -/
+
+open Set Filter Topology MeasureTheory
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+theorem spectralWeighted_square_sub_integrable (u v : ℝ → V) (R : ℝ) (hR : 0≤R)
+    (hcU : ContinuousOn u (Ioi R)) (hcV : ContinuousOn v (Ioi R))
+    (hu : IntegrableOn (fun r => r^11*‖u r‖^2) (Ioi R))
+    (hv : IntegrableOn (fun r => r^11*‖v r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖u r-v r‖^2) (Ioi R) := by
+  have hmajor := (hu.add hv).const_mul (2 : ℝ)
+  apply hmajor.mono'
+    (((continuousOn_id.pow 11).mul ((hcU.sub hcV).norm.pow 2)).aestronglyMeasurable measurableSet_Ioi)
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  have hr₀ : 0≤r := hR.trans hr.le
+  have hsq : ‖u r-v r‖^2 ≤ 2*(‖u r‖^2+‖v r‖^2) := by
+    have h := norm_sub_le (u r) (v r)
+    have hnorm := norm_nonneg (u r-v r)
+    nlinarith [sq_nonneg (‖u r‖-‖v r‖)]
+  change ‖(r^11*‖u r-v r‖^2 : ℝ)‖ ≤ 2*(r^11*‖u r‖^2+r^11*‖v r‖^2)
+  rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (pow_nonneg hr₀ 11) (sq_nonneg ‖u r-v r‖))]
+  calc
+    _ ≤ r^11*(2*(‖u r‖^2+‖v r‖^2)) :=
+      mul_le_mul_of_nonneg_left hsq (pow_nonneg hr₀ _)
+    _ = _ := by ring
+
+theorem spectralWeighted_square_smul_integrable (u : ℝ → V) (R : ℝ) (c : ℂ)
+    (hu : IntegrableOn (fun r => r^11*‖u r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖c • u r‖^2) (Ioi R) := by
+  have hi : IntegrableOn (fun r => ‖c‖^2*(r^11*‖u r‖^2)) (Ioi R) := hu.const_mul _
+  apply hi.congr_fun _ measurableSet_Ioi
+  intro r _
+  dsimp only
+  rw [norm_smul,mul_pow]
+  ring
+
+theorem spectralWeighted_top_sub_integrable (u v : ℝ → V) (R : ℝ) (hR : 0≤R) (N : ℕ)
+    (hcU : ContDiffOn ℝ ∞ u (Ioi R)) (hcV : ContDiffOn ℝ ∞ v (Ioi R))
+    (hu : IntegrableOn (fun r => r^11*‖iteratedDeriv N u r‖^2) (Ioi R))
+    (hv : IntegrableOn (fun r => r^11*‖iteratedDeriv N v r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖iteratedDeriv N (fun s => u s-v s) r‖^2) (Ioi R) := by
+  have hi := spectralWeighted_square_sub_integrable (iteratedDeriv N u) (iteratedDeriv N v) R hR
+    (homogeneousPair_iteratedDeriv_smooth_tail u R hcU N).continuousOn
+    (homogeneousPair_iteratedDeriv_smooth_tail v R hcV N).continuousOn hu hv
+  apply hi.congr_fun _ measurableSet_Ioi
+  intro r hr
+  dsimp only
+  rw [iteratedDeriv_fun_sub
+    (((hcU r hr).contDiffAt (Ioi_mem_nhds hr)).of_le (by simp))
+    (((hcV r hr).contDiffAt (Ioi_mem_nhds hr)).of_le (by simp))]
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailEnergyPair.lean

@@ -0,0 +1,39 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEnergyOperations
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousRadialPairL2
+
+namespace OAI
+
+/-! Conversion between the two radial channel energies and the pair norm. -/
+
+open Set Filter Topology MeasureTheory
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+theorem spectralWeighted_pair_integrable (U : ℝ → V) (R : ℝ) (hR : 0≤R)
+    (hU : ContinuousOn U (Ioi R))
+    (hp : IntegrableOn (fun r => r^11*‖(U r).1‖^2) (Ioi R))
+    (hm : IntegrableOn (fun r => r^11*‖(U r).2‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖U r‖^2) (Ioi R) := by
+  have hi := radial_pair_energy_integrable (fun r => (U r).1) (fun r => (U r).2) R hp hm
+  apply hi.mono' (((continuousOn_id.pow 11).mul (hU.norm.pow 2)).aestronglyMeasurable measurableSet_Ioi)
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  have hr₀ : 0≤r := hR.trans hr.le
+  change ‖(r^11*‖U r‖^2 : ℝ)‖ ≤ r^11*homogeneousPairEnergy ((U r).1,(U r).2)
+  rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (pow_nonneg hr₀ 11) (sq_nonneg ‖U r‖))]
+  exact mul_le_mul_of_nonneg_left (homogeneousPairEnergy_lower (U r)) (pow_nonneg hr₀ 11)
+
+theorem spectralWeighted_scalar_of_pair (U : ℝ → V) (f : ℝ → ℂ) (R : ℝ) (hR : 0≤R)
+    (hf : ContinuousOn f (Ioi R)) (hb : ∀ r, R<r → ‖f r‖≤‖U r‖)
+    (hU : IntegrableOn (fun r => r^11*‖U r‖^2) (Ioi R)) :
+    IntegrableOn (fun r => r^11*‖f r‖^2) (Ioi R) := by
+  apply hU.mono' (((continuousOn_id.pow 11).mul (hf.norm.pow 2)).aestronglyMeasurable measurableSet_Ioi)
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  have hr₀ : 0≤r := hR.trans hr.le
+  change ‖(r^11*‖f r‖^2 : ℝ)‖ ≤ r^11*‖U r‖^2
+  rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (pow_nonneg hr₀ 11) (sq_nonneg ‖f r‖))]
+  exact mul_le_mul_of_nonneg_left
+    (pow_le_pow_left₀ (norm_nonneg _) (hb r hr) 2) (pow_nonneg hr₀ 11)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailEulerPhysical.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousEulerPhysical
+
+namespace OAI
+
+/-! Falling Euler derivatives on a tail only require smoothness on that tail. -/
+
+open Set Filter Topology
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+theorem homogeneousPair_iteratedDeriv_smooth_tail (U : ℝ → V) (R : ℝ)
+    (hU : ContDiffOn ℝ ∞ U (Ioi R)) (n : ℕ) :
+    ContDiffOn ℝ ∞ (iteratedDeriv n U) (Ioi R) := by
+  induction n with
+  | zero => simpa using hU
+  | succ n ih =>
+      rw [iteratedDeriv_succ]
+      exact ih.deriv_of_isOpen isOpen_Ioi (by simp)
+
+theorem homogeneousEulerDeriv_physical_tail (U : ℝ → V) (L : ℝ)
+    (hU : ContDiffOn ℝ ∞ U (Ioi (Real.exp L))) (n : ℕ) (t : ℝ) (ht : L<t) :
+    homogeneousEulerDeriv (fun s => U (Real.exp s)) n t =
+      Real.exp ((n : ℝ)*t) • iteratedDeriv n U (Real.exp t) := by
+  induction n generalizing t with
+  | zero => simp [homogeneousEulerDeriv]
+  | succ n ih =>
+      have heq : homogeneousEulerDeriv (fun s => U (Real.exp s)) n =ᶠ[𝓝 t]
+          (fun s => Real.exp ((n : ℝ)*s) • iteratedDeriv n U (Real.exp s)) := by
+        filter_upwards [Ioi_mem_nhds ht] with s hs
+        exact ih s hs
+      have het : Real.exp L < Real.exp t := Real.exp_lt_exp.mpr ht
+      have hUn : HasDerivAt (iteratedDeriv n U) (iteratedDeriv (n+1) U (Real.exp t))
+          (Real.exp t) := by
+        rw [iteratedDeriv_succ]
+        exact (((homogeneousPair_iteratedDeriv_smooth_tail U (Real.exp L) hU n) _ het).contDiffAt
+          (Ioi_mem_nhds het)).differentiableAt (by simp) |>.hasDerivAt
+      have hUt : HasDerivAt (fun s => iteratedDeriv n U (Real.exp s))
+          (Real.exp t • iteratedDeriv (n+1) U (Real.exp t)) t :=
+        hUn.scomp t (Real.hasDerivAt_exp t)
+      have hweight : HasDerivAt (fun s : ℝ => Real.exp ((n : ℝ)*s))
+          ((n : ℝ)*Real.exp ((n : ℝ)*t)) t := by
+        convert ((hasDerivAt_id t).const_mul (n : ℝ)).exp using 1 <;> simp [mul_comm]
+      have hh := hweight.smul hUt
+      have hd := hh.congr_of_eventuallyEq heq
+      change deriv (homogeneousEulerDeriv (fun s => U (Real.exp s)) n) t -
+        (n : ℝ) • homogeneousEulerDeriv (fun s => U (Real.exp s)) n t = _
+      rw [hd.deriv,ih t ht]
+      simp only [smul_smul]
+      have hexp : Real.exp ((n : ℝ)*t)*Real.exp t=Real.exp (((n+1 : ℕ) : ℝ)*t) := by
+        rw [← Real.exp_add]
+        congr 1
+        push_cast
+        ring
+      rw [hexp]
+      abel
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailLinear.lean

@@ -0,0 +1,97 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralCircularTail
+
+namespace OAI
+
+/-! The backward circular integral is a bounded complex-linear operator. -/
+
+open Set MeasureTheory
+open scoped BoundedContinuousFunction
+namespace DefocusingNLS
+
+theorem boundedRadialExteriorTail_zero (κ : ℝ) (hκ : 0 < κ) :
+    boundedRadialExteriorTail κ hκ 0=0 := by
+  apply BoundedContinuousFunction.ext
+  intro t
+  change radialExteriorTailIntegral κ (0 : ℝ →ᵇ ℂ × ℂ) t=0
+  simp [radialExteriorTailIntegral,radialExteriorPropagator]
+
+theorem boundedRadialExteriorTail_smul (κ : ℝ) (hκ : 0 < κ)
+    (a : ℂ) (g : ℝ →ᵇ ℂ × ℂ) :
+    boundedRadialExteriorTail κ hκ (a • g)=a • boundedRadialExteriorTail κ hκ g := by
+  apply BoundedContinuousFunction.ext
+  intro t
+  change radialExteriorTailIntegral κ (a • g) t=a • radialExteriorTailIntegral κ g t
+  have hp (u : ℝ) : radialExteriorPropagator t (t+u) ((a • g) (t+u))=
+      a • radialExteriorPropagator t (t+u) (g (t+u)) := by
+    apply Prod.ext <;> simp [radialExteriorPropagator,smul_eq_mul,mul_left_comm]
+  unfold radialExteriorTailIntegral
+  change -(∫ u in Ioi (0 : ℝ), Real.exp (-κ*u) •
+    radialExteriorPropagator t (t+u) ((a • g) (t+u))) =
+      a • -(∫ u in Ioi (0 : ℝ), Real.exp (-κ*u) •
+        radialExteriorPropagator t (t+u) (g (t+u)))
+  simp_rw [hp,smul_comm (Real.exp (-κ * _)) a]
+  rw [integral_smul,smul_neg]
+
+theorem boundedRadialExteriorTail_add (κ : ℝ) (hκ : 0 < κ)
+    (g h : ℝ →ᵇ ℂ × ℂ) :
+    boundedRadialExteriorTail κ hκ (g+h)=
+      boundedRadialExteriorTail κ hκ g+boundedRadialExteriorTail κ hκ h := by
+  have hs : boundedRadialExteriorTail κ hκ (-h)= -boundedRadialExteriorTail κ hκ h := by
+    have he : boundedRadialExteriorTail κ hκ (0-h)=
+        boundedRadialExteriorTail κ hκ 0-boundedRadialExteriorTail κ hκ h := by
+      apply BoundedContinuousFunction.ext
+      intro t
+      exact radialExteriorTailIntegral_sub κ hκ 0 h t
+    simpa only [zero_sub,boundedRadialExteriorTail_zero] using he
+  have he : boundedRadialExteriorTail κ hκ (g-(-h))=
+      boundedRadialExteriorTail κ hκ g-boundedRadialExteriorTail κ hκ (-h) := by
+      apply BoundedContinuousFunction.ext
+      intro t
+      exact radialExteriorTailIntegral_sub κ hκ g (-h) t
+  simpa only [sub_neg_eq_add,hs] using he
+
+noncomputable def boundedRadialExteriorTailCLM (κ : ℝ) (hκ : 0 < κ) :
+    (ℝ →ᵇ ℂ × ℂ) →L[ℂ] (ℝ →ᵇ ℂ × ℂ) :=
+  LinearMap.mkContinuous
+    { toFun := boundedRadialExteriorTail κ hκ
+      map_add' := boundedRadialExteriorTail_add κ hκ
+      map_smul' := fun a g => boundedRadialExteriorTail_smul κ hκ a g }
+    (1/κ) (fun g => by
+      change ‖boundedRadialExteriorTail κ hκ g‖ ≤ (1/κ)*‖g‖
+      rw [one_div_mul_eq_div]
+      exact boundedRadialExteriorTail_norm κ hκ g)
+
+theorem circularTail_add (κ : ℝ) (hκ : 0 < κ) (g h : CircularTailSpace) :
+    circularTail κ hκ (g+h)=circularTail κ hκ g+circularTail κ hκ h := by
+  apply Prod.ext
+  · exact boundedRadialExteriorTail_add κ hκ g.1 h.1
+  · change star (boundedRadialExteriorTail κ hκ (star (g.2+h.2)))=_
+    rw [star_add,boundedRadialExteriorTail_add,star_add]
+    rfl
+
+theorem circularTail_smul (κ : ℝ) (hκ : 0 < κ) (a : ℂ) (g : CircularTailSpace) :
+    circularTail κ hκ (a • g)=a • circularTail κ hκ g := by
+  apply Prod.ext
+  · exact boundedRadialExteriorTail_smul κ hκ a g.1
+  · change star (boundedRadialExteriorTail κ hκ (star (a • g.2)))=_
+    rw [star_smul,boundedRadialExteriorTail_smul,star_smul,star_star]
+    rfl
+
+noncomputable def circularTailCLM (κ : ℝ) (hκ : 0 < κ) :
+    CircularTailSpace →L[ℂ] CircularTailSpace :=
+  LinearMap.mkContinuous
+    { toFun := circularTail κ hκ
+      map_add' := circularTail_add κ hκ
+      map_smul' := fun a g => circularTail_smul κ hκ a g }
+    (1/κ) (fun g => by
+      change ‖circularTail κ hκ g‖ ≤ (1/κ)*‖g‖
+      rw [one_div_mul_eq_div]
+      exact circularTail_norm κ hκ g)
+
+theorem circularTailCLM_norm (κ : ℝ) (hκ : 0 < κ) :
+    ‖circularTailCLM κ hκ‖ ≤ 1/κ := by
+  exact LinearMap.mkContinuous_norm_le _ (by positivity) _
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailOutgoingSelection.lean

@@ -0,0 +1,143 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailRows
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousOutgoingDefectEquation
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousPhysicalColumnJets
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousOutgoingPropagation
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousRadialRiccati
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousLogEquation
+
+namespace OAI
+
+/-! Selection of the outgoing plane from regularity and finite energy on a tail. -/
+
+open Set Filter Topology MeasureTheory
+open scoped ContDiff
+
+namespace DefocusingNLS
+
+local notation "V" => ℂ × ℂ
+local notation "V₄" => V × V
+local notation "End" => V →L[ℂ] V
+
+theorem homogeneousPhysicalOutgoing_tail_selection
+    (νp νm eta : ℂ) (m n : ℕ) (Q : ℝ → ℂ) (Z Zp Zm : ℝ → V₄)
+    (R₀ L c : ℝ) (hR₀ : 0 < R₀) (hL : Real.log R₀ ≤ L) (hc : 0 < c)
+    (hν : νp.re = νm.re)
+    (hbeta : -6 ≤ (n : ℝ) - (11 + νp.re))
+    (hgap : 0 < ((n + 1 : ℕ) : ℝ) + n - (11 + νp.re))
+    (hQ : ContinuousOn Q (Ici R₀))
+    (hZ : ∀ r, R₀ ≤ r → HasDerivAt Z
+      (spectralPhysicalCircularField νp νm eta m (Q r) r (Z r)) r)
+    (hZp : ∀ r, R₀ ≤ r → HasDerivAt Zp
+      (spectralPhysicalCircularField νp νm eta m (Q r) r (Zp r)) r)
+    (hZm : ∀ r, R₀ ≤ r → HasDerivAt Zm
+      (spectralPhysicalCircularField νp νm eta m (Q r) r (Zm r)) r)
+    (hU : ContDiffOn ℝ ∞ (fun r => spectralPhysicalValueMap (Z r)) (Ioi R₀))
+    (hbounded : ∃ M : ℝ, 0 ≤ M ∧ ∀ r, R₀≤r → ‖spectralPhysicalValueMap (Z r)‖ ≤ M)
+    (hL2p : IntegrableOn (fun r => r ^ 11 *
+      ‖(iteratedDeriv (n + 1) (fun s => spectralPhysicalValueMap (Z s)) r).1‖ ^ 2) (Ioi R₀))
+    (hL2m : IntegrableOn (fun r => r ^ 11 *
+      ‖(iteratedDeriv (n + 1) (fun s => spectralPhysicalValueMap (Z s)) r).2‖ ^ 2) (Ioi R₀))
+    (hB : ContDiffOn ℝ ∞ homogeneousLogRadialDamping (Ioi L))
+    (hC : ContDiffOn ℝ ∞
+      (homogeneousLogRadialStiffness νp νm eta m (fun t => Q (Real.exp t))) (Ioi L))
+    (hrow : ∀ᶠ t in atTop, ∀ w : V,
+      c * Real.exp (2 * (n : ℝ) * t) * ‖w‖ ≤
+      ‖(homogeneousEulerRows homogeneousLogRadialDamping
+        (homogeneousLogRadialStiffness νp νm eta m (fun s => Q (Real.exp s)))
+        (n + 1)).2 t w‖)
+    (hrem : ∃ K : ℝ, 0 ≤ K ∧ ∀ᶠ t in atTop,
+      spectralValueDet (spectralPhysicalValueMap (Zp (Real.exp t)))
+        (spectralPhysicalValueMap (Zm (Real.exp t))) ≠ 0 ∧
+      ‖spectralTwoColumns
+        (homogeneousEulerDeriv (fun s => spectralPhysicalValueMap (Zp (Real.exp s))) (n + 1) t)
+        (homogeneousEulerDeriv (fun s => spectralPhysicalValueMap (Zm (Real.exp s))) (n + 1) t) *
+        spectralValueInverse (spectralPhysicalValueMap (Zp (Real.exp t)))
+          (spectralPhysicalValueMap (Zm (Real.exp t)))‖ ≤ K)
+    (herr : ∃ M : ℝ, 0 ≤ M ∧ ∀ᶠ r in atTop,
+      ‖spectralJetRobin (Zp r) (Zm r) - r⁻¹ • homogeneousDiagonal νp νm‖ ≤ M / r ^ 3)
+    (R : ℝ) (hR : R₀ ≤ R) :
+    ∃ a : V, Z R = a.1 • Zp R + a.2 • Zm R := by
+  let U := fun r => spectralPhysicalValueMap (Z r)
+  let Vd := fun r => spectralPhysicalDerivativeMap (Z r)
+  let A := fun r => spectralJetRobin (Zp r) (Zm r)
+  let W := homogeneousRadialDefect A U Vd
+  let logU := fun t => U (Real.exp t)
+  let logV := fun t => Real.exp t • Vd (Real.exp t)
+  let up := fun t => spectralPhysicalValueMap (Zp (Real.exp t))
+  let um := fun t => spectralPhysicalValueMap (Zm (Real.exp t))
+  let dp := fun t => Real.exp t • spectralPhysicalDerivativeMap (Zp (Real.exp t))
+  let dm := fun t => Real.exp t • spectralPhysicalDerivativeMap (Zm (Real.exp t))
+  let C := homogeneousLogRadialStiffness νp νm eta m (fun t => Q (Real.exp t))
+  have hrad (t : ℝ) (ht : L < t) : R₀ ≤ Real.exp t := by
+    rw [← Real.exp_log hR₀]
+    exact Real.exp_le_exp.mpr (hL.trans ht.le)
+  have hlogs (S : ℝ → V₄)
+      (hS : ∀ r, R₀ ≤ r → HasDerivAt S
+        (spectralPhysicalCircularField νp νm eta m (Q r) r (S r)) r)
+      (t : ℝ) (ht : L < t) :=
+    homogeneousPhysicalRadial_logEquation νp νm eta m Q
+      (fun r => spectralPhysicalValueMap (S r))
+      (fun r => spectralPhysicalDerivativeMap (S r)) t
+      (homogeneousPhysicalState_pair_derivatives νp νm eta m _ S _ (hS _ (hrad t ht))).1
+      (homogeneousPhysicalState_pair_derivatives νp νm eta m _ S _ (hS _ (hrad t ht))).2
+  have hAscale (t : ℝ) : spectralRobinOperator (up t) (um t) (dp t) (dm t) =
+      Real.exp t • A (Real.exp t) :=
+    homogeneousRobin_smul_derivatives _ _ _ _ _
+  obtain ⟨K, hK, hremK⟩ := hrem
+  obtain ⟨M, hM, hMbound⟩ := hbounded
+  let T := (homogeneousEulerRows homogeneousLogRadialDamping C (n + 1)).2
+  let Rem := fun t => spectralTwoColumns (homogeneousEulerDeriv up (n + 1) t)
+    (homogeneousEulerDeriv um (n + 1) t) * spectralValueInverse (up t) (um t)
+  have hid : ∀ᶠ t in atTop, homogeneousEulerDeriv logU (n + 1) t =
+      T t (Real.exp t • W (Real.exp t)) + Rem t (U (Real.exp t)) := by
+    filter_upwards [hremK, eventually_gt_atTop L] with t ht hLt
+    have hh := homogeneousEulerRows_defect_identity homogeneousLogRadialDamping C
+      up um dp dm logU logV L hB hC
+      (fun t ht => (hlogs Zp hZp t ht).1) (fun t ht => (hlogs Zm hZm t ht).1)
+      (fun t ht => (hlogs Zp hZp t ht).2) (fun t ht => (hlogs Zm hZm t ht).2)
+      (fun t ht => (hlogs Z hZ t ht).1) (fun t ht => (hlogs Z hZ t ht).2)
+      (n + 1) t hLt ht.1
+    have hw : logV t - spectralRobinOperator (up t) (um t) (dp t) (dm t) (logU t) =
+        Real.exp t • W (Real.exp t) := by
+      rw [hAscale]
+      simp only [logV, logU, W, homogeneousRadialDefect, smul_apply, smul_sub]
+    simpa only [hw] using hh
+  have hcomp := homogeneousOutgoingRows_tail_comparison U W T Rem n c K M R₀ hR₀
+    hU hc hK hM hMbound hrow (hremK.mono fun _ h => h.2) hid
+  have hd : ∀ᶠ r in atTop, spectralValueDet (spectralPhysicalValueMap (Zp r))
+      (spectralPhysicalValueMap (Zm r)) ≠ 0 := by
+    filter_upwards [Real.tendsto_log_atTop.eventually hremK,
+      eventually_gt_atTop (0 : ℝ)] with r hr hr0
+    simpa only [Real.exp_log hr0] using hr.1
+  obtain ⟨R₁, hR₁⟩ := eventually_atTop.mp hd
+  let R₂ := max R₀ R₁
+  have hW (r : ℝ) (hr : R₂ ≤ r) : HasDerivAt W
+      (-(homogeneousRadialDamping r + A r) (W r)) r := by
+    have hr₀ := (le_max_left R₀ R₁).trans hr
+    have hp := homogeneousPhysicalState_pair_derivatives νp νm eta m _ Zp r (hZp r hr₀)
+    have hm := homogeneousPhysicalState_pair_derivatives νp νm eta m _ Zm r (hZm r hr₀)
+    have hu := homogeneousPhysicalState_pair_derivatives νp νm eta m _ Z r (hZ r hr₀)
+    exact homogeneousRadialDefect_from_columns _ _ _ _ _ _ U Vd r hp.1 hm.1 hp.2 hm.2
+      (hR₁ r ((le_max_right R₀ R₁).trans hr)) hu.1 hu.2
+  have hwzero := homogeneousOutgoingDefect_eventually_zero νp νm hν A W
+    (fun r => (iteratedDeriv (n + 1) U r).1)
+    (fun r => (iteratedDeriv (n + 1) U r).2) R₂ n (4 / c ^ 2)
+    ((4 / c ^ 2) * (K * M) ^ 2) (n + 1)
+    (hR₀.trans_le (le_max_left _ _)) (by positivity) hbeta hgap hW herr hcomp
+    (hL2p.mono_set (Ioi_subset_Ioi (le_max_left R₀ R₁)))
+    (hL2m.mono_set (Ioi_subset_Ioi (le_max_left R₀ R₁)))
+  have hout : ∀ᶠ r in atTop, ∃ a : V, Z r = a.1 • Zp r + a.2 • Zm r := by
+    filter_upwards [hwzero, hd] with r hw hd'
+    apply (spectralJetRobin_plane _ _ _ hd').1
+    exact sub_eq_zero.mp hw
+  obtain ⟨T', ⟨a, ha⟩, hT'⟩ := (hout.and (eventually_ge_atTop R)).exists
+  refine ⟨a, homogeneousPhysicalOutgoingPlane_backward νp νm eta m Q Z Zp Zm R T'
+    (hR₀.trans_le hR) hT' ?_ ?_ ?_ ?_ a ha⟩
+  · exact hQ.mono (fun _ hr => hR.trans hr.1)
+  · exact fun _ hr => hZ _ (hR.trans hr.1)
+  · exact fun _ hr => hZp _ (hR.trans hr.1)
+  · exact fun _ hr => hZm _ (hR.trans hr.1)
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailPowerBounds.lean

@@ -0,0 +1,98 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralParameterShearLogJets
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEulerPhysical
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousOutgoingEstimates
+
+namespace OAI
+
+/-! Bounds for every physical radial derivative from the normalized logarithmic jets. -/
+
+open Set Filter Topology
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+noncomputable def spectralPowerValues (νp νm : ℂ) (f g : ℝ → ℂ) (r : ℝ) : V :=
+  homogeneousPhysicalLogColumn νp νm f g (Real.log r)
+
+theorem spectralPowerValues_smooth (νp νm : ℂ) (f g : ℝ → ℂ) (L : ℝ)
+    (hf : ContDiffOn ℝ ∞ f (Ioi L)) (hg : ContDiffOn ℝ ∞ g (Ioi L)) :
+    ContDiffOn ℝ ∞ (spectralPowerValues νp νm f g) (Ioi (Real.exp L)) := by
+  have hlog : ContDiffOn ℝ ∞ Real.log (Ioi (Real.exp L)) :=
+    Real.contDiffOn_log.mono (fun r hr => (lt_trans (Real.exp_pos L) hr).ne')
+  have hmap : MapsTo Real.log (Ioi (Real.exp L)) (Ioi L) := by
+    intro r hr
+    simpa only [mem_Ioi,Real.log_exp] using
+      Real.log_lt_log (Real.exp_pos L) hr
+  have hfp := hf.comp hlog hmap
+  have hgp := hg.comp hlog hmap
+  have hEp : ContDiffOn ℝ ∞ (fun r : ℝ => Complex.exp (νp*(Real.log r : ℂ)))
+      (Ioi (Real.exp L)) :=
+    Complex.contDiff_exp.comp_contDiffOn
+      (contDiffOn_const.mul (Complex.ofRealCLM.contDiff.comp_contDiffOn hlog))
+  have hEm : ContDiffOn ℝ ∞ (fun r : ℝ => Complex.exp (νm*(Real.log r : ℂ)))
+      (Ioi (Real.exp L)) :=
+    Complex.contDiff_exp.comp_contDiffOn
+      (contDiffOn_const.mul (Complex.ofRealCLM.contDiff.comp_contDiffOn hlog))
+  exact (hEp.mul hfp).prodMk (hEm.mul hgp)
+
+theorem spectralPowerValues_derivative_bound (νp νm : ℂ) (hsame : νp.re=νm.re)
+    (f g : ℝ → ℂ) (σ : ℝ) (hf : HasLogJetBound σ f) (hg : HasLogJetBound σ g)
+    (n : ℕ) :
+    ∃ C : ℝ, 0≤C ∧ ∀ᶠ r in atTop,
+      ‖iteratedDeriv n (spectralPowerValues νp νm f g) r‖ ≤
+        C*r^(νp.re+σ-(n : ℝ)) := by
+  obtain ⟨Lf,hfs⟩ := hf.smooth
+  obtain ⟨Lg,hgs⟩ := hg.smooth
+  let L := max Lf Lg
+  have hfl := hfs.mono (Ioi_subset_Ioi (le_max_left Lf Lg))
+  have hgl := hgs.mono (Ioi_subset_Ioi (le_max_right Lf Lg))
+  have hU := spectralPowerValues_smooth νp νm f g L hfl hgl
+  have hE := (homogeneousNormalizedEuler_bound_order νp f σ hf n).pair
+    (homogeneousNormalizedEuler_bound_order νm g σ hg n)
+  obtain ⟨C,hC,hbound⟩ := hE.bound 0
+  refine ⟨C,hC,?_⟩
+  have hlogbound := Real.tendsto_log_atTop.eventually hbound
+  filter_upwards [hlogbound,eventually_gt_atTop (Real.exp L)] with r hr hrL
+  have hr₀ : 0<r := (Real.exp_pos L).trans hrL
+  have ht : L<Real.log r := by
+    simpa only [Real.log_exp] using Real.log_lt_log (Real.exp_pos L) hrL
+  let t := Real.log r
+  have hphys := homogeneousEulerDeriv_physical_tail (spectralPowerValues νp νm f g) L hU n t ht
+  have heq : (fun s => spectralPowerValues νp νm f g (Real.exp s))=
+      homogeneousPhysicalLogColumn νp νm f g := by
+    funext s
+    simp only [spectralPowerValues,Real.log_exp]
+  rw [heq,homogeneousPhysicalLogColumn_euler νp νm f g L hfl hgl n t ht] at hphys
+  have hnp : ‖Complex.exp (νp*(t : ℂ))‖=Real.exp (νp.re*t) := by
+    simp only [Complex.norm_exp,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,mul_zero,sub_zero]
+  have hnm : ‖Complex.exp (νm*(t : ℂ))‖=Real.exp (νp.re*t) := by
+    simpa only [hsame] using (show ‖Complex.exp (νm*(t : ℂ))‖=Real.exp (νm.re*t) by
+      simp only [Complex.norm_exp,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,mul_zero,sub_zero])
+  have hn := congrArg norm hphys
+  rw [homogeneousDiagonal_norm _ _ _ (Real.exp_pos _).le hnp hnm,norm_smul,
+    Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] at hn
+  simp only [iteratedDeriv_zero] at hr
+  have hr' : ‖homogeneousNormalizedEulerColumn νp νm f g n t‖≤C*Real.exp (σ*t) := hr
+  have hprod : Real.exp ((n : ℝ)*t)*
+      ‖iteratedDeriv n (spectralPowerValues νp νm f g) (Real.exp t)‖ ≤
+      C*Real.exp ((νp.re+σ)*t) := by
+    rw [← hn]
+    calc
+      _ ≤ Real.exp (νp.re*t)*(C*Real.exp (σ*t)) :=
+        mul_le_mul_of_nonneg_left hr' (Real.exp_pos _).le
+      _ = _ := by rw [add_mul,Real.exp_add]; ring
+  have hout : ‖iteratedDeriv n (spectralPowerValues νp νm f g) (Real.exp t)‖ ≤
+      C*Real.exp ((νp.re+σ-(n : ℝ))*t) := by
+    apply (mul_le_mul_iff_right₀ (Real.exp_pos ((n : ℝ)*t))).mp
+    calc
+      _ ≤ C*Real.exp ((νp.re+σ)*t) := by simpa only [mul_comm] using hprod
+      _ = _ := by
+        calc
+          C*Real.exp ((νp.re+σ)*t) =
+              C*Real.exp ((n : ℝ)*t+(νp.re+σ-(n : ℝ))*t) := by congr 2; ring
+          _ = _ := by rw [Real.exp_add]; ring
+  simpa only [t,Real.exp_log hr₀,Real.rpow_def_of_pos hr₀,mul_comm] using hout
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailRows.lean

@@ -0,0 +1,52 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Linear.HomogeneousOutgoingRadialRows
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailEulerPhysical
+
+namespace OAI
+
+/-! The physical row comparison only needs smoothness and boundedness on a tail. -/
+
+open Set Filter Topology
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+local notation "End" => V →L[ℂ] V
+
+theorem homogeneousOutgoingRows_tail_comparison
+    (U W : ℝ → V) (T R : ℝ → End) (n : ℕ) (c K M : ℝ)
+    (R₀ : ℝ) (hR₀ : 0<R₀) (hU : ContDiffOn ℝ ∞ U (Ioi R₀)) (hc : 0 < c) (hK : 0 ≤ K) (hM : 0 ≤ M)
+    (hbound : ∀ r, R₀≤r → ‖U r‖ ≤ M)
+    (hrow : ∀ᶠ t in atTop, ∀ w : V,
+      c * Real.exp (2 * (n : ℝ) * t) * ‖w‖ ≤ ‖T t w‖)
+    (hR : ∀ᶠ t in atTop, ‖R t‖ ≤ K)
+    (hid : ∀ᶠ t in atTop,
+      homogeneousEulerDeriv (fun s => U (Real.exp s)) (n + 1) t =
+        T t (Real.exp t • W (Real.exp t)) + R t (U (Real.exp t))) :
+    ∀ᶠ r in atTop, r ^ (2 * (n : ℝ)) * homogeneousPairEnergy (W r) ≤
+      (4 / c ^ 2) * homogeneousPairEnergy (iteratedDeriv (n + 1) U r) +
+        (4 / c ^ 2) * (K * M) ^ 2 * r ^ (-2 * ((n + 1 : ℕ) : ℝ)) := by
+  have hall := hrow.and (hR.and hid)
+  have hlog := Real.tendsto_log_atTop.eventually hall
+  filter_upwards [hlog, eventually_gt_atTop R₀] with r h hr₁
+  have hr : 0<r := hR₀.trans hr₁
+  have hlogr : Real.log R₀<Real.log r := Real.log_lt_log hR₀ hr₁
+  have hUt : ContDiffOn ℝ ∞ U (Ioi (Real.exp (Real.log R₀))) := by
+    simpa only [Real.exp_log hR₀] using hU
+  have he2 : Real.exp (2 * (n : ℝ) * Real.log r) = r ^ (2 * n) := by
+    rw [show 2 * (n : ℝ) = ((2 * n : ℕ) : ℝ) by push_cast; ring,
+      Real.exp_nat_mul, Real.exp_log hr]
+  have heN : Real.exp (((n + 1 : ℕ) : ℝ) * Real.log r) = r ^ (n + 1) := by
+    rw [Real.exp_nat_mul, Real.exp_log hr]
+  have hident := h.2.2
+  rw [homogeneousEulerDeriv_physical_tail U (Real.log R₀) hUt (n+1) (Real.log r) hlogr,
+    heN,Real.exp_log hr] at hident
+  apply homogeneousLogRow_energy_comparison (U r) (W r)
+    (iteratedDeriv (n + 1) U r) (T (Real.log r)) (R (Real.log r))
+    r c K M n hr hc hK hM
+  · simpa only [he2, Real.exp_log hr] using h.1 (r • W r)
+  · exact hident
+  · exact h.2.1
+  · exact hbound r hr₁.le
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTailWeightedL2.lean

@@ -0,0 +1,61 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTailPowerBounds
+import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
+
+namespace OAI
+
+/-! A strict physical power bound gives finite weighted top energy on a tail. -/
+
+open Set Filter Topology MeasureTheory
+open scoped ContDiff
+namespace DefocusingNLS
+local notation "V" => ℂ × ℂ
+
+theorem spectral_tail_top_integrable (U : ℝ → V) (N : ℕ) (R s : ℝ)
+    (hU : ContDiffOn ℝ ∞ U (Ioi R)) (hs : 11+2*s < -1)
+    (hb : ∃ C : ℝ, 0≤C ∧ ∀ᶠ r in atTop, ‖iteratedDeriv N U r‖≤C*r^s) :
+    ∃ T : ℝ, R<T ∧ 1<T ∧
+      IntegrableOn (fun r => r^11*‖iteratedDeriv N U r‖^2) (Ioi T) := by
+  obtain ⟨C,hC,hb⟩ := hb
+  obtain ⟨B,hB⟩ := eventually_atTop.mp hb
+  let T := max R (max B 1)+1
+  have hRT : R<T := by dsimp only [T]; linarith [le_max_left R (max B 1)]
+  have hBT : B<T := by dsimp only [T]; linarith [(le_max_left B 1).trans (le_max_right R (max B 1))]
+  have hT : 1<T := by dsimp only [T]; linarith [(le_max_right B 1).trans (le_max_right R (max B 1))]
+  have hT₀ : 0<T := lt_trans zero_lt_one hT
+  have hc := (homogeneousPair_iteratedDeriv_smooth_tail U R hU N).continuousOn
+  have hcT : ContinuousOn (fun r : ℝ => r^11*‖iteratedDeriv N U r‖^2) (Ioi T) :=
+    (continuousOn_id.pow 11).mul
+      (((hc.mono (Ioi_subset_Ioi hRT.le)).norm).pow 2)
+  refine ⟨T,hRT,hT,?_⟩
+  have hi := (integrableOn_Ioi_rpow_of_lt hs hT₀).const_mul (C^2)
+  apply hi.mono' (hcT.aestronglyMeasurable measurableSet_Ioi)
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  have hr₀ : 0<r := hT₀.trans hr
+  have hp : r^(11+2*s)=r^11*(r^s)^2 := by
+    rw [Real.rpow_add hr₀,show (2 : ℝ)*s=s*2 by ring,Real.rpow_mul hr₀.le]
+    norm_num
+  have hsq := pow_le_pow_left₀ (norm_nonneg (iteratedDeriv N U r))
+    (hB r (hBT.le.trans hr.le)) 2
+  rw [Real.norm_eq_abs,abs_of_nonneg (by positivity),hp]
+  calc
+    _ ≤ r^11*(C*r^s)^2 := mul_le_mul_of_nonneg_left hsq (by positivity)
+    _ = _ := by ring
+
+theorem spectralPowerValues_top_integrable (νp νm : ℂ) (hsame : νp.re=νm.re)
+    (f g : ℝ → ℂ) (σ : ℝ) (hf : HasLogJetBound σ f) (hg : HasLogJetBound σ g)
+    (N : ℕ) (hs : 11+2*(νp.re+σ-(N : ℝ)) < -1) :
+    ∃ T : ℝ, 1<T ∧
+      IntegrableOn (fun r => r^11*‖iteratedDeriv N (spectralPowerValues νp νm f g) r‖^2)
+        (Ioi T) := by
+  obtain ⟨Lf,hfs⟩ := hf.smooth
+  obtain ⟨Lg,hgs⟩ := hg.smooth
+  have hU := spectralPowerValues_smooth νp νm f g (max Lf Lg)
+    (hfs.mono (Ioi_subset_Ioi (le_max_left _ _)))
+    (hgs.mono (Ioi_subset_Ioi (le_max_right _ _)))
+  obtain ⟨T,_,hT,hi⟩ := spectral_tail_top_integrable _ N _ _ hU hs
+    (spectralPowerValues_derivative_bound νp νm hsame f g σ hf hg N)
+  exact ⟨T,hT,hi⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTerminalResidualBound.lean

@@ -0,0 +1,77 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarTerminalDuhamel
+
+namespace OAI
+
+/-! A terminal comparison error is controlled by the integral of the scaled
+residual and a bound for the true Cauchy data. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+theorem spectralScalar_terminal_residual_bound
+    (R E kr A B : ℝ) (hRE : R ≤ E) (hkr : 0 ≤ kr) (_hA : 0 ≤ A) (hB : 0 ≤ B)
+    (D U q : ℝ → ℂ × ℂ) (W : ℂ) (e : ℝ → ℂ) (k : ℝ → ℝ)
+    (hD : ContinuousOn D (Icc R E)) (hU : ContinuousOn U (Icc R E))
+    (hq : ContinuousOn q (Icc R E)) (he : ContinuousOn e (Icc R E))
+    (hk : ContinuousOn k (Icc R E)) (hk0 : ∀ t ∈ Icc R E, 0 < k t)
+    (hkernel : ∀ t ∈ Icc R E,
+      spectralShellNorm kr (spectralScalarTransferKernel D U W R t) ≤ A/k t)
+    (hqbound : ∀ t ∈ Icc R E, spectralShellNorm (k t) (q t) ≤ B) :
+    spectralShellNorm kr
+      (∫ t in R..E, (e t*(q t).1) • spectralScalarTransferKernel D U W R t) ≤
+      A*B*(∫ t in R..E, ‖e t‖/(k t)^2) := by
+  have hK : ContinuousOn (fun t => spectralScalarTransferKernel D U W R t) (Icc R E) :=
+    ((hD.fst.div_const W).smul continuousOn_const).sub
+      ((hU.fst.div_const W).smul continuousOn_const)
+  have hg : ContinuousOn (fun t => A*B*(‖e t‖/(k t)^2)) (Icc R E) :=
+    continuousOn_const.mul (he.norm.div (hk.pow 2) (fun t ht => pow_ne_zero _ (hk0 t ht).ne'))
+  have hval (t : ℝ) (ht : t ∈ Icc R E) : ‖(q t).1‖ ≤ B/k t :=
+    (spectralShellNorm_value (k t) (hk0 t ht) (q t)).trans
+      (div_le_div_of_nonneg_right (hqbound t ht) (hk0 t ht).le)
+  have hb := spectralShellNorm_integral_bound R E kr hRE hkr
+    (fun t => (e t*(q t).1) • spectralScalarTransferKernel D U W R t)
+    (fun t => A*B*(‖e t‖/(k t)^2)) ((he.mul hq.fst).smul hK) hg (by
+      intro t ht
+      have hkt := hk0 t ht
+      rw [spectralShellNorm_smul,norm_mul]
+      calc
+        _ = ‖e t‖*(‖(q t).1‖*spectralShellNorm kr (spectralScalarTransferKernel D U W R t)) := by ring
+        _ ≤ ‖e t‖*((B/k t)*(A/k t)) := mul_le_mul_of_nonneg_left
+          (mul_le_mul (hval t ht) (hkernel t ht)
+            (spectralShellNorm_nonneg kr hkr _) (by positivity)) (norm_nonneg _)
+        _ = A*B*(‖e t‖/(k t)^2) := by ring)
+  rw [intervalIntegral.integral_const_mul] at hb
+  exact hb
+
+theorem spectralScalar_terminal_comparison_error
+    (R E A B : ℝ) (hRE : R ≤ E) (hA : 0 ≤ A) (hB : 0 ≤ B)
+    (D U q : ℝ → ℂ × ℂ) (V e : ℝ → ℂ) (W : ℂ) (k : ℝ → ℝ)
+    (hDc : ContinuousOn D (Icc R E)) (hUc : ContinuousOn U (Icc R E))
+    (hqc : ContinuousOn q (Icc R E)) (hec : ContinuousOn e (Icc R E))
+    (hkc : ContinuousOn k (Icc R E)) (hk : ∀ t ∈ Icc R E, 0 < k t)
+    (hW : W ≠ 0) (hdet : ∀ t ∈ Icc R E, spectralScalarWronskian (D t) (U t) = W)
+    (hD : ∀ t ∈ Ioo R E, HasDerivAt D (spectralScalarField (V t) (D t)) t)
+    (hU : ∀ t ∈ Ioo R E, HasDerivAt U (spectralScalarField (V t) (U t)) t)
+    (hq : ∀ t ∈ Ioo R E, HasDerivAt q
+      (spectralScalarField (V t) (q t)+(0,e t*(q t).1)) t)
+    (hkernel : ∀ t ∈ Icc R E,
+      spectralShellNorm (k R) (spectralScalarTransferKernel D U W R t) ≤ A/k t)
+    (hqbound : ∀ t ∈ Icc R E, spectralShellNorm (k t) (q t) ≤ B) :
+    spectralShellNorm (k R)
+      (q R - ((spectralScalarWronskian (q E) (U E)/W) • D R +
+        (spectralScalarWronskian (D E) (q E)/W) • U R)) ≤
+      A*B*(∫ t in R..E, ‖e t‖/(k t)^2) := by
+  have hrep := spectralScalar_terminal_representation R E D U q V
+    (fun t => e t*(q t).1) W hDc hUc hqc (hec.mul hqc.fst) hW hdet hD hU hq R ⟨le_rfl,hRE⟩
+  have herr : q R - ((spectralScalarWronskian (q E) (U E)/W) • D R +
+      (spectralScalarWronskian (D E) (q E)/W) • U R) =
+      -(∫ t in R..E, (e t*(q t).1) • spectralScalarTransferKernel D U W R t) := by
+    rw [hrep]
+    abel
+  rw [herr,spectralShellNorm_neg]
+  exact spectralScalar_terminal_residual_bound R E (k R) A B hRE
+    (hk R ⟨le_rfl,hRE⟩).le hA hB D U q W e k hDc hUc hqc hec hkc hk hkernel hqbound
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTestPrimitive.lean

@@ -0,0 +1,53 @@
+import Mathlib.Analysis.Distribution.AEEqOfIntegralContDiff
+import Mathlib.Analysis.Calculus.ContDiff.Deriv
+import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
+
+namespace OAI
+
+/-! Compactly supported primitives for the radial weak-flux equation. -/
+
+open Set MeasureTheory
+open scoped ContDiff
+namespace DefocusingNLS
+
+theorem spectralTestPrimitive (a b : ℝ) (ψ : ℝ → ℝ)
+    (hψ : ContDiff ℝ ∞ ψ) (hs : Function.support ψ ⊆ Ioo a b)
+    (hz : ∫ x, ψ x = 0) :
+    ∃ Φ : ℝ → ℝ, ContDiff ℝ ∞ Φ ∧ HasCompactSupport Φ ∧
+      tsupport Φ ⊆ Icc a b ∧ ∀ x, deriv Φ x = ψ x := by
+  let Φ := fun t => ∫ x in a..t, ψ x
+  have hd (t : ℝ) : HasDerivAt Φ (ψ t) t :=
+    intervalIntegral.integral_hasDerivAt_right (hψ.continuous.intervalIntegrable a t)
+      hψ.continuous.aestronglyMeasurable.stronglyMeasurableAtFilter hψ.continuous.continuousAt
+  have he : deriv Φ=ψ := funext (fun t => (hd t).deriv)
+  have hc : ContDiff ℝ ∞ Φ := contDiff_infty_iff_deriv.mpr
+    ⟨fun t => (hd t).differentiableAt,by simpa only [he] using hψ⟩
+  have hzero (t : ℝ) (ht : t ∉ Icc a b) : Φ t=0 := by
+    rcases not_and_or.mp ht with ht | ht
+    · have hta : t < a := lt_of_not_ge ht
+      change (∫ x in a..t, ψ x)=0
+      rw [intervalIntegral.integral_symm]
+      have hi : (∫ x in t..a, ψ x)=0 := by
+        calc
+          (∫ x in t..a, ψ x) = ∫ _ in t..a, (0 : ℝ) := by
+            apply intervalIntegral.integral_congr_Ioo_of_le hta.le
+            intro x hx
+            apply Function.notMem_support.mp
+            intro hxs
+            exact (not_lt_of_ge (hs hxs).1.le) hx.2
+          _ = 0 := intervalIntegral.integral_zero
+      rw [hi,neg_zero]
+    · have hbt : b < t := lt_of_not_ge ht
+      change (∫ x in a..t, ψ x)=0
+      rw [intervalIntegral.integral_eq_integral_of_support_subset
+        (fun x hx => ⟨(hs hx).1,(hs hx).2.le.trans hbt.le⟩),hz]
+  have hsup : Function.support Φ ⊆ Icc a b := by
+    intro t ht
+    by_contra h
+    exact ht (hzero t h)
+  exact ⟨Φ,hc,HasCompactSupport.of_support_subset_isCompact isCompact_Icc hsup,
+    closure_minimal hsup isClosed_Icc,fun t => (hd t).deriv⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralThreeRegionBounds.lean

@@ -0,0 +1,54 @@
+import Mathlib.Analysis.SpecialFunctions.ExpDeriv
+import Mathlib.Topology.Order.Basic
+
+namespace OAI
+
+/-! Join estimates from the forbidden, central, and oscillatory regions
+without comparing the actions of distinct scalar channels. -/
+
+open Set
+namespace DefocusingNLS
+
+noncomputable def spectralTruncatedAction (a : ℝ) (H : ℝ → ℝ) (r : ℝ) : ℝ :=
+  if r ≤ a then H r else 0
+
+theorem spectralTruncatedAction_antitone (R a E : ℝ) (hRa : R ≤ a) (_haE : a ≤ E)
+    (H : ℝ → ℝ) (hH : AntitoneOn H (Icc R a)) (ha : H a = 0) :
+    AntitoneOn (spectralTruncatedAction a H) (Icc R E) := by
+  intro r hr s hs hrs
+  by_cases hsa : s ≤ a
+  · have hra := hrs.trans hsa
+    simp only [spectralTruncatedAction,ite_eq_left hsa,ite_eq_left hra]
+    exact hH ⟨hr.1,hra⟩ ⟨hs.1,hsa⟩ hrs
+  · by_cases hra : r ≤ a
+    · simp only [spectralTruncatedAction,ite_eq_right hsa,ite_eq_left hra]
+      exact ha ▸ hH ⟨hr.1,hra⟩ ⟨hRa,le_rfl⟩ hra
+    · simp only [spectralTruncatedAction,ite_eq_right hsa,ite_eq_right hra,le_refl]
+
+theorem spectralThreeRegion_bound (R a b E A C D B : ℝ)
+    (_hRa : R ≤ a) (hab : a ≤ b) (_hbE : b ≤ E)
+    (_hA : 0 ≤ A) (hC : 0 ≤ C) (hD : 1 ≤ D) (hB : 0 ≤ B)
+    (N H : ℝ → ℝ) (_ha : H a = 0)
+    (hleft : ∀ r ∈ Icc R a, N r ≤ A*Real.exp (H r)*B)
+    (hcentral : ∀ r ∈ Icc a b, N r ≤ C*B)
+    (hright : ∀ r ∈ Icc b E, N r ≤ D*N b) :
+    ∀ r ∈ Icc R E,
+      N r ≤ max A (C*D)*Real.exp (spectralTruncatedAction a H r)*B := by
+  intro r hr
+  by_cases hra : r ≤ a
+  · simp only [spectralTruncatedAction,ite_eq_left hra]
+    exact (hleft r ⟨hr.1,hra⟩).trans (by gcongr; exact le_max_left _ _)
+  · simp only [spectralTruncatedAction,ite_eq_right hra,Real.exp_zero,mul_one]
+    by_cases hrb : r ≤ b
+    · have hCD : C ≤ C*D := by nlinarith
+      exact (hcentral r ⟨le_of_not_ge hra,hrb⟩).trans
+        (mul_le_mul_of_nonneg_right (hCD.trans (le_max_right _ _)) hB)
+    · calc
+        N r ≤ D*N b := hright r ⟨le_of_not_ge hrb,hr.2⟩
+        _ ≤ D*(C*B) := mul_le_mul_of_nonneg_left (hcentral b ⟨hab,le_rfl⟩) (by linarith)
+        _ = (C*D)*B := by ring
+        _ ≤ max A (C*D)*B := mul_le_mul_of_nonneg_right (le_max_right _ _) hB
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralThreeRegionGreen.lean

@@ -0,0 +1,109 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralThreeRegionTransfer
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralDirichletGreenScaled
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralOutgoingExtensionBound
+
+namespace OAI
+
+/-! Extend the Dirichlet/outgoing construction across a turning interval and
+the oscillatory region. No exponential comparison between channels is needed. -/
+
+open Set
+namespace DefocusingNLS
+
+theorem spectralScalar_three_region_green_and_extension (R a b E A C D c : ℝ)
+    (hRa : R ≤ a) (hab : a ≤ b) (hbE : b ≤ E)
+    (hA : 0 ≤ A) (hC : 0 ≤ C) (hD : 1 ≤ D) (hc : 0 < c)
+    (V : ℝ → ℂ) (k H : ℝ → ℝ)
+    (hV : ContinuousOn V (Icc R E)) (hk : ∀ r ∈ Icc R E, 0 < k r)
+    (hH : AntitoneOn H (Icc R a)) (ha : H a = 0)
+    (U : ℝ → ℂ × ℂ) (hUc : ContinuousOn U (Icc R E))
+    (hUD : ∀ r ∈ Ioo R E, HasDerivAt U (spectralScalarField (V r) (U r)) r)
+    (hN : 0 < spectralShellNorm (k a) (U a))
+    (hvalue : c*Real.exp (H R)*spectralShellNorm (k a) (U a) ≤ k R*‖(U R).1‖)
+    (hleft : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc R a,
+        spectralShellNorm (k r) (q r) ≤ A*Real.exp (H R-H r)*spectralShellNorm (k R) (q R) ∧
+        spectralShellNorm (k r) (q r) ≤ A*Real.exp (H r)*spectralShellNorm (k a) (q a))
+    (hcentral : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc a b, spectralShellNorm (k r) (q r) ≤ C*spectralShellNorm (k a) (q a))
+    (hright : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc b E, spectralShellNorm (k r) (q r) ≤ D*spectralShellNorm (k b) (q b)) :
+    ∃ (Y : ℝ → ℂ × ℂ) (W : ℂ), Continuous Y ∧ Y R = (0,(k R : ℂ)) ∧
+      (∀ r ∈ Icc R E, HasDerivAt Y (spectralScalarField (V r) (Y r)) r) ∧
+      W ≠ 0 ∧ (∀ r ∈ Icc R E, spectralScalarWronskian (Y r) (U r) = W) ∧
+      (∀ r ∈ Icc R E, ∀ t ∈ Icc R E,
+        spectralShellNorm (k r) (spectralScalarGreenState Y U W r t) ≤
+          max A (C*A*D)*max A (C*D)/(c*k t)) ∧
+      ∀ z : ℂ, ∀ r ∈ Icc R E,
+        spectralShellNorm (k r) ((z/(U R).1) • U r) ≤ (max A (C*D)/c)*k R*‖z‖ := by
+  let N := spectralShellNorm (k a) (U a)
+  let G := spectralTruncatedAction a H
+  have hRE : R ≤ E := hRa.trans (hab.trans hbE)
+  have hGR : G R = H R := by simp only [G,spectralTruncatedAction,ite_eq_left hRa]
+  have hUb : ∀ r ∈ Icc R E, spectralShellNorm (k r) (U r) ≤ max A (C*D)*N*Real.exp (G r) := by
+    intro r hr
+    have hh := spectralThreeRegion_bound R a b E A C D N hRa hab hbE hA hC hD hN.le
+      (fun t => spectralShellNorm (k t) (U t)) H ha
+      (fun t ht => (hleft U hUc hUD t ht).2) (hcentral U hUc hUD) (hright U hUc hUD) r hr
+    convert hh using 1
+    ring
+  obtain ⟨Y,W,hYc,hYR,hYD,hW,hdet,hYb,hWb,hgreen⟩ :=
+    spectralScalar_dirichlet_green_scaled_data R E (max A (C*A*D)) (max A (C*D)) c N
+      hRE (hA.trans (le_max_left _ _)) (hA.trans (le_max_left _ _)) hc hN V k G hV hk
+      (spectralTruncatedAction_antitone R a E hRa (hab.trans hbE) H hH ha) U hUc hUD hUb
+      (by rw [hGR]; simpa only [N,mul_assoc,mul_left_comm,mul_comm] using hvalue)
+      (by
+        intro q hq hqD r hr
+        rw [hGR]
+        exact spectralThreeRegion_forward R a b E A C D hRa hab hbE hA hC hD
+          (fun t => spectralShellNorm (k t) (q t)) H
+          (spectralShellNorm_nonneg _ (hk R ⟨le_rfl,hRE⟩).le _) ha
+          (fun t ht => (hleft q hq hqD t ht).1) (hcentral q hq hqD) (hright q hq hqD) r hr)
+  refine ⟨Y,W,hYc,hYR,hYD,hW,hdet,hgreen,?_⟩
+  intro z r hr
+  apply spectralOutgoing_extension_bound (k r) (k R) (max A (C*D)) c N (G r) (G R)
+    (U r) (U R) z (hA.trans (le_max_left _ _)) hc hN
+  · exact spectralTruncatedAction_antitone R a E hRa (hab.trans hbE) H hH ha
+      ⟨le_rfl,hRE⟩ hr hr.1
+  · exact hUb r hr
+  · rw [hGR]
+    simpa only [N,mul_assoc,mul_left_comm,mul_comm] using hvalue
+
+theorem spectralScalar_three_region_green (R a b E A C D c : ℝ)
+    (hRa : R ≤ a) (hab : a ≤ b) (hbE : b ≤ E)
+    (hA : 0 ≤ A) (hC : 0 ≤ C) (hD : 1 ≤ D) (hc : 0 < c)
+    (V : ℝ → ℂ) (k H : ℝ → ℝ)
+    (hV : ContinuousOn V (Icc R E)) (hk : ∀ r ∈ Icc R E, 0 < k r)
+    (hH : AntitoneOn H (Icc R a)) (ha : H a = 0)
+    (U : ℝ → ℂ × ℂ) (hUc : ContinuousOn U (Icc R E))
+    (hUD : ∀ r ∈ Ioo R E, HasDerivAt U (spectralScalarField (V r) (U r)) r)
+    (hN : 0 < spectralShellNorm (k a) (U a))
+    (hvalue : c*Real.exp (H R)*spectralShellNorm (k a) (U a) ≤ k R*‖(U R).1‖)
+    (hleft : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc R a,
+        spectralShellNorm (k r) (q r) ≤ A*Real.exp (H R-H r)*spectralShellNorm (k R) (q R) ∧
+        spectralShellNorm (k r) (q r) ≤ A*Real.exp (H r)*spectralShellNorm (k a) (q a))
+    (hcentral : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc a b, spectralShellNorm (k r) (q r) ≤ C*spectralShellNorm (k a) (q a))
+    (hright : ∀ q : ℝ → ℂ × ℂ, ContinuousOn q (Icc R E) →
+      (∀ r ∈ Ioo R E, HasDerivAt q (spectralScalarField (V r) (q r)) r) →
+      ∀ r ∈ Icc b E, spectralShellNorm (k r) (q r) ≤ D*spectralShellNorm (k b) (q b)) :
+    ∃ (Y : ℝ → ℂ × ℂ) (W : ℂ), Continuous Y ∧ Y R = (0,(k R : ℂ)) ∧
+      (∀ r ∈ Icc R E, HasDerivAt Y (spectralScalarField (V r) (Y r)) r) ∧
+      W ≠ 0 ∧ (∀ r ∈ Icc R E, spectralScalarWronskian (Y r) (U r) = W) ∧
+      ∀ r ∈ Icc R E, ∀ t ∈ Icc R E,
+        spectralShellNorm (k r) (spectralScalarGreenState Y U W r t) ≤
+          max A (C*A*D)*max A (C*D)/(c*k t) := by
+  obtain ⟨Y,W,hYc,hYR,hYD,hW,hdet,hgreen,_⟩ :=
+    spectralScalar_three_region_green_and_extension R a b E A C D c hRa hab hbE
+      hA hC hD hc V k H hV hk hH ha U hUc hUD hN hvalue hleft hcentral hright
+  exact ⟨Y,W,hYc,hYR,hYD,hW,hdet,hgreen⟩
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralThreeRegionTransfer.lean

@@ -0,0 +1,47 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralThreeRegionBounds
+
+namespace OAI
+
+/-! Propagate an endpoint state and an outgoing state with separate constants,
+retaining the action only on the forbidden part of the interval. -/
+
+open Set
+namespace DefocusingNLS
+
+theorem spectralThreeRegion_forward (R a b E A C D : ℝ)
+    (hRa : R ≤ a) (hab : a ≤ b) (hbE : b ≤ E)
+    (hA : 0 ≤ A) (hC : 0 ≤ C) (hD : 1 ≤ D)
+    (N H : ℝ → ℝ) (hNR : 0 ≤ N R) (ha : H a = 0)
+    (hleft : ∀ r ∈ Icc R a, N r ≤ A*Real.exp (H R-H r)*N R)
+    (hcentral : ∀ r ∈ Icc a b, N r ≤ C*N a)
+    (hright : ∀ r ∈ Icc b E, N r ≤ D*N b) :
+    ∀ r ∈ Icc R E, N r ≤ max A (C*A*D)*
+      Real.exp (H R-spectralTruncatedAction a H r)*N R := by
+  have haN : N a ≤ A*(Real.exp (H R)*N R) := by
+    simpa only [ha,sub_zero,mul_assoc] using hleft a ⟨hRa,le_rfl⟩
+  have hcN (r : ℝ) (hr : r ∈ Icc a b) : N r ≤ (C*A)*(Real.exp (H R)*N R) := by
+    calc
+      N r ≤ C*N a := hcentral r hr
+      _ ≤ C*(A*(Real.exp (H R)*N R)) := mul_le_mul_of_nonneg_left haN hC
+      _ = _ := by ring
+  have hh := spectralThreeRegion_bound R a b E A (C*A) D (Real.exp (H R)*N R)
+    hRa hab hbE hA (mul_nonneg hC hA) hD (mul_nonneg (Real.exp_pos _).le hNR)
+    N (fun r => -H r) (by simp only [ha,neg_zero])
+    (fun r hr => by
+      convert hleft r hr using 1
+      rw [Real.exp_sub,Real.exp_neg]
+      field_simp
+      ) hcN hright
+  intro r hr
+  have he : spectralTruncatedAction a (fun s => -H s) r = -spectralTruncatedAction a H r := by
+    unfold spectralTruncatedAction
+    split_ifs <;> simp only [neg_zero]
+  have hb := hh r hr
+  rw [he] at hb
+  convert hb using 1
+  rw [Real.exp_sub,Real.exp_neg]
+  field_simp
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningActionGrowth.lean

@@ -0,0 +1,77 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningForbiddenGeometry
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralWKBFluxMargin
+
+namespace OAI
+
+/-! The forbidden action tends to infinity with the turning radius, already
+on the segment between the fixed shell and half the turning radius. -/
+
+open Set MeasureTheory
+namespace DefocusingNLS
+
+theorem spectralTurning_far_momentum_re_lower (h b eta omega gamma r₀ r : ℝ)
+    (heta : 0 ≤ eta) (hr₀ : 0 < r₀) (hr : 0 < r) (hrr : r ≤ r₀/2)
+    (hz : homogeneousSpectralLocalizationFrequency h b eta omega r₀ = 0) :
+    r₀/16 ≤ (spectralLiouvilleMomentum (-1) h b eta omega gamma r).re := by
+  let F := homogeneousSpectralLocalizationFrequency h b eta omega r
+  let p := spectralLiouvilleMomentum (-1) h b eta omega gamma r
+  have hfar := (spectralTurning_forbidden_far h b eta omega r₀ r heta hr₀ hr hrr hz).1
+  have hFp : 0 < -F := by dsimp only [F]; nlinarith [sq_pos_of_pos hr₀]
+  have he : spectralWKBSquaredMomentum (-1) F gamma = ((-F : ℝ) : ℂ)+Complex.I*((-gamma : ℝ) : ℂ) := by
+    dsimp only [spectralWKBSquaredMomentum]
+    push_cast
+    ring
+  have hre : (2/3 : ℝ)*‖p‖ ≤ p.re := by
+    dsimp only [p,spectralLiouvilleMomentum]
+    rw [he]
+    exact spectralComplexSqrt_re_two_thirds (-F) (-gamma) hFp
+  have hsq : ‖p‖^2 = ‖spectralWKBSquaredMomentum (-1) F gamma‖ := spectralComplexSqrt_norm_sq _
+  have hnorm : -F ≤ ‖p‖^2 := (neg_le_abs F).trans (by
+    rw [hsq]
+    exact spectralWKBSquaredMomentum_norm_lower (-1) F gamma (by norm_num))
+  have hplower : r₀/8 ≤ ‖p‖ := by nlinarith [norm_nonneg p]
+  change r₀/16 ≤ p.re
+  linarith
+
+theorem spectralTurning_forbidden_action_lower (h b eta omega gamma r₀ R E : ℝ)
+    (heta : 0 ≤ eta) (hr₀ : 0 < r₀) (hR : 0 < R)
+    (hRfour : R ≤ r₀/4) (hEhalf : r₀/2 ≤ E) (hEturn : E < r₀)
+    (hz : homogeneousSpectralLocalizationFrequency h b eta omega r₀ = 0) :
+    r₀^2/64 ≤ (∫ t in R..E, spectralLiouvilleMomentum (-1) h b eta omega gamma t).re := by
+  let p := spectralLiouvilleMomentum (-1) h b eta omega gamma
+  have hRE : R ≤ E := by linarith
+  have hRh : R ≤ r₀/2 := by linarith
+  have hF (t : ℝ) (ht : t ∈ Icc R E) :
+      0 < (-1)*homogeneousSpectralLocalizationFrequency h b eta omega t := by
+    have hh := homogeneousSpectralLocalizationFrequency_strictMono h b eta omega heta
+      (hR.trans_le ht.1) hr₀ (ht.2.trans_lt hEturn)
+    rw [hz] at hh
+    linarith
+  have hpc : ContinuousOn p (Icc R E) := fun t ht =>
+    (spectralLiouvilleMomentum_hasDerivAt (-1) h b eta omega gamma t
+      (hR.trans_le ht.1) (hF t ht)).continuousAt.continuousWithinAt
+  have hrc : ContinuousOn (fun t => (p t).re) (Icc R E) :=
+    Complex.continuous_re.comp_continuousOn hpc
+  have hi₁ : IntervalIntegrable (fun t => (p t).re) volume R (r₀/2) :=
+    (hrc.mono (Icc_subset_Icc le_rfl hEhalf)).intervalIntegrable_of_Icc hRh
+  have hi₂ : IntervalIntegrable (fun t => (p t).re) volume (r₀/2) E :=
+    (hrc.mono (Icc_subset_Icc hRh le_rfl)).intervalIntegrable_of_Icc hEhalf
+  have hlow : (r₀/2-R)*(r₀/16) ≤ ∫ t in R..r₀/2, (p t).re := by
+    calc
+      _ = ∫ _t in R..r₀/2, r₀/16 := by
+        simp only [intervalIntegral.integral_const,smul_eq_mul]
+      _ ≤ _ := intervalIntegral.integral_mono_on hRh intervalIntegrable_const hi₁
+        (fun t ht => spectralTurning_far_momentum_re_lower h b eta omega gamma r₀ t
+          heta hr₀ (hR.trans_le ht.1) ht.2 hz)
+  have hpos : 0 ≤ ∫ t in r₀/2..E, (p t).re := intervalIntegral.integral_nonneg hEhalf
+    (fun t _ => spectralComplexSqrt_re_nonneg _)
+  have hadd := intervalIntegral.integral_add_adjacent_intervals hi₁ hi₂
+  have hreal : (∫ t in R..E, p t).re = ∫ t in R..E, (p t).re := by
+    exact (intervalIntegral.intervalIntegral_re (hpc.intervalIntegrable_of_Icc hRE)).symm
+  change r₀^2/64 ≤ (∫ t in R..E, p t).re
+  rw [hreal]
+  nlinarith
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningActionLimit.lean

@@ -0,0 +1,49 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningActionGrowth
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningScaleLimit
+
+namespace OAI
+
+/-! The forbidden action diverges along every escaping turning radius,
+for any fixed inner radius and fixed Airy observation point. -/
+
+open Set Filter Topology MeasureTheory
+namespace DefocusingNLS
+
+theorem spectralTurning_forbidden_action_tendsto
+    (h : ℝ) (b eta omega gamma r₀ d : ℕ → ℝ) (R M : ℝ) (hR : 0 < R) (hM : 0 < M)
+    (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ eta n ∧
+      homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) (r₀ n) = 0 ∧
+      spectralLiouvilleSlope (eta n) (r₀ n)*(d n)^3 = 1) :
+    Tendsto (fun n => (∫ t in R..(r₀ n-M*d n),
+      spectralLiouvilleMomentum (-1) h (b n) (eta n) (omega n) (gamma n) t).re)
+      atTop atTop := by
+  have hd := spectralTurningScale_tendsto eta r₀ d hr₀
+    (hdata.mono (fun n hn => ⟨hn.1,hn.2.1,hn.2.2.1,hn.2.2.2.2⟩))
+  have hlarge : ∀ᶠ n in atTop, (r₀ n)^2/64 ≤
+      (∫ t in R..(r₀ n-M*d n),
+        spectralLiouvilleMomentum (-1) h (b n) (eta n) (omega n) (gamma n) t).re := by
+    filter_upwards [hdata,hd.eventually (gt_mem_nhds (by norm_num : (0 : ℝ) < 1)),
+      hr₀.eventually (eventually_ge_atTop (max (4*R) (2*M)))] with n hn hdn hrn
+    have hdp : 0 < d n := by
+      apply lt_of_le_of_ne hn.2.1
+      intro he
+      have hsc := hn.2.2.2.2
+      rw [← he] at hsc
+      norm_num at hsc
+    exact spectralTurning_forbidden_action_lower h (b n) (eta n) (omega n) (gamma n)
+      (r₀ n) R (r₀ n-M*d n) hn.2.2.1 hn.1 hR
+      (by linarith [le_trans (le_max_left (4*R) (2*M)) hrn])
+      (by nlinarith [le_trans (le_max_right (4*R) (2*M)) hrn])
+      (by nlinarith) hn.2.2.2.1
+  have hsq := (tendsto_pow_atTop (by decide : (2 : ℕ) ≠ 0)).comp hr₀
+  have hbound : Tendsto (fun n => (r₀ n)^2/64) atTop atTop :=
+    Filter.Tendsto.atTop_div_const (by norm_num) hsq
+  rw [tendsto_atTop]
+  intro A
+  filter_upwards [hlarge,hbound.eventually (eventually_ge_atTop A)] with n hn hAn
+  exact hAn.trans hn
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningAiryCoefficient.lean

@@ -0,0 +1,34 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningUniformLimit
+
+namespace OAI
+
+/-! The reflected coefficient converges to the Airy coefficient on every
+fixed compact interval, with no symmetry restriction on its endpoints. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralTurningAiryCoefficient_uniform_limit
+    (h : ℝ) (b eta omega gamma r₀ d : ℕ → ℝ) (a c G : ℝ)
+    (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ eta n ∧ |gamma n| ≤ G ∧
+      homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) (r₀ n) = 0 ∧
+      (r₀ n/8 + 2*(eta n+99/4)/(r₀ n)^3)*(d n)^3 = 1) :
+    TendstoUniformlyOn
+      (fun n t => spectralTurningCoefficient h (b n) (eta n) (omega n)
+        (gamma n) (r₀ n) (d n) (-t))
+      (fun t => -(t : ℂ)) atTop (Icc a c) := by
+  let M := max |a| |c|
+  have hM : 0 ≤ M := (abs_nonneg a).trans (le_max_left _ _)
+  have ha : -M ≤ a := (neg_le_neg (le_max_left |a| |c|)).trans (neg_abs_le a)
+  have hc : c ≤ M := (le_abs_self c).trans (le_max_right _ _)
+  have hu := spectralTurningCoefficient_uniform_limit h b eta omega gamma r₀ d M G hM hr₀ hdata
+  rw [Metric.tendstoUniformlyOn_iff]
+  intro eps heps
+  filter_upwards [(Metric.tendstoUniformlyOn_iff.mp hu) eps heps] with n hn t ht
+  have hm : -t ∈ Icc (-M) M := by constructor <;> linarith [ht.1,ht.2]
+  simpa only [Complex.ofReal_neg] using hn (-t) hm
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningAiryHalfLineLimit.lean

@@ -0,0 +1,45 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningAiryLimit
+
+namespace OAI
+
+/-! One limiting Airy solution works on every fixed compact interval. Local
+uniqueness makes the independently obtained interval limits agree. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralTurningAiry_halfLine_limit
+    (h : ℝ) (b eta omega gamma r₀ d : ℕ → ℝ) (a R G : ℝ)
+    (q : ℕ → ℝ → ℂ × ℂ) (x : ℂ × ℂ)
+    (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ eta n ∧ |gamma n| ≤ G ∧
+      homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) (r₀ n) = 0 ∧
+      (r₀ n/8 + 2*(eta n+99/4)/(r₀ n)^3)*(d n)^3 = 1)
+    (hq : ∀ᶠ n in atTop, Continuous (q n) ∧ ∀ r ∈ Icc R (2*r₀ n),
+      HasDerivAt (q n) (spectralScalarField
+        ((homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) r : ℂ) +
+          Complex.I*(gamma n : ℂ)) (q n r)) r)
+    (hinit : Tendsto (fun n =>
+      spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n) a) atTop (𝓝 x)) :
+    ∃ p : ℝ → ℂ × ℂ, Continuous p ∧ p a = x ∧
+      (∀ t, a ≤ t → HasDerivAt p (spectralScalarField (-(t : ℂ)) (p t)) t) ∧
+      ∀ c : ℝ, TendstoUniformlyOn
+        (fun n => spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n))
+        p atTop (Icc a c) := by
+  obtain ⟨p,hp,hpa,hpD,_⟩ := spectralTurningAiry_cauchy_limit h b eta omega gamma r₀ d
+    a a R G q x hr₀ hdata hq hinit
+  refine ⟨p,hp,hpa,hpD,?_⟩
+  intro c
+  obtain ⟨u,hu,hua,huD,hlim⟩ := spectralTurningAiry_cauchy_limit h b eta omega gamma r₀ d
+    a c R G q x hr₀ hdata hq hinit
+  apply hlim.congr_right
+  intro t ht
+  apply spectralScalar_unique_right a t ht.1 (fun s => -(s : ℂ)) (by fun_prop)
+    u p hu.continuousOn hp.continuousOn
+  · exact fun s hs => huD s hs.1.le
+  · exact fun s hs => hpD s hs.1.le
+  · exact hua.trans hpa.symm
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningAiryLimit.lean

@@ -0,0 +1,80 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningAiryCoefficient
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningAiryState
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarHalfLineExistence
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralScalarUniformDependence
+
+namespace OAI
+
+/-! Actual rescaled scalar solutions converge to one Airy solution whenever
+their Cauchy data at the left endpoint converge. The equation is inherited
+from the original radial equation, rather than assumed for the limit. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralTurningAiry_cauchy_limit
+    (h : ℝ) (b eta omega gamma r₀ d : ℕ → ℝ) (a c R G : ℝ)
+    (q : ℕ → ℝ → ℂ × ℂ) (x : ℂ × ℂ)
+    (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ eta n ∧ |gamma n| ≤ G ∧
+      homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) (r₀ n) = 0 ∧
+      (r₀ n/8 + 2*(eta n+99/4)/(r₀ n)^3)*(d n)^3 = 1)
+    (hq : ∀ᶠ n in atTop, Continuous (q n) ∧ ∀ r ∈ Icc R (2*r₀ n),
+      HasDerivAt (q n) (spectralScalarField
+        ((homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) r : ℂ) +
+          Complex.I*(gamma n : ℂ)) (q n r)) r)
+    (hinit : Tendsto (fun n =>
+      spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n) a) atTop (𝓝 x)) :
+    ∃ p : ℝ → ℂ × ℂ, Continuous p ∧ p a = x ∧
+      (∀ t, a ≤ t → HasDerivAt p (spectralScalarField (-(t : ℂ)) (p t)) t) ∧
+      TendstoUniformlyOn
+        (fun n => spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n))
+        p atTop (Icc a c) := by
+  obtain ⟨p,hp,hpa,hpD⟩ := spectralScalar_halfLine_exists a (fun t => -(t : ℂ))
+    (by fun_prop) x
+  refine ⟨p,hp,hpa,hpD,?_⟩
+  have hd := spectralTurningScale_tendsto eta r₀ d hr₀
+    (hdata.mono (fun n hn => ⟨hn.1,hn.2.1,hn.2.2.1,hn.2.2.2.2.2⟩))
+  let M := max |a| |c|
+  have hM : 0 ≤ M := (abs_nonneg a).trans (le_max_left _ _)
+  have ha : -M ≤ a := (neg_le_neg (le_max_left |a| |c|)).trans (neg_abs_le a)
+  have hc : c ≤ M := (le_abs_self c).trans (le_max_right _ _)
+  have hstate : ∀ᶠ n in atTop,
+      ContinuousOn (spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n)) (Icc a c) ∧
+      ∀ t ∈ Icc a c, HasDerivAt
+        (spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n))
+        (spectralScalarField
+          (spectralTurningCoefficient h (b n) (eta n) (omega n) (gamma n) (r₀ n) (d n) (-t))
+          (spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n) t)) t := by
+    filter_upwards [hdata,hq,hd.eventually (gt_mem_nhds (by norm_num : (0 : ℝ) < 1)),
+      hr₀.eventually (eventually_ge_atTop (max (R + M) M))] with n hn hqn hd1 hrn
+    have hdn : 0 < d n := by
+      apply lt_of_le_of_ne hn.2.1
+      intro he
+      have heq := hn.2.2.2.2.2
+      rw [← he] at heq
+      norm_num at heq
+    refine ⟨(spectralTurningAiryState_continuous _ _ _ _ hqn.1).continuousOn,?_⟩
+    intro t ht
+    have htM : |t| ≤ M := abs_le.mpr ⟨ha.trans ht.1,ht.2.trans hc⟩
+    have hprod : |d n*t| ≤ M := by
+      rw [abs_mul,abs_of_nonneg hn.2.1]
+      exact (mul_le_mul_of_nonneg_left htM hn.2.1).trans (by nlinarith)
+    have hpoint : r₀ n - d n*t ∈ Icc R (2*r₀ n) := by
+      have hleft := (le_max_left (R+M) M).trans hrn
+      have hright := (le_max_right (R+M) M).trans hrn
+      constructor <;> linarith [(abs_le.mp hprod).1,(abs_le.mp hprod).2]
+    exact spectralTurningAiryState_hasDerivAt h (b n) (eta n) (omega n) (gamma n)
+      (r₀ n) (d n) (Real.sqrt (d n)) t (Real.sqrt_pos.mpr hdn).ne'
+      (Real.sq_sqrt hn.2.1) (q n) (hqn.2 _ hpoint)
+  apply spectralScalar_uniform_dependence a c
+    (fun n t => spectralTurningCoefficient h (b n) (eta n) (omega n)
+      (gamma n) (r₀ n) (d n) (-t)) (fun t => -(t : ℂ))
+    (fun n => spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n)) p
+    (by fun_prop) hp.continuousOn (fun t ht => hpD t ht.1) hstate
+    (spectralTurningAiryCoefficient_uniform_limit h b eta omega gamma r₀ d a c G hr₀ hdata)
+  simpa only [hpa] using hinit
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningAiryNonzero.lean

@@ -0,0 +1,65 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningOutgoingFlux
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningOutgoingAiry
+
+namespace OAI
+
+/-! The actual outgoing comparison has a nonzero Airy limit. The cutoff is
+chosen from the explicit WKB error before extracting a subsequence. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralTurning_outgoing_airy_nonzero
+    (ell : ℕ → ℕ) (h : ℝ) (b omega gamma r₀ d E : ℕ → ℝ) (R : ℝ)
+    (hh : h^2 = 1) (hR : 0 < R) (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ b n ∧ b n ≤ 1 ∧
+      |gamma n| ≤ 8 ∧ 2*r₀ n ≤ E n ∧
+      (E n)^2 = 256*max ((ell n : ℝ)+1) (omega n) ∧
+      homogeneousSpectralLocalizationFrequency h (b n)
+        ((ell n : ℝ)*(ell n+10)) (omega n) (r₀ n) = 0 ∧
+      spectralLiouvilleSlope ((ell n : ℝ)*(ell n+10)) (r₀ n)*(d n)^3 = 1) :
+    ∃ (M : ℝ) (q : ℕ → ℝ → ℂ × ℂ) (φ : ℕ → ℕ) (p : ℝ → ℂ × ℂ),
+      32 ≤ M ∧ StrictMono φ ∧ Continuous p ∧
+      (∀ᶠ n in atTop, Continuous (q n) ∧
+        q n (E n) = spectralOscillatoryData h (Real.sqrt (Real.sqrt
+          (homogeneousSpectralLocalizationFrequency h (b n)
+            ((ell n : ℝ)*(ell n+10)) (omega n) (E n)))) ∧
+        spectralScalarFlux (q n (E n)) = h ∧
+        ∀ t ∈ Icc R (E n), HasDerivAt (q n) (spectralScalarField
+          ((homogeneousSpectralLocalizationFrequency h (b n)
+            ((ell n : ℝ)*(ell n+10)) (omega n) t : ℂ)+Complex.I*(gamma n : ℂ))
+          (q n t)) t) ∧
+      (∀ t, -M ≤ t → HasDerivAt p (spectralScalarField (-(t : ℂ)) (p t)) t) ∧
+      spectralTurningFluxBase/2 ≤ -h*spectralScalarFlux (p 1) ∧
+      ∀ c : ℝ, TendstoUniformlyOn
+        (fun n => spectralTurningAiryState (r₀ (φ n)) (d (φ n))
+          (Real.sqrt (d (φ n))) (q (φ n))) p atTop (Icc (-M) c) := by
+  obtain ⟨M,hM,hflux⟩ := spectralTurning_eventual_outgoing_flux ell h b omega gamma r₀ d E R
+    hh hr₀ hdata
+  obtain ⟨q,φ,p,hφ,hp,hq,hpD,hlim⟩ := spectralTurning_outgoing_airy_limit ell h b omega gamma r₀ d E M R
+    hh hM hR hr₀ hdata
+  have hqflux := hflux q (hq.mono (fun n hn => ⟨hn.1,hn.2.1,hn.2.2.2⟩))
+  have hpflux : spectralTurningFluxBase/2 ≤ -h*spectralScalarFlux (p (-M)) := by
+    apply ge_of_tendsto ((spectralScalarFlux_continuous.continuousAt.tendsto.comp
+      ((hlim (-M)).tendsto_at ⟨le_rfl,le_rfl⟩)).const_mul (-h))
+    filter_upwards [hφ.tendsto_atTop.eventually hqflux,hφ.tendsto_atTop.eventually hdata] with n hn hdn
+    have hdp : 0 < d (φ n) := by
+      apply lt_of_le_of_ne hdn.2.1
+      intro he
+      have hs := hdn.2.2.2.2.2.2.2.2
+      rw [← he] at hs
+      norm_num at hs
+    dsimp only [Function.comp_def]
+    rw [spectralTurningAiryState_flux _ _ _ _ (Real.sqrt_pos.mpr hdp).ne']
+    have he : r₀ (φ n)-d (φ n)*(-M) = r₀ (φ n)+M*d (φ n) := by ring
+    rw [he]
+    nlinarith
+  have heq := spectralScalarFlux_const (-M) 1 p (fun t => -t) hp.continuousOn
+    (fun t ht => by simpa only [Complex.ofReal_neg] using hpD t ht.1.le)
+    1 ⟨by linarith,le_rfl⟩
+  refine ⟨M,q,φ,p,hM,hφ,hp,hq,hpD,?_,hlim⟩
+  simpa only [heq] using hpflux
+
+end DefocusingNLS
+
+end OAI

lean/OAI/MathematicalPhysics/DefocusingNLS/Spectrum/SpectralTurningAiryProjection.lean

@@ -0,0 +1,46 @@
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningProjectionLimit
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralTurningAiryState
+import OAI.MathematicalPhysics.DefocusingNLS.Spectrum.SpectralAiryGrowingMargin
+
+namespace OAI
+
+/-! Nonzero limiting flux supplies a fixed growing-mode margin for the
+actual rescaled WKB projection at every sufficiently late fixed Airy point. -/
+
+open Set Filter Topology
+namespace DefocusingNLS
+
+theorem spectralTurning_eventual_growing_projection
+    (h : ℝ) (b eta omega gamma r₀ d : ℕ → ℝ) (a G : ℝ) (ha : a ≤ 1)
+    (hr₀ : Tendsto r₀ atTop atTop)
+    (hdata : ∀ᶠ n in atTop, 0 < r₀ n ∧ 0 ≤ d n ∧ 0 ≤ eta n ∧ |gamma n| ≤ G ∧
+      homogeneousSpectralLocalizationFrequency h (b n) (eta n) (omega n) (r₀ n) = 0 ∧
+      (r₀ n/8+2*(eta n+99/4)/(r₀ n)^3)*(d n)^3 = 1)
+    (q : ℕ → ℝ → ℂ × ℂ) (p : ℝ → ℂ × ℂ) (hp : Continuous p)
+    (hpD : ∀ t, a ≤ t → HasDerivAt p (spectralScalarField (-(t : ℂ)) (p t)) t)
+    (hpJ : spectralScalarFlux (p 1) ≠ 0)
+    (hlim : ∀ c : ℝ, TendstoUniformlyOn
+      (fun n => spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n)) p atTop (Icc a c)) :
+    ∀ᶠ T : ℝ in atTop, ∀ᶠ n in atTop,
+      let u := spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n) T
+      let P := (d n : ℂ)*spectralLiouvilleMomentum (-1) h (b n) (eta n)
+        (omega n) (gamma n) (r₀ n-d n*T)
+      let A := ((d n)^3*spectralLiouvilleSlope (eta n) (r₀ n-d n*T) : ℝ)
+      (1/8 : ℝ)*spectralShellNorm (Real.sqrt ‖P‖) u ≤
+        ‖(u.2+(P+(A : ℂ)/(4*P^2))*u.1)/(2*Complex.sqrt P)‖ := by
+  have hmargin := spectralAiry_eventual_growing_margin p 1 le_rfl hp.continuousOn
+    (fun t ht => hpD t (ha.trans ht)) hpJ
+  filter_upwards [hmargin,eventually_ge_atTop (1 : ℝ)] with T hTmargin hT
+  have hTp : 0 < T := by linarith
+  have hJT : spectralScalarFlux (p T) ≠ 0 := by
+    rw [spectralScalarFlux_const 1 T p (fun t => -t) hp.continuousOn
+      (fun t ht => by simpa only [Complex.ofReal_neg] using hpD t (ha.trans ht.1.le))
+      T ⟨hT,le_rfl⟩]
+    exact hpJ
+  exact spectralTurning_growing_projection_margin h b eta omega gamma r₀ d T G hTp hr₀ hdata
+    (p T) (fun n => spectralTurningAiryState (r₀ n) (d n) (Real.sqrt (d n)) (q n) T)
+    hJT ((hlim T).tendsto_at ⟨ha.trans hT,le_rfl⟩) hTmargin
+
+end DefocusingNLS
+
+end OAI