Add lean source and binary files (part 71)

lean/OAI/Geometry/NodalSets/Waves/GaussianFactorBound.lean

@@ -0,0 +1,64 @@
+import Mathlib.Analysis.Normed.Module.FiniteDimension
+import OAI.Geometry.NodalSets.Waves.GaussianFactor
+
+namespace OAI
+
+namespace Yau.Probability
+open MeasureTheory ProbabilityTheory
+open scoped RealInnerProductSpace
+noncomputable section
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+variable {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
+  [FiniteDimensional ℝ F]
+local notation "E" => EuclideanSpace ℝ ι
+
+lemma covarianceFactor_norm_sq (T : F →L[ℝ] E) (v : E) :
+    ‖covarianceFactor T v‖^2 = ‖T.adjoint v‖^2 := by
+  simpa only [real_inner_self_eq_norm_sq] using covarianceFactor_inner T v v
+
+lemma covarianceFactor_lower (T : F →L[ℝ] E) (a : ℝ) (ha : 0 < a)
+    (h : ∀ v : E, a*‖v‖^2 ≤ ‖T.adjoint v‖^2) (v : E) :
+    Real.sqrt a * ‖v‖ ≤ ‖covarianceFactor T v‖ := by
+  have hs := Real.sq_sqrt ha.le
+  have hb := h v
+  rw [← covarianceFactor_norm_sq T v] at hb
+  nlinarith [sq_nonneg (Real.sqrt a*‖v‖-‖covarianceFactor T v‖),
+    norm_nonneg (covarianceFactor T v), norm_nonneg v, Real.sqrt_nonneg a]
+
+lemma covarianceFactor_bijective (T : F →L[ℝ] E) (a : ℝ) (ha : 0 < a)
+    (h : ∀ v : E, a*‖v‖^2 ≤ ‖T.adjoint v‖^2) :
+    Function.Bijective (covarianceFactor T) := by
+  have hi : Function.Injective (covarianceFactor T) := by
+    apply (covarianceFactor T).ker_eq_bot.mp
+    rw [LinearMap.ker_eq_bot']
+    intro v hv
+    change covarianceFactor T v = 0 at hv
+    have hb := covarianceFactor_lower T a ha h v
+    rw [hv,norm_zero] at hb
+    have hz : ‖v‖ = 0 := by nlinarith [Real.sqrt_pos.mpr ha, norm_nonneg v]
+    exact norm_eq_zero.mp hz
+  exact ⟨hi, LinearMap.injective_iff_surjective.mp hi⟩
+
+variable [MeasurableSpace F] [BorelSpace F]
+
+lemma exists_gaussian_factor_equiv (T : F →L[ℝ] E) (a : ℝ) (ha : 0 < a)
+    (h : ∀ v : E, a*‖v‖^2 ≤ ‖T.adjoint v‖^2) :
+    ∃ L : E ≃L[ℝ] E,
+      (stdGaussian F).map T = (stdGaussian E).map L ∧
+      ‖L.symm.toContinuousLinearMap‖ ≤ (Real.sqrt a)⁻¹ := by
+  let L := (LinearEquiv.ofBijective (covarianceFactor T).toLinearMap
+    (covarianceFactor_bijective T a ha h)).toContinuousLinearEquiv
+  refine ⟨L, gaussian_covariance_factorization T, ?_⟩
+  apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+  intro v
+  have hb := covarianceFactor_lower T a ha h (L.symm v)
+  change Real.sqrt a*‖L.symm v‖ ≤ ‖L (L.symm v)‖ at hb
+  rw [L.apply_symm_apply] at hb
+  change ‖L.symm v‖ ≤ _
+  rw [inv_mul_eq_div]
+  exact (le_div_iff₀ (Real.sqrt_pos.mpr ha)).mpr (by simpa [mul_comm] using hb)
+
+end
+end Yau.Probability
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianFactorTwoSided.lean

@@ -0,0 +1,40 @@
+import OAI.Geometry.NodalSets.Waves.GaussianFactorBound
+
+namespace OAI
+
+namespace Yau.Probability
+open MeasureTheory ProbabilityTheory
+noncomputable section
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+variable {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
+  [FiniteDimensional ℝ F] [MeasurableSpace F] [BorelSpace F]
+local notation "E" => EuclideanSpace ℝ ι
+
+lemma exists_gaussian_factor_two_sided (T : F →L[ℝ] E) (a B : ℝ)
+    (ha : 0 < a) (hB : 0 ≤ B)
+    (hlo : ∀ v : E, a*‖v‖^2 ≤ ‖T.adjoint v‖^2)
+    (hhi : ∀ v : E, ‖T.adjoint v‖^2 ≤ B^2*‖v‖^2) :
+    ∃ L : E ≃L[ℝ] E,
+      (stdGaussian F).map T = (stdGaussian E).map L ∧
+      ‖L.symm.toContinuousLinearMap‖ ≤ (Real.sqrt a)⁻¹ ∧ ‖L.toContinuousLinearMap‖ ≤ B := by
+  let L := (LinearEquiv.ofBijective (covarianceFactor T).toLinearMap
+    (covarianceFactor_bijective T a ha hlo)).toContinuousLinearEquiv
+  refine ⟨L,gaussian_covariance_factorization T,?_,?_⟩
+  · apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+    intro v
+    have hb := covarianceFactor_lower T a ha hlo (L.symm v)
+    change Real.sqrt a*‖L.symm v‖ ≤ ‖L (L.symm v)‖ at hb
+    rw [L.apply_symm_apply] at hb
+    rw [inv_mul_eq_div]
+    exact (le_div_iff₀ (Real.sqrt_pos.mpr ha)).mpr (by simpa [mul_comm] using hb)
+  · apply ContinuousLinearMap.opNorm_le_bound _ hB
+    intro v
+    change ‖covarianceFactor T v‖ ≤ B*‖v‖
+    apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg hB (norm_nonneg _))).mp
+    rw [covarianceFactor_norm_sq,mul_pow]
+    exact hhi v
+
+end
+end Yau.Probability
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianGradientSupremum.lean

@@ -0,0 +1,99 @@
+import OAI.Geometry.NodalSets.Charts.MetricFrequencyBounds
+import OAI.Geometry.NodalSets.Waves.GaussianCompactSections
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory
+open scoped ContDiff
+noncomputable section
+variable {ι X : Type*} [Fintype ι] [TopologicalSpace X]
+
+def vectorMeanSection (M : Fin 4 → C(X,ℝ)) : C(X,EuclideanSpace ℝ (Fin 4)) :=
+  ⟨fun x ↦ WithLp.toLp 2 (fun j ↦ M j x),
+    (PiLp.continuous_toLp 2 (fun _ : Fin 4 ↦ ℝ)).comp (continuous_pi (fun j ↦ (M j).continuous))⟩
+
+def vectorCoeffSection (Z : Fin 4 → ι → C(X,ℂ)) (p : ι × Fin 2) :
+    C(X,EuclideanSpace ℝ (Fin 4)) :=
+  vectorMeanSection (fun j ↦ if p.2 = 0 then
+    ⟨fun x ↦ (Z j p.1 x).re, Complex.continuous_re.comp (Z j p.1).continuous⟩ else
+    ⟨fun x ↦ -(Z j p.1 x).im, (Complex.continuous_im.comp (Z j p.1).continuous).neg⟩)
+
+def pairVectorSection (M : Fin 4 → C(X,ℝ)) (Z : Fin 4 → ι → C(X,ℂ))
+    (a : ι × Fin 2 → ℝ) : C(X,EuclideanSpace ℝ (Fin 4)) :=
+  vectorMeanSection M + ∑ p : ι × Fin 2, a p • vectorCoeffSection Z p
+
+lemma pairVectorSection_apply (M : Fin 4 → C(X,ℝ)) (Z : Fin 4 → ι → C(X,ℂ))
+    (a : ι × Fin 2 → ℝ) (x : X) (j : Fin 4) :
+    pairVectorSection M Z a x j = M j x+pairLinearSum (fun i ↦ Z j i x) a := by
+  classical
+  simp only [pairVectorSection,ContinuousMap.add_apply,ContinuousMap.sum_apply,
+    ContinuousMap.smul_apply,PiLp.add_apply,
+    vectorMeanSection,ContinuousMap.coe_mk,pairLinearSum,vectorCoeffSection]
+  congr 1
+  simp only [WithLp.ofLp_sum,WithLp.ofLp_smul,Finset.sum_apply,Pi.smul_apply]
+  apply Finset.sum_congr rfl
+  intro p _
+  split_ifs <;> simp [smul_eq_mul,mul_comm]
+
+lemma pairVectorSection_continuous (M : Fin 4 → C(X,ℝ)) (Z : Fin 4 → ι → C(X,ℂ)) :
+    Continuous (pairVectorSection M Z) := by
+  unfold pairVectorSection
+  exact continuous_const.add (continuous_finsetSum _ (fun p _ ↦
+    (continuous_apply p).smul continuous_const))
+
+variable [CompactSpace X]
+
+lemma pairVectorSection_integrable (M : Fin 4 → C(X,ℝ)) (Z : Fin 4 → ι → C(X,ℂ)) :
+    Integrable (pairVectorSection M Z) gaussianPairs := by
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by unfold gaussianPairs; infer_instance
+  unfold pairVectorSection
+  apply (integrable_const (μ := gaussianPairs (ι := ι)) (vectorMeanSection M)).add
+  apply integrable_finsetSum
+  intro p _
+  exact (integrable_eval (μ := fun _ : ι × Fin 2 ↦ gaussianReal 0 1)
+    (i := p) IsGaussian.integrable_id).smul_const _
+
+variable (V : ι → Coord → ℂ) (seed : Coord → ℝ)
+    (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hs : ContDiff ℝ ∞ seed)
+    (K : Set Coord) [CompactSpace K]
+
+def gaussianGradientSection (a : ι × Fin 2 → ℝ) : C(K,EuclideanSpace ℝ (Fin 4)) :=
+  pairVectorSection (fun j ↦ derivativeSection seed hs K 1 (fun _ ↦ Pi.single j 1))
+    (fun j i ↦ derivativeSection (V i) (hV i) K 1 (fun _ ↦ Pi.single j 1)) a
+
+omit [CompactSpace K] in
+lemma gaussianGradientSection_apply (a : ι × Fin 2 → ℝ) (x : K) (j : Fin 4) :
+    gaussianGradientSection V seed hV hs K a x j =
+      fderiv ℝ (fun z ↦ seed z+gaussianWaveField V a z) x (Pi.single j 1) := by
+  rw [gaussianGradientSection,pairVectorSection_apply]
+  have hh := seeded_gaussian_iterated_apply V seed hV hs a 1 x (fun _ ↦ Pi.single j 1)
+  simpa only [derivativeSection,ContinuousMap.coe_mk,iteratedFDeriv_one_apply] using hh.symm
+
+def gaussianGradientSup (a : ι × Fin 2 → ℝ) : ℝ :=
+  ‖gaussianGradientSection V seed hV hs K a‖
+
+lemma gaussianGradientSup_continuous : Continuous (gaussianGradientSup V seed hV hs K) :=
+  (pairVectorSection_continuous _ _).norm
+
+lemma gaussianGradientSup_integrable : Integrable (gaussianGradientSup V seed hV hs K) gaussianPairs :=
+  (pairVectorSection_integrable _ _).norm
+
+lemma gaussianGradientSup_le_iff (a : ι × Fin 2 → ℝ) {C : ℝ} (hC : 0 ≤ C) :
+    gaussianGradientSup V seed hV hs K a ≤ C ↔
+      ∀ x ∈ K, sourceEuclideanNorm (fun j ↦
+        fderiv ℝ (fun z ↦ seed z+gaussianWaveField V a z) x (Pi.single j 1)) ≤ C := by
+  unfold gaussianGradientSup
+  rw [ContinuousMap.norm_le _ hC]
+  have he (x : K) : ‖gaussianGradientSection V seed hV hs K a x‖ =
+      sourceEuclideanNorm (fun j ↦
+        fderiv ℝ (fun z ↦ seed z+gaussianWaveField V a z) x (Pi.single j 1)) := by
+    rw [EuclideanSpace.norm_eq]
+    simp only [gaussianGradientSection_apply,Real.norm_eq_abs,sq_abs,sourceEuclideanNorm]
+  simp_rw [he]
+  exact Subtype.forall
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianIntervalBound.lean

@@ -0,0 +1,38 @@
+import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
+import Mathlib.Probability.Distributions.Gaussian.Real
+
+namespace OAI
+
+namespace Yau.Probability
+open MeasureTheory ProbabilityTheory Set
+open scoped ENNReal NNReal
+noncomputable section
+
+lemma gaussian_pdf_upper_bound (mean x : ℝ) (v : ℝ≥0) :
+    gaussianPDFReal mean v x ≤ (Real.sqrt (2*Real.pi*v))⁻¹ := by
+  unfold gaussianPDFReal
+  apply mul_le_of_le_one_right (by positivity)
+  apply Real.exp_le_one_iff.mpr
+  exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (sq_nonneg _)) (by positivity)
+
+lemma gaussian_interval_bound (mean center radius : ℝ) (hr : 0 ≤ radius)
+    (v : ℝ≥0) (hv : v ≠ 0) :
+    gaussianReal mean v (Icc (center-radius) (center+radius)) ≤
+      ENNReal.ofReal (2*radius/(Real.sqrt (2*Real.pi*v))) := by
+  rw [gaussianReal_apply mean hv]
+  calc
+    _ ≤ ∫⁻ _ in Icc (center-radius) (center+radius),
+        ENNReal.ofReal ((Real.sqrt (2*Real.pi*v))⁻¹) := by
+      apply lintegral_mono
+      intro x
+      exact ENNReal.ofReal_le_ofReal (gaussian_pdf_upper_bound mean x v)
+    _ = _ := by
+      rw [lintegral_const,Measure.restrict_apply_univ,Real.volume_Icc]
+      rw [← ENNReal.ofReal_mul' (by linarith only [hr])]
+      congr 1
+      ring
+
+end
+end Yau.Probability
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianJet.lean

@@ -0,0 +1,91 @@
+import OAI.Geometry.NodalSets.Waves.FiniteGaussianMap
+import OAI.Geometry.NodalSets.Waves.SeededGaussianJet
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory
+open scoped RealInnerProductSpace
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+
+abbrev JetSpace := EuclideanSpace ℝ (Fin 5)
+
+def normalizedRealJet (f : Coord → ℝ) (N S : ℝ) (x : Coord) : JetSpace :=
+  WithLp.toLp 2 (Fin.cons (Real.exp (-N*S)*f x)
+    (fun i : Fin 4 ↦ Real.exp (-N*S)*N⁻¹*fderiv ℝ f x (Pi.single i 1)))
+
+lemma normalizedRealJet_inner (f : Coord → ℝ) (N S : ℝ) (x : Coord) (v : JetSpace) :
+    ⟪v,normalizedRealJet f N S x⟫ =
+      Real.exp (-N*S)*(v 0*f x+N⁻¹*fderiv ℝ f x (Fin.tail (WithLp.ofLp v))) := by
+  have he : Fin.tail (WithLp.ofLp v) = ∑ i : Fin 4, (v i.succ) • Pi.single i (1:ℝ) := by
+    ext j
+    simp [Pi.single_apply,Fin.tail]
+  rw [he,map_sum]
+  simp only [map_smul,smul_eq_mul]
+  simp only [normalizedRealJet,PiLp.inner_apply,RCLike.inner_apply,conj_trivial,
+    Fin.sum_univ_succ,Fin.cons_zero,Fin.cons_succ]
+  ring
+
+def jetWaveCoefficients (V : ι → Coord → ℂ) (N S : ℝ) (x : Coord) : Fin 5 → ι → ℂ :=
+  Fin.cons (fun i ↦ dualWaveCoefficient N (V i) S x 1 0)
+    (fun j i ↦ dualWaveCoefficient N (V i) S x 0 (Pi.single j 1))
+
+lemma gaussianWaveField_normalizedJet (V : ι → Coord → ℂ) (N S : ℝ) (x : Coord)
+    (hV : ∀ i, DifferentiableAt ℝ (V i) x) (a : ι × Fin 2 → ℝ) :
+    normalizedRealJet (gaussianWaveField V a) N S x =
+      pairJetMap (jetWaveCoefficients V N S x) (WithLp.toLp 2 a) := by
+  ext k
+  rw [pairJetMap_apply]
+  refine Fin.cases ?_ (fun j ↦ ?_) k
+  · simpa [normalizedRealJet,jetWaveCoefficients] using
+      gaussianWaveField_dual V a x 0 hV N S 1
+  · simpa [normalizedRealJet,jetWaveCoefficients,mul_assoc] using
+      gaussianWaveField_dual V a x (Pi.single j 1) hV N S 0
+
+lemma normalizedRealJet_add (f g : Coord → ℝ) (N S : ℝ) (x : Coord)
+    (hf : DifferentiableAt ℝ f x) (hg : DifferentiableAt ℝ g x) :
+    normalizedRealJet (fun y ↦ f y+g y) N S x =
+      normalizedRealJet f N S x+normalizedRealJet g N S x := by
+  ext k
+  refine Fin.cases ?_ (fun j ↦ ?_) k
+  · simp [normalizedRealJet,mul_add]
+  · simp [normalizedRealJet,fderiv_fun_add hf hg,mul_add]
+
+lemma seeded_gaussian_jet_eq (V : ι → Coord → ℂ) (seed : Coord → ℝ)
+    (N S : ℝ) (x : Coord) (hV : ∀ i, DifferentiableAt ℝ (V i) x)
+    (hs : DifferentiableAt ℝ seed x) (a : ι × Fin 2 → ℝ) :
+    normalizedRealJet (fun y ↦ seed y+gaussianWaveField V a y) N S x =
+      normalizedRealJet seed N S x+
+        pairJetMap (jetWaveCoefficients V N S x) (WithLp.toLp 2 a) := by
+  rw [normalizedRealJet_add _ _ _ _ _ hs (gaussianWaveField_differentiable V a x hV),
+    gaussianWaveField_normalizedJet V N S x hV]
+
+lemma seeded_gaussian_jet_law (V : ι → Coord → ℂ) (seed : Coord → ℝ)
+    (N S : ℝ) (x : Coord) (hV : ∀ i, DifferentiableAt ℝ (V i) x)
+    (hs : DifferentiableAt ℝ seed x) :
+    (gaussianPairs (ι := ι)).map (fun a ↦
+      normalizedRealJet (fun y ↦ seed y+gaussianWaveField V a y) N S x) =
+      (stdGaussian (EuclideanSpace ℝ (ι × Fin 2))).map
+        (fun z ↦ normalizedRealJet seed N S x+pairJetMap (jetWaveCoefficients V N S x) z) := by
+  simp_rw [seeded_gaussian_jet_eq V seed N S x hV hs]
+  rw [← map_pi_eq_stdGaussian, Measure.map_map (by fun_prop) (by fun_prop)]
+  rfl
+
+lemma seeded_gaussian_jet_variance (V : ι → Coord → ℂ) (seed : Coord → ℝ)
+    (N S : ℝ) (x : Coord) (hV : ∀ i, DifferentiableAt ℝ (V i) x)
+    (hs : DifferentiableAt ℝ seed x) (v : JetSpace) :
+    Var[fun a : ι × Fin 2 → ℝ ↦
+      ⟪v,normalizedRealJet (fun y ↦ seed y+gaussianWaveField V a y) N S x⟫; gaussianPairs] =
+      ‖(pairJetMap (jetWaveCoefficients V N S x)).adjoint v‖^2 := by
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by
+    unfold gaussianPairs
+    infer_instance
+  simp_rw [seeded_gaussian_jet_eq V seed N S x hV hs,inner_add_right]
+  rw [variance_const_add (by fun_prop)]
+  exact variance_gaussianMap_inner _ v
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianPairCovariance.lean

@@ -0,0 +1,51 @@
+import Mathlib.Probability.Moments.Covariance
+import OAI.Geometry.NodalSets.Waves.GaussianPairMoments
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Probability MeasureTheory ProbabilityTheory
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+
+lemma pairLinearSum_add (z w : ι → ℂ) :
+    pairLinearSum (fun i ↦ z i+w i) = fun a ↦ pairLinearSum z a+pairLinearSum w a := by
+  classical
+  funext a
+  simp only [pairLinearSum,Complex.add_re,Complex.add_im]
+  rw [← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro p _
+  split_ifs <;> ring
+
+lemma covariance_pairLinearSum (z w : ι → ℂ) :
+    cov[pairLinearSum z,pairLinearSum w;gaussianPairs] =
+      ∑ i, ((z i).re*(w i).re+(z i).im*(w i).im) := by
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by unfold gaussianPairs; infer_instance
+  have hz := pairLinearSum_memLp_two z
+  have hw := pairLinearSum_memLp_two w
+  have hh := variance_add hz hw
+  change Var[fun a ↦ pairLinearSum z a+pairLinearSum w a;gaussianPairs] = _ at hh
+  rw [← pairLinearSum_add] at hh
+  simp only [variance_pairLinearSum] at hh
+  have hn : ∑ i, ‖z i+w i‖^2 = (∑ i, ‖z i‖^2) + (∑ i, ‖w i‖^2) +
+      2 * ∑ i, ((z i).re*(w i).re+(z i).im*(w i).im) := by
+    simp only [← Finset.sum_add_distrib,Finset.mul_sum,Complex.sq_norm,
+      Complex.normSq_apply,Complex.add_re,Complex.add_im]
+    apply Finset.sum_congr rfl
+    intro i _
+    ring
+  linarith
+
+lemma pairLinearSum_covariance_integral (z w : ι → ℂ) :
+    ∫ a, pairLinearSum z a*pairLinearSum w a ∂gaussianPairs =
+      ∑ i, ((z i).re*(w i).re+(z i).im*(w i).im) := by
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by unfold gaussianPairs; infer_instance
+  have hh := covariance_eq_sub (pairLinearSum_memLp_two z) (pairLinearSum_memLp_two w)
+  rw [pairLinearSum_mean,pairLinearSum_mean,mul_zero,sub_zero,covariance_pairLinearSum] at hh
+  exact hh.symm
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianPairMoments.lean

@@ -0,0 +1,50 @@
+import OAI.Geometry.NodalSets.Coefficients.GaussianCoefficientMSE
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+
+lemma pairLinearSum_memLp_two (z : ι → ℂ) : MemLp (pairLinearSum z) 2 gaussianPairs := by
+  classical
+  unfold pairLinearSum gaussianPairs
+  apply memLp_finsetSum
+  intro p _
+  have hh : MemLp (id : ℝ → ℝ) 2 (gaussianReal 0 1) := IsGaussian.memLp_two_id
+  exact (hh.comp_measurePreserving (measurePreserving_eval (μ := fun _ : ι × Fin 2 ↦ gaussianReal 0 1) p)).const_mul _
+
+lemma pairLinearSum_mean_square (z : ι → ℂ) (m : ℝ) :
+    ∫ coeff, (m+pairLinearSum z coeff)^2 ∂gaussianPairs = m^2+∑ i, ‖z i‖^2 := by
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by unfold gaussianPairs; infer_instance
+  have hp := pairLinearSum_memLp_two z
+  have hh := variance_eq_sub ((memLp_const m).add hp)
+  have hm : ∫ coeff, m+pairLinearSum z coeff ∂gaussianPairs = m := by
+    rw [integral_add (integrable_const _) (pairLinearSum_integrable z),pairLinearSum_mean,integral_const]
+    simp
+  change Var[fun coeff ↦ m+pairLinearSum z coeff;gaussianPairs] =
+    (∫ coeff, (m+pairLinearSum z coeff)^2 ∂gaussianPairs) -
+      (∫ coeff, m+pairLinearSum z coeff ∂gaussianPairs)^2 at hh
+  rw [hm,variance_const_add hp.aestronglyMeasurable,variance_pairLinearSum] at hh
+  linarith
+
+lemma rescaledGaussianField_mse (V W : ι → Coord → ℂ) (S0 T0 S : Coord → ℝ)
+    (N s sigma : ℝ) (x v : Coord) :
+    ∫ coeff, (rescaledGaussianField V S0 T0 S N s sigma x coeff v -
+      gaussianWaveField W coeff v)^2 ∂gaussianPairs =
+      (rescaledSeed S0 T0 S N s sigma x v)^2 +
+        ∑ i, ‖normalizedRescaling (V i) S N s sigma x v-W i v‖^2 := by
+  have heq (coeff : ι × Fin 2 → ℝ) :
+      rescaledGaussianField V S0 T0 S N s sigma x coeff v - gaussianWaveField W coeff v =
+        rescaledSeed S0 T0 S N s sigma x v +
+          pairLinearSum (fun i ↦ normalizedRescaling (V i) S N s sigma x v-W i v) coeff := by
+    rw [rescaledGaussianField_decomposition,← gaussianWaveField_sub_pair]
+    ring
+  simp_rw [heq]
+  exact pairLinearSum_mean_square _ _
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianPartialMeasurability.lean

@@ -0,0 +1,39 @@
+import OAI.Geometry.NodalSets.Elliptic.CoordinatePartialJets
+import OAI.Geometry.NodalSets.Waves.GaussianDerivativeMoments
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Analysis Yau.Probability MeasureTheory
+open scoped ContDiff
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+
+lemma seeded_partial_joint_continuous (V : ι → Coord → ℂ) (seed : Coord → ℝ)
+    (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hs : ContDiff ℝ ∞ seed)
+    (ds : List (Fin 4)) :
+    Continuous (fun z : (ι × Fin 2 → ℝ) × Coord ↦
+      partialJet (fun x ↦ seed x+gaussianWaveField V z.1 x) ds z.2) := by
+  have hF (a : ι × Fin 2 → ℝ) := hs.add (gaussianWaveField_contDiff V a hV)
+  simp_rw [partialJet_eq_iterated _ (hF _),seeded_gaussian_iterated_apply V seed hV hs]
+  have horder : (ds.length : WithTop ℕ∞) ≤ ∞ := by
+    exact_mod_cast (show (ds.length:ℕ∞) ≤ ⊤ from le_top)
+  have hc {F : Type} [NormedAddCommGroup F] [NormedSpace ℝ F]
+      (f : Coord → F) (hf : ContDiff ℝ ∞ f) :
+      Continuous (fun z : (ι × Fin 2 → ℝ) × Coord ↦
+        iteratedFDeriv ℝ ds.length f z.2 (partialDirs ds)) :=
+    ((hf.continuous_iteratedFDeriv horder).comp continuous_snd).eval continuous_const
+  apply (hc seed hs).add
+  unfold pairLinearSum
+  apply continuous_finsetSum
+  intro p _
+  apply Continuous.mul
+  · split_ifs
+    · exact Complex.continuous_re.comp (hc (V p.1) (hV p.1))
+    · exact (Complex.continuous_im.comp (hc (V p.1) (hV p.1))).neg
+  · exact (continuous_apply p).comp continuous_fst
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianTailBound.lean

@@ -0,0 +1,56 @@
+import Mathlib.Analysis.SpecialFunctions.Exp
+import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
+import Mathlib.Tactic.GCongr
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Positivity
+import Mathlib.Tactic.Ring
+
+namespace OAI
+
+namespace Yau.Probability
+open Filter
+open scoped BigOperators Topology
+noncomputable section
+
+lemma finite_gaussian_tail {ι : Type*} [Fintype ι] (d f : ι → ℝ)
+    {a R B r : ℝ} (ha : 0 ≤ a) (hR : 0 ≤ R) (hr : 0 ≤ r)
+    (hd : ∀ i, 0 ≤ d i) (hf : ∀ i, f i ≤ R*Real.exp (-2*a*(d i)^2))
+    (hs : ∑ i, Real.exp (-a*(d i)^2) ≤ B) :
+    ∑ i ∈ Finset.univ.filter (fun i ↦ r < d i), f i ≤
+      R*B*Real.exp (-a*r^2) := by
+  classical
+  calc
+    _ ≤ ∑ i ∈ Finset.univ.filter (fun i ↦ r < d i),
+        (R*Real.exp (-a*r^2))*Real.exp (-a*(d i)^2) := by
+      apply Finset.sum_le_sum
+      intro i hi
+      have hri := (Finset.mem_filter.mp hi).2.le
+      apply (hf i).trans
+      simp only [mul_assoc,← Real.exp_add]
+      gcongr
+      have hh := mul_le_mul_of_nonneg_left ((sq_le_sq₀ hr (hd i)).2 hri) ha
+      nlinarith
+    _ ≤ ∑ i, (R*Real.exp (-a*r^2))*Real.exp (-a*(d i)^2) :=
+      Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun _ _ _ ↦ by positivity)
+    _ = (R*Real.exp (-a*r^2))*∑ i, Real.exp (-a*(d i)^2) := by rw [Finset.mul_sum]
+    _ ≤ (R*Real.exp (-a*r^2))*B := mul_le_mul_of_nonneg_left hs (by positivity)
+    _ = _ := by ring
+
+lemma main_center_scale (N : ℝ) (hN : 0 < N) :
+    N*(N^(-5/12:ℝ))^2 = N^(1/6:ℝ) := by
+  calc
+    _ = N^(1:ℝ)*N^(-5/6:ℝ) := by
+      rw [← Real.rpow_mul_natCast hN.le]
+      norm_num
+    _ = _ := by rw [← Real.rpow_add hN]; norm_num
+
+lemma tendsto_main_center_tail (a : ℝ) (ha : 0 < a) :
+    Tendsto (fun n : ℕ ↦ Real.exp (-a*(n:ℝ)^(1/6:ℝ))) atTop (𝓝 0) := by
+  have hpow : Tendsto (fun n : ℕ ↦ (n:ℝ)^(1/6:ℝ)) atTop atTop :=
+    (tendsto_rpow_atTop (by norm_num : (0:ℝ) < 1/6)).comp tendsto_natCast_atTop_atTop
+  exact Real.tendsto_exp_atBot.comp ((tendsto_const_mul_atBot_of_neg (neg_neg_of_pos ha)).mpr hpow)
+
+end
+end Yau.Probability
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianUniformBall.lean

@@ -0,0 +1,84 @@
+import Mathlib.MeasureTheory.Measure.OpenPos
+import OAI.Geometry.NodalSets.Waves.EuclideanGaussianSmallBall
+
+namespace OAI
+
+namespace Yau.Probability
+open MeasureTheory ProbabilityTheory Set Metric
+open scoped ENNReal
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+local notation "E" => EuclideanSpace ℝ ι
+
+lemma stdGaussian_open_positive : (stdGaussian E).IsOpenPosMeasure := by
+  let : (gaussianReal 0 1).IsOpenPosMeasure :=
+    (gaussianReal_absolutelyContinuous' 0 (by norm_num : (1:NNReal) ≠ 0)).isOpenPosMeasure
+  rw [← map_pi_eq_stdGaussian]
+  apply Continuous.isOpenPosMeasure_map (by fun_prop)
+  exact (WithLp.equiv 2 (ι → ℝ)).symm.surjective
+
+lemma uniform_gaussian_ball (R r : ℝ) (hr : 0 < r) :
+    ∃ p : ℝ≥0∞, 0 < p ∧ ∀ z : E, ‖z‖ ≤ R → p ≤ stdGaussian E (ball z r) := by
+  classical
+  let : (stdGaussian E).IsOpenPosMeasure := stdGaussian_open_positive
+  obtain ⟨s,hs⟩ := (isCompact_closedBall (0:E) R).elim_finite_subcover
+    (fun z : E ↦ ball z (r/2)) (fun _ ↦ isOpen_ball) (by
+      intro z hz
+      exact mem_iUnion.mpr ⟨z,mem_ball_self (by positivity)⟩)
+  let p : ℝ≥0∞ := s.inf (fun z ↦ stdGaussian E (ball z (r/2)))
+  have hp : 0 < p := by
+    dsimp only [p]
+    clear hs p
+    induction s using Finset.induction_on with
+    | empty => simp
+    | @insert z s hz ih =>
+      rw [Finset.inf_insert]
+      exact lt_min (measure_ball_pos _ _ (by positivity)) ih
+  refine ⟨p,hp,?_⟩
+  intro z hz
+  have hz' : z ∈ closedBall (0:E) R := by simpa only [mem_closedBall,dist_zero_right] using hz
+  obtain ⟨y,hy,hyz⟩ := mem_iUnion₂.mp (hs hz')
+  apply (Finset.inf_le hy).trans
+  apply measure_mono
+  intro x hx
+  have hx' : dist x y < r/2 := hx
+  have hz'' : dist z y < r/2 := hyz
+  have hh := dist_triangle x y z
+  rw [dist_comm y z] at hh
+  change dist x z < r
+  linarith
+
+lemma uniform_affine_gaussian_ball (A B M r : ℝ) (hA : 0 ≤ A)
+    (hB : 0 < B) (hM : 0 ≤ M) (hr : 0 < r) (target : E) :
+    ∃ p : ℝ≥0∞, 0 < p ∧ ∀ (L : E ≃L[ℝ] E) (mean : E),
+      ‖L.symm.toContinuousLinearMap‖ ≤ A → ‖L.toContinuousLinearMap‖ ≤ B → ‖mean‖ ≤ M →
+      p ≤ ((stdGaussian E).map (fun z ↦ mean+L z)) (ball target r) := by
+  let radius : NNReal := ⟨A*(‖target‖+M), mul_nonneg hA (add_nonneg (norm_nonneg _) hM)⟩
+  obtain ⟨p,hp,huniform⟩ := uniform_gaussian_ball (ι := ι) radius (r/B) (div_pos hr hB)
+  refine ⟨p,hp,?_⟩
+  intro L mean hLi hL hm
+  let center := L.symm (target-mean)
+  have hc : ‖center‖ ≤ A*(‖target‖+M) := by
+    exact (L.symm.toContinuousLinearMap.le_opNorm _).trans
+      (mul_le_mul hLi ((norm_sub_le _ _).trans (add_le_add le_rfl hm)) (norm_nonneg _) hA)
+  apply (huniform center hc).trans
+  rw [Measure.map_apply (by fun_prop) isOpen_ball.measurableSet]
+  apply measure_mono
+  intro z hz
+  change dist (mean+L z) target < r
+  rw [dist_eq_norm]
+  have he : mean+L z-target = L (z-center) := by
+    simp only [map_sub,center,L.apply_symm_apply]
+    abel
+  rw [he]
+  have hb := L.toContinuousLinearMap.le_opNorm (z-center)
+  have hh : ‖z-center‖ < r/B := by simpa only [mem_ball,dist_eq_norm] using hz
+  have hmul := (lt_div_iff₀ hB).mp hh
+  calc
+    _ ≤ B*‖z-center‖ := hb.trans (mul_le_mul_of_nonneg_right hL (norm_nonneg _))
+    _ < r := by nlinarith
+
+end
+end Yau.Probability
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/GaussianWaveJet.lean

@@ -0,0 +1,58 @@
+import OAI.Geometry.NodalSets.Coefficients.DualWaveCoefficient
+import OAI.Geometry.NodalSets.Coefficients.GaussianCoefficientVariance
+import OAI.Geometry.NodalSets.Elliptic.RealPhaseJet
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff
+noncomputable section
+variable {ι : Type*} [Fintype ι]
+
+def gaussianCoefficient (a : ι × Fin 2 → ℝ) (i : ι) : ℂ :=
+  (a (i,0):ℂ)+Complex.I*(a (i,1):ℂ)
+
+lemma pairLinearSum_eq_complex (z : ι → ℂ) (a : ι × Fin 2 → ℝ) :
+    pairLinearSum z a = ∑ i, (gaussianCoefficient a i*z i).re := by
+  classical
+  simp only [pairLinearSum,Fintype.sum_prod_type,Fin.sum_univ_succ,Fin.succ_ne_zero,Fin.succ_zero_eq_one,ite_true,ite_false,Fin.sum_univ_zero,add_zero,
+    gaussianCoefficient,Complex.mul_re,Complex.mul_im,Complex.add_re,Complex.add_im,Complex.ofReal_re,
+    Complex.ofReal_im,Complex.I_re,Complex.I_im,zero_mul,one_mul,mul_zero,zero_add]
+  apply Finset.sum_congr rfl
+  intro i _
+  ring
+
+def gaussianWaveField (V : ι → Coord → ℂ) (a : ι × Fin 2 → ℝ) (x : Coord) : ℝ :=
+  (∑ i, gaussianCoefficient a i*V i x).re
+
+lemma gaussianWaveField_dual (V : ι → Coord → ℂ) (a : ι × Fin 2 → ℝ)
+    (x v : Coord) (hV : ∀ i, DifferentiableAt ℝ (V i) x) (N S b : ℝ) :
+    Real.exp (-N*S)*(b*gaussianWaveField V a x+N⁻¹*fderiv ℝ (gaussianWaveField V a) x v) =
+      pairLinearSum (fun i ↦ dualWaveCoefficient N (V i) S x b v) a := by
+  classical
+  let W : Coord → ℂ := fun z ↦ ∑ i, gaussianCoefficient a i*V i z
+  have hW : DifferentiableAt ℝ W x := DifferentiableAt.fun_sum (fun i _ ↦ (hV i).const_mul _)
+  have hd : fderiv ℝ W x v = ∑ i, gaussianCoefficient a i*fderiv ℝ (V i) x v := by
+    dsimp only [W]
+    rw [fderiv_fun_sum (fun i _ ↦ (hV i).const_mul _)]
+    simp only [sum_apply]
+    apply Finset.sum_congr rfl
+    intro i _
+    rw [((hV i).hasFDerivAt.const_mul (gaussianCoefficient a i)).fderiv]
+    rfl
+  have hr := realPart_fderiv W x hW v
+  change fderiv ℝ (gaussianWaveField V a) x v = _ at hr
+  rw [hr,hd,pairLinearSum_eq_complex]
+  simp only [gaussianWaveField,Complex.re_sum,Finset.mul_sum,← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro i _
+  simp only [dualWaveCoefficient,Complex.mul_re,Complex.mul_im,Complex.add_re,Complex.add_im,
+    Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,← Complex.ofReal_inv,
+    zero_mul,sub_zero,add_zero]
+  ring
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeActualDerivativeEnergy.lean

@@ -0,0 +1,74 @@
+import OAI.Geometry.NodalSets.Elliptic.RescaledDerivativeMoments
+import OAI.Geometry.NodalSets.Waves.LatticePlaneWaveEnergy
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+
+lemma norm_square_le_two_sub_add {E : Type*} [SeminormedAddCommGroup E] (a b : E) :
+    ‖a‖^2 ≤ 2*‖a-b‖^2+2*‖b‖^2 := by
+  have h := norm_add_le (a-b) b
+  rw [sub_add_cancel] at h
+  have hsq := pow_le_pow_left₀ (norm_nonneg a) h 2
+  nlinarith [sq_nonneg (‖a-b‖-‖b‖)]
+
+theorem lattice_actual_derivative_energy
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) (d : ℕ) :
+    ∃ C > 0, ∀ (w S : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+      (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+      U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+      ContDiff ℝ ∞ S → d ≤ k0 →
+      ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+        ∀ x ∈ Q, ∀ v : Coord, ‖v‖ ≤ 2 → ∀ k : ℕ, k ≤ d →
+        ∑ i : SourceGrid U n × Fin 3,
+          ‖iteratedFDeriv ℝ k (normalizedRescaling
+            (latticeWave a.cover a.beams hUD n i.1 i.2) S n (sourceSignScale g S x)
+            (a.latticeSigma hUD n x) x) v‖^2 ≤ C := by
+  obtain ⟨C,hC,hplane⟩ := lattice_planeWave_derivative_energy g hH hg hp d
+  refine ⟨2+2*C,by positivity,?_⟩
+  intro w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hd
+  filter_upwards [hplane w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU,
+    a.lattice_full_jet_approximation hUD hU hUb hQ hQU hS 2 (by norm_num) 1 (by norm_num),
+    a.estimates] with n hW he hest
+  obtain ⟨hfin,hW⟩ := hW
+  obtain ⟨hfin',he⟩ := he
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx v hv k hk
+  let W := a.latticePlaneWaveCoefficient hUD n x (sourceSignScale g S x)
+  let A := fun i : SourceGrid U n × Fin 3 ↦ normalizedRescaling
+    (latticeWave a.cover a.beams hUD n i.1 i.2) S n (sourceSignScale g S x)
+    (a.latticeSigma hUD n x) x
+  have hAs (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (A i) :=
+    normalizedRescaling_smooth _ (hest (latticeFrame a.cover hUD n i.1,i.2)).1 _ _ _ _ _
+  have hWs (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (W i) :=
+    a.latticePlaneWaveCoefficient_smooth _ _ _ _ _
+  have hk' : (k : WithTop ℕ∞) ≤ ∞ := by exact_mod_cast (show (k:ℕ∞) ≤ ⊤ from le_top)
+  have hid (i : SourceGrid U n × Fin 3) :
+      iteratedFDeriv ℝ k (fun z ↦ A i z-W i z) v =
+        iteratedFDeriv ℝ k (A i) v-iteratedFDeriv ℝ k (W i) v := by
+    change iteratedFDeriv ℝ k (A i-W i) v = _
+    exact iteratedFDeriv_sub_apply ((hAs i).of_le hk').contDiffAt ((hWs i).of_le hk').contDiffAt
+  have herr := he x hx _ (show 1 ≤ sourceSignScale g S x by
+    linarith [a.source_sign_scale_lower x (hUD (hQU hx))]) v hv (⟨k,by omega⟩ : Fin (k0+1))
+  change (∑ i, ‖iteratedFDeriv ℝ k (fun z ↦ A i z-W i z) v‖^2) ≤ 1 at herr
+  simp_rw [hid] at herr
+  have hw := hW x hx v k hk
+  have hb := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (SourceGrid U n × Fin 3))) ↦
+    norm_square_le_two_sub_add (iteratedFDeriv ℝ k (A i) v) (iteratedFDeriv ℝ k (W i) v))
+  simp only [Finset.sum_add_distrib,← Finset.mul_sum] at hb
+  change (∑ i, ‖iteratedFDeriv ℝ k (A i) v‖^2) ≤ _
+  change (∑ i, ‖iteratedFDeriv ℝ k (W i) v‖^2) ≤ C at hw
+  linarith
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeActualTwoPoint.lean

@@ -0,0 +1,73 @@
+import OAI.Geometry.NodalSets.Coefficients.TwoPointCoefficientEnergy
+import OAI.Geometry.NodalSets.Waves.LatticeTwoPointGap
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory Set Filter
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_actual_two_point_energy
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ delta > 0,
+      ∀ (w S : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U → ContDiff ℝ ∞ S →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∀ x ∈ Q, ∃ j : Fin 4, ∀ u v : ℝ,
+            let coeff := fun i : SourceGrid U n × Fin 3 ↦ normalizedRescaling
+              (latticeWave a.cover a.beams hUD n i.1 i.2) S n
+              (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+            delta*(u^2+v^2) ≤ ∑ i,
+              ‖(u:ℂ)*coeff i 0+(v:ℂ)*coeff i (tau • Pi.single j 1)‖^2 := by
+  obtain ⟨tau,ht,ht4,d,hd,hgaps⟩ := lattice_plane_wave_two_point_gap g hH hg hp
+  refine ⟨tau,ht,ht4,d/4,by positivity,?_⟩
+  intro w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS
+  filter_upwards [hgaps w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU,
+    a.lattice_full_jet_approximation hUD hU hUb hQ hQU hS 2 (by norm_num) (d/8) (by positivity)]
+    with n hgap herr
+  obtain ⟨hfin,hgap⟩ := hgap
+  obtain ⟨hfin',herr⟩ := herr
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx
+  obtain ⟨j,hM,hM1,hW,hC0,hC⟩ := hgap x hx
+  dsimp only at hM hM1 hW hC0 hC
+  let W := a.latticePlaneWaveCoefficient hUD n x (sourceSignScale g S x)
+  let A := fun i : SourceGrid U n × Fin 3 ↦ normalizedRescaling
+    (latticeWave a.cover a.beams hUD n i.1 i.2) S n
+    (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+  have hgap' : ∀ u v : ℝ, d*(u^2+v^2) ≤
+      ∑ i, ‖(u:ℂ)*W i 0+(v:ℂ)*W i (tau • Pi.single j 1)‖^2 := by
+    intro u v
+    apply two_point_energy_of_gap _ _ _ _ d rfl _ rfl _ _ u v
+    · simpa only [gaussianWaveField_eq_pair] using hW
+    · have hm0 := variance_nonneg (fun coeff ↦ gaussianWaveField W coeff 0) gaussianPairs
+      rw [gaussianWaveField_eq_pair] at hm0
+      simp only [gaussianWaveField_eq_pair] at hC0
+      linarith
+    · simpa only [gaussianWaveField_eq_pair] using hC
+  have hs : 1 ≤ sourceSignScale g S x := by
+    linarith [a.source_sign_scale_lower x (hUD (hQU hx))]
+  have hnorm : ‖(tau • Pi.single j (1:ℝ) : Coord)‖ ≤ 2 := by
+    rw [norm_smul,Real.norm_eq_abs,abs_of_pos ht,Pi.norm_single,norm_one,mul_one]
+    linarith
+  have he0 := herr x hx _ hs 0 (by simp) (0 : Fin (k0+1))
+  have he1 := herr x hx _ hs _ hnorm (0 : Fin (k0+1))
+  simp +instances only [Fin.val_zero,norm_iteratedFDeriv_zero] at he0 he1
+  refine ⟨j,?_⟩
+  intro u v
+  have hh := two_point_energy_perturbation (fun i ↦ W i 0) (fun i ↦ W i (tau • Pi.single j 1))
+    (fun i ↦ A i 0) (fun i ↦ A i (tau • Pi.single j 1)) d (d/8) he0 he1 hgap' u v
+  convert hh using 1
+  ring
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeCount.lean

@@ -0,0 +1,75 @@
+import Mathlib.SetTheory.Cardinal.Finite
+import OAI.Geometry.NodalSets.Waves.LatticeGeometry
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set
+noncomputable section
+
+lemma lattice_scale_eq_inv_sqrt (n : ℕ) : (n:ℝ)^(-1/2:ℝ) = (Real.sqrt n)⁻¹ := by
+  rw [show (-1/2:ℝ) = -(1/2) by ring,Real.rpow_neg,Real.sqrt_eq_rpow]
+  positivity
+
+theorem source_grid_card_bound {U : Set Coord} (hU : Bornology.IsBounded U) :
+    ∃ C > 0, ∀ n : ℕ, 0 < n → (Nat.card (SourceGrid U n) : ℝ) ≤ C*(n:ℝ)^2 := by
+  obtain ⟨B,hB,hbound⟩ := hU.exists_pos_norm_le
+  refine ⟨(2*B+3)^4,by positivity,?_⟩
+  intro n hn
+  have hnR : (1:ℝ) ≤ n := by exact_mod_cast hn
+  have hs : 0 < Real.sqrt n := Real.sqrt_pos.mpr (by exact_mod_cast hn)
+  have hs1 : 1 ≤ Real.sqrt n := Real.one_le_sqrt.mpr hnR
+  have hs2 : (Real.sqrt n)^2 = (n:ℝ) := Real.sq_sqrt (by positivity)
+  let M : ℤ := ⌈B*Real.sqrt n⌉
+  have hM0 : 0 ≤ M := Int.ceil_nonneg (by positivity)
+  have hMc : (M:ℝ) < B*Real.sqrt n+1 := Int.ceil_lt_add_one _
+  have hcoords (z : SourceGrid U n) (i : Fin 4) : z.val i ∈ Icc (-M) M := by
+    have hi := (norm_le_pi_norm (scaledLatticePoint n z) i).trans (hbound _ z.property)
+    change |(n:ℝ)^(-1/2:ℝ)*(z.val i:ℝ)| ≤ B at hi
+    rw [lattice_scale_eq_inv_sqrt,abs_mul,abs_of_pos (inv_pos.mpr hs)] at hi
+    have hmul := mul_le_mul_of_nonneg_left hi hs.le
+    have hcancel : Real.sqrt n * ((Real.sqrt n)⁻¹ * |(z.val i:ℝ)|) = |(z.val i:ℝ)| := by
+      field_simp
+    rw [hcancel] at hmul
+    have ha : |(z.val i:ℝ)| ≤ (M:ℝ) := hmul.trans (by simpa [mul_comm] using Int.le_ceil (B*Real.sqrt n))
+    have hp := abs_le.mp ha
+    exact ⟨by exact_mod_cast hp.1,by exact_mod_cast hp.2⟩
+  let f : SourceGrid U n → (Fin 4 → Icc (-M) M) := fun z i ↦ ⟨z.val i,hcoords z i⟩
+  have hfi : Function.Injective f := by
+    intro z w h
+    apply Subtype.ext
+    funext i
+    exact congrArg Subtype.val (congrFun h i)
+  have hc := Nat.card_le_card_of_injective f hfi
+  have hbox : Nat.card (Fin 4 → Icc (-M) M) = ((2*M+1).toNat)^4 := by
+    rw [Nat.card_fun]
+    simp [Nat.card_eq_fintype_card,Int.card_Icc,show M+1- -M = 2*M+1 by ring]
+  rw [hbox] at hc
+  have hcR : (Nat.card (SourceGrid U n):ℝ) ≤ ((2*M+1).toNat:ℝ)^4 := by exact_mod_cast hc
+  have hcast : ((2*M+1).toNat:ℝ) = 2*(M:ℝ)+1 := by
+    have hi : ((2*M+1).toNat:ℤ) = 2*M+1 := Int.toNat_of_nonneg (by omega)
+    exact_mod_cast hi
+  rw [hcast] at hcR
+  have hmnon : (0:ℝ) ≤ 2*(M:ℝ)+1 := by exact_mod_cast (show (0:ℤ) ≤ 2*M+1 by omega)
+  have hmle : 2*(M:ℝ)+1 ≤ (2*B+3)*Real.sqrt n := by nlinarith
+  have hpow := pow_le_pow_left₀ hmnon hmle 4
+  calc
+    _ ≤ (2*(M:ℝ)+1)^4 := hcR
+    _ ≤ ((2*B+3)*Real.sqrt n)^4 := hpow
+    _ = (2*B+3)^4*(n:ℝ)^2 := by
+      rw [mul_pow,show (Real.sqrt n)^4 = ((Real.sqrt n)^2)^2 by ring,hs2]
+
+theorem source_coefficient_card_bound {U : Set Coord} (hU : Bornology.IsBounded U) :
+    ∃ C > 0, ∀ n : ℕ, 0 < n → (Nat.card (SourceGrid U n × Fin 3):ℝ) ≤ C*(n:ℝ)^2 := by
+  obtain ⟨C,hC,hb⟩ := source_grid_card_bound hU
+  refine ⟨3*C,by positivity,?_⟩
+  intro n hn
+  have h := hb n hn
+  rw [Nat.card_prod]
+  norm_num
+  nlinarith
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeCovariance.lean

@@ -0,0 +1,60 @@
+import OAI.Geometry.NodalSets.Waves.LatticeCovariance2
+import OAI.Geometry.NodalSets.Waves.SeededGaussianJet
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeSeededRandomDual (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (seed : Coord → ℝ) (x : Coord) (b : ℝ) (v : Coord)
+    (coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ) : ℝ :=
+  letI := hfin
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  Real.exp (-(n:ℝ)*S x)*(b*(seed x+gaussianWaveField V coeff x)+
+    (n:ℝ)⁻¹*fderiv ℝ (fun z ↦ seed z+gaussianWaveField V coeff z) x v)
+
+lemma variance_latticeSeededRandomDual (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (seed : Coord → ℝ) (x : Coord) (hseed : DifferentiableAt ℝ seed x)
+    (hV : ∀ z j, DifferentiableAt ℝ (latticeWave a.cover a.beams hUD n z j) x)
+    (b : ℝ) (v : Coord) :
+    letI := hfin
+    Var[a.latticeSeededRandomDual hUD n hfin seed x b v; gaussianPairs] =
+      a.latticeEnergy hUD n hfin x b v := by
+  let := hfin
+  exact seeded_gaussian_dual_variance
+    (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+    seed x v (fun i ↦ hV i.1 i.2) hseed (n:ℝ) (S x) b
+
+theorem actual_lattice_covariance_lower_bound (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ (seed : Coord → ℝ) (x : Coord), x ∈ Q → DifferentiableAt ℝ seed x → ∀ (b : ℝ) (v : Coord),
+      c/(n:ℝ)*(b^2+∑ i : Fin 4, (v i)^2) ≤
+        Var[a.latticeSeededRandomDual hUD n hfin seed x b v; gaussianPairs] := by
+  obtain ⟨c,hc,hb⟩ := a.euclidean_lattice_covariance_lower_bound hUD hU hUb hQ hQU
+  refine ⟨c,hc,?_⟩
+  filter_upwards [hb,lattice_wave_estimates a.cover a.beams hUD] with n hn hs
+  obtain ⟨hfin,hbound⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro seed x hx hseed b v
+  have hV : ∀ z j, DifferentiableAt ℝ (latticeWave a.cover a.beams hUD n z j) x :=
+    fun z j ↦ ((hs z j).1.differentiable (by simp)).differentiableAt
+  rw [a.variance_latticeSeededRandomDual hUD n hfin seed x hseed hV]
+  have hb := hbound x hx b v
+  rw [a.variance_latticeRandomDual] at hb
+  exact hb
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeCovariance2.lean

@@ -0,0 +1,70 @@
+import OAI.Geometry.NodalSets.Coefficients.GaussianCoefficientVariance
+import OAI.Geometry.NodalSets.Waves.LatticeEnergyLowerBound
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeRandomDual (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (x : Coord) (b : ℝ) (v : Coord) : (((SourceGrid U n × Fin 3) × Fin 2) → ℝ) → ℝ :=
+  letI := hfin
+  pairLinearSum (fun i : SourceGrid U n × Fin 3 ↦
+    dualWaveCoefficient n (latticeWave a.cover a.beams hUD n i.1 i.2) (S x) x b v)
+
+lemma variance_latticeRandomDual (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (x : Coord) (b : ℝ) (v : Coord) :
+    letI := hfin
+    Var[a.latticeRandomDual hUD n hfin x b v; gaussianPairs] = a.latticeEnergy hUD n hfin x b v := by
+  let := hfin
+  exact variance_pairLinearSum _
+
+theorem lattice_covariance_lower_bound (hUD : U ⊆ D) (hU : IsOpen U) (hUb : Bornology.IsBounded U)
+    {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), ∀ x ∈ Q, ∀ b v,
+      letI := hfin
+      c/(n:ℝ)*(b^2+‖v‖^2) ≤ Var[a.latticeRandomDual hUD n hfin x b v; gaussianPairs] := by
+  obtain ⟨c,hc,hb⟩ := a.lattice_energy_lower_bound hUD hU hUb hQ hQU
+  refine ⟨c,hc,?_⟩
+  filter_upwards [hb] with n hn
+  obtain ⟨hfin,hbound⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx b v
+  rw [a.variance_latticeRandomDual]
+  exact hbound x hx b v
+
+theorem euclidean_lattice_covariance_lower_bound (hUD : U ⊆ D) (hU : IsOpen U) (hUb : Bornology.IsBounded U)
+    {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), ∀ x ∈ Q, ∀ b v,
+      letI := hfin
+      c/(n:ℝ)*(b^2+∑ i : Fin 4, (v i)^2) ≤ Var[a.latticeRandomDual hUD n hfin x b v; gaussianPairs] := by
+  obtain ⟨c,hc,hb⟩ := a.lattice_covariance_lower_bound hUD hU hUb hQ hQU
+  refine ⟨c/4,by positivity,?_⟩
+  filter_upwards [hb,eventually_ge_atTop (1:ℕ)] with n hn hn1
+  obtain ⟨hfin,hbound⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx b v
+  apply le_trans _ (hbound x hx b v)
+  have hcoord (i : Fin 4) : (v i)^2 ≤ ‖v‖^2 := by
+    have hh := norm_le_pi_norm v i
+    change |v i| ≤ ‖v‖ at hh
+    nlinarith [sq_abs (v i),norm_nonneg v,abs_nonneg (v i)]
+  have hsum := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) ↦ hcoord i)
+  norm_num at hsum
+  have hh : b^2+∑ i : Fin 4, (v i)^2 ≤ 4*(b^2+‖v‖^2) := by nlinarith [sq_nonneg b]
+  have hh' := mul_le_mul_of_nonneg_left hh (by positivity : 0 ≤ c/(4*(n:ℝ)))
+  convert hh' using 1 <;> ring
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeDerivativeMoments.lean

@@ -0,0 +1,63 @@
+import OAI.Geometry.NodalSets.Elliptic.SignScaleSeed
+import OAI.Geometry.NodalSets.Waves.LatticeActualDerivativeEnergy
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_derivative_second_moments
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) (d : ℕ) :
+    ∃ C > 0, ∀ (w S S0 T0 : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+      (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+      U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+      ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 → d ≤ k0 →
+      ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+      ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+        ∀ x ∈ Q, ∀ v : Coord, sourceEuclideanNorm v ≤ 2 → ∀ k : ℕ, k ≤ d →
+        ∀ dirs : Fin k → Coord, ‖dirs‖ ≤ 1 →
+        let F := rescaledGaussianField
+          (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+          S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+        MemLp (fun coeff ↦ iteratedFDeriv ℝ k (F coeff) v dirs) 2 gaussianPairs ∧
+        (∫ coeff, (iteratedFDeriv ℝ k (F coeff) v dirs)^2 ∂gaussianPairs) ≤ C := by
+  obtain ⟨C,hC,henergy⟩ := lattice_actual_derivative_energy g hH hg hp d
+  refine ⟨1+C,by positivity,?_⟩
+  intro w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 hd gamma hgamma hgap
+  filter_upwards [henergy w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hd,
+    a.sign_scale_seed_decay hUD hU hUb hQ hQU hS S0 T0 hS0 hT0 gamma hgamma hgap d 1 (by norm_num),
+    a.estimates] with n he hs hest
+  obtain ⟨hfin,he⟩ := he
+  obtain ⟨hfin',hs⟩ := hs
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx v hv k hk dirs hdirs
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (hest (latticeFrame a.cover hUD n i.1,i.2)).1
+  refine ⟨rescaledGaussianField_derivative_memLp V hV _ _ _ hS0 hT0 _ _ _ _ _ _ _,?_⟩
+  rw [rescaledGaussianField_derivative_moment V hV _ _ _ hS0 hT0]
+  have hseed := hs x hx v hv (⟨k,by omega⟩ : Fin (d+1))
+  have hseed' := (iteratedFDeriv ℝ k
+    (rescaledSeed S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x) v).unit_le_opNorm hdirs
+  have hmean := pow_le_pow_left₀ (norm_nonneg _) (hseed'.trans hseed) 2
+  simp only [Real.norm_eq_abs,sq_abs,one_pow] at hmean
+  have hsum := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (SourceGrid U n × Fin 3))) ↦
+    pow_le_pow_left₀ (norm_nonneg _)
+      ((iteratedFDeriv ℝ k (normalizedRescaling (V i) S n (sourceSignScale g S x)
+        (a.latticeSigma hUD n x) x) v).unit_le_opNorm hdirs) 2)
+  have hbound := he x hx v ((norm_le_sourceEuclideanNorm v).trans hv) k hk
+  change (∑ i, ‖iteratedFDeriv ℝ k (normalizedRescaling (V i) S n (sourceSignScale g S x)
+    (a.latticeSigma hUD n x) x) v‖^2) ≤ C at hbound
+  linarith
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeDerivativeTail.lean

@@ -0,0 +1,75 @@
+import OAI.Geometry.NodalSets.Waves.GaussianTailBound
+import OAI.Geometry.NodalSets.Waves.LatticeVarianceUpper
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_derivative_tail_bound (hUD : U ⊆ D) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x : Coord,
+      ∀ k : Fin (k0+1), ∀ r : ℝ, 0 ≤ r →
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+          r < sourceEuclideanNorm (x-scaledLatticePoint n i.1)),
+        ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 ≤
+        C*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x)*Real.exp (-a.beams.c*(n:ℝ)*r^2) := by
+  classical
+  obtain ⟨B,hB,hgauss⟩ := source_lattice_gaussian_sum a.beams.c_pos
+  refine ⟨3*a.beams.Cw^2*B,by have := a.beams.Cw_pos; positivity,?_⟩
+  filter_upwards [a.estimates,eventually_gt_atTop (0:ℕ)] with n hn hnpos
+  intro hfin x k r hr
+  let d : SourceGrid U n × Fin 3 → ℝ := fun i ↦ sourceEuclideanNorm (x-scaledLatticePoint n i.1)
+  let R := a.beams.Cw^2*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x)
+  have hb (i : SourceGrid U n × Fin 3) :
+      ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 ≤
+        R*Real.exp (-2*(a.beams.c*(n:ℝ))*(d i)^2) := by
+    have h := ((hn (latticeFrame a.cover hUD n i.1,i.2)).2.2.2.2 x).1 k
+    simp only [latticeFrame_center] at h
+    change ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖ ≤ _ at h
+    refine (pow_le_pow_left₀ (norm_nonneg _) h 2).trans_eq ?_
+    dsimp [R,d]
+    rw [mul_pow,mul_pow,← Real.exp_nat_mul,← pow_mul]
+    simp only [mul_assoc,← Real.exp_add]
+    congr 2 <;> ring_nf
+  have hg : ∑ i : SourceGrid U n × Fin 3, Real.exp (-(a.beams.c*(n:ℝ))*(d i)^2) ≤ 3*B := by
+    dsimp [d]
+    rw [Fintype.sum_prod_type]
+    simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+    rw [← Finset.mul_sum]
+    norm_num only [Nat.cast_ofNat]
+    apply mul_le_mul_of_nonneg_left _ (by norm_num)
+    simpa only [neg_mul] using hgauss U n hnpos x
+  have hh := finite_gaussian_tail d
+    (fun i ↦ ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2)
+    (by have := a.beams.c_pos; positivity : 0 ≤ a.beams.c*(n:ℝ))
+    (by dsimp [R]; positivity : 0 ≤ R) hr (fun i ↦ sourceEuclideanNorm_nonneg _) hb hg
+  convert hh using 1
+  dsimp [R]
+  simp only [neg_mul]
+  ring
+
+theorem lattice_nonmain_derivative_bound (hUD : U ⊆ D) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x : Coord,
+      ∀ k : Fin (k0+1),
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+          (n:ℝ)^(-5/12:ℝ) < sourceEuclideanNorm (x-scaledLatticePoint n i.1)),
+        ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 ≤
+        C*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)) := by
+  obtain ⟨C,hC,hb⟩ := a.lattice_derivative_tail_bound hUD
+  refine ⟨C,hC,?_⟩
+  filter_upwards [hb,eventually_gt_atTop (0:ℕ)] with n hn hnpos
+  intro hfin x k
+  have h := hn x k ((n:ℝ)^(-5/12:ℝ)) (by positivity)
+  rwa [mul_assoc (-a.beams.c),main_center_scale _ (by exact_mod_cast hnpos)] at h
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeDirectionalCenters.lean

@@ -0,0 +1,49 @@
+import OAI.Geometry.NodalSets.Elliptic.HalfScaleLemmas
+import OAI.Geometry.NodalSets.Waves.LatticeGeometry
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Metric Filter
+noncomputable section
+
+def unitDirection (v : Coord) : Coord := (‖v‖⁻¹:ℝ) • v
+
+lemma norm_unitDirection_le (v : Coord) : ‖unitDirection v‖ ≤ 1 := by
+  by_cases hv : v = 0
+  · simp [unitDirection,hv]
+  have hn : 0 < ‖v‖ := norm_pos_iff.mpr hv
+  simp only [unitDirection,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hn),inv_mul_cancel₀ hn.ne']
+  exact le_rfl
+
+def directionalLatticeIndex (n : ℕ) (x : Coord) (K : ℝ) (v : Coord) : Fin 4 → ℤ :=
+  roundedLatticeIndex n (x+(K*(n:ℝ)^(-1/2:ℝ)) • unitDirection v)
+
+lemma directional_rounding_error {n : ℕ} (hn : 0 < n) (x : Coord) (K : ℝ) (v : Coord) :
+    ‖scaledLatticePoint n (directionalLatticeIndex n x K v)-
+      (x+(K*(n:ℝ)^(-1/2:ℝ)) • unitDirection v)‖ ≤ 2*(n:ℝ)^(-1/2:ℝ) :=
+  (norm_le_sourceEuclideanNorm _).trans (rounded_lattice_distance hn _)
+
+lemma directional_center_distance {n : ℕ} (hn : 0 < n) (x : Coord) (K : ℝ) (hK : 0 ≤ K) (v : Coord) :
+    ‖scaledLatticePoint n (directionalLatticeIndex n x K v)-x‖ ≤ (K+2)*(n:ℝ)^(-1/2:ℝ) := by
+  let z := x+(K*(n:ℝ)^(-1/2:ℝ)) • unitDirection v
+  have h := norm_sub_le_norm_sub_add_norm_sub (scaledLatticePoint n (directionalLatticeIndex n x K v)) z x
+  have hz : ‖z-x‖ ≤ K*(n:ℝ)^(-1/2:ℝ) := by
+    simp only [z,add_sub_cancel_left,norm_smul,Real.norm_eq_abs,
+      abs_of_nonneg (mul_nonneg hK (lattice_scale_pos hn).le)]
+    exact (mul_le_mul_of_nonneg_left (norm_unitDirection_le v)
+      (mul_nonneg hK (lattice_scale_pos hn).le)).trans_eq (mul_one _)
+  have hr := directional_rounding_error hn x K v
+  dsimp [z] at h hz
+  nlinarith
+
+lemma directional_center_mem {U : Set Coord} {n : ℕ} (hn : 0 < n)
+    (x : Coord) (K : ℝ) (hK : 0 ≤ K) (v : Coord)
+    (hball : closedBall x ((K+2)*(n:ℝ)^(-1/2:ℝ)) ⊆ U) :
+    scaledLatticePoint n (directionalLatticeIndex n x K v) ∈ U :=
+  hball (by simpa only [mem_closedBall,dist_eq_norm] using directional_center_distance hn x K hK v)
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeEnergyLowerBound.lean

@@ -0,0 +1,152 @@
+import OAI.Geometry.NodalSets.Elliptic.FiniteJetEnergy
+import OAI.Geometry.NodalSets.Waves.LatticeDirectionalCenters
+import OAI.Geometry.NodalSets.Waves.LocalCovarianceGeometry
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Metric Filter
+open scoped ContDiff Topology
+noncomputable section
+
+lemma compact_inner_ball {Q U : Set Coord} (hQ : IsCompact Q) (hU : IsOpen U) (hQU : Q ⊆ U) :
+    ∃ r > 0, ∀ x ∈ Q, closedBall x r ⊆ U := by
+  let : CompactSpace Q := isCompact_iff_compactSpace.mp hQ
+  obtain ⟨r,hr,hri⟩ := compact_family_common_radius isCompact_univ
+    (fun z : Q × Coord ↦ (z.1:Coord)+z.2)
+    ((continuous_subtype_val.comp continuous_fst).add continuous_snd)
+    hU (fun t _ ↦ by simpa only [add_zero] using hQU t.property)
+  refine ⟨r/2,by positivity,?_⟩
+  intro x hx z hz
+  have hn : ‖z-x‖ ≤ r/2 := by simpa only [mem_closedBall,dist_eq_norm] using hz
+  have h := hri ⟨x,hx⟩ (mem_univ _) (z-x) (by linarith)
+  simpa using h
+
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeEnergy (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (x : Coord) (b : ℝ) (v : Coord) : ℝ :=
+  letI := hfin
+  ∑ i : SourceGrid U n × Fin 3,
+    ‖dualWaveCoefficient n (latticeWave a.cover a.beams hUD n i.1 i.2) (S x) x b v‖^2
+
+theorem lattice_energy_lower_bound (hUD : U ⊆ D) (hU : IsOpen U) (hUb : Bornology.IsBounded U)
+    {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), ∀ x ∈ Q, ∀ b v,
+      c/(n:ℝ)*(b^2+‖v‖^2) ≤ a.latticeEnergy hUD n hfin x b v := by
+  obtain ⟨mu,hmu,B,hB,hgeom⟩ := a.original_covariance_geometry
+  obtain ⟨e,he,E,hE,heta⟩ := a.lattice_eta_bounds hUD
+  let R : ℝ := (2*B+2)/mu
+  have hR : 0 < R := by dsimp [R]; positivity
+  let L := R+2
+  have hL : 0 < L := by dsimp [L]; linarith
+  have hlarge : 2*B+1 ≤ R*mu := by dsimp [R]; rw [div_mul_cancel₀ _ hmu.ne']; linarith
+  obtain ⟨Ca,hCa,Cr,hCr,Ci,hCi,s,hs,C,hC,hjets⟩ := a.lattice_logarithmic_jet_estimates hUD L hL
+  let F := B+E*B*L+Cr
+  have hF : 0 ≤ F := by dsimp [F]; positivity
+  let kappa := e^2/(2*(e+F+1)^2)
+  have hkappa : 0 < kappa := by dsimp [kappa]; positivity
+  obtain ⟨r,hr,hinner⟩ := compact_inner_ball hQ hU hQU
+  refine ⟨s^2*kappa/2,by positivity,?_⟩
+  filter_upwards [hjets,eventually_nat_frequency (half_scale_eventually L 1 r hr),
+    eventually_nat_frequency (half_scale_eventually (2*Cr) 1 e he)] with n hj hn hsmall
+  have hn1 : 1 ≤ n := by exact_mod_cast hn.1
+  have hnpos : 0 < n := by omega
+  have hN : 0 < (n:ℝ) := by exact_mod_cast hnpos
+  let h := (n:ℝ)^(-1/2:ℝ)
+  have hh : 0 < h := lattice_scale_pos hnpos
+  have hh1 : h ≤ 1 := Real.rpow_le_one_of_one_le_of_nonpos hn.1 (by norm_num)
+  let : Finite (SourceGrid U n) := finite_source_grid hUb hnpos
+  let hfin : Fintype (SourceGrid U n) := Fintype.ofFinite _
+  refine ⟨hfin,?_⟩
+  intro x hx b v
+  have hxD := hUD (hQU hx)
+  have hball : closedBall x (L*h) ⊆ U := (closedBall_subset_closedBall hn.2.1).trans (hinner x hx)
+  let z (v : Coord) : SourceGrid U n := ⟨directionalLatticeIndex n x R v,
+    directional_center_mem hnpos x R hR.le v hball⟩
+  let V (v : Coord) := latticeWave a.cover a.beams hUD n (z v) 0
+  let yy (v : Coord) := scaledLatticePoint n (z v)
+  have hdist (v : Coord) : ‖x-yy v‖ ≤ L*h := by
+    rw [norm_sub_rev]
+    exact directional_center_distance hnpos x R hR.le v
+  have hjet (v : Coord) := hj (z v) 0 x (hdist v)
+  let Rp := b+(normalizedLogJet n (V v) x v).re
+  let Rm := b+(normalizedLogJet n (V (-v)) x v).re
+  let pp := g (yy v) (x-yy v) v
+  let pm := g (yy (-v)) (x-yy (-v)) v
+  let ep := a.latticeEta hUD n (z v) 0
+  let em := a.latticeEta hUD n (z (-v)) 0
+  have hgp := hgeom (yy v) (hUD (z v).property)
+  have hgm := hgeom (yy (-v)) (hUD (z (-v)).property)
+  have hpp : pp ≤ -h*‖v‖ := rounded_positive_pairing (g (yy v)) mu B R h hmu hB.le hR.le hh.le
+    hgp.1 hgp.2.2 hlarge x (yy v) v (directional_rounding_error hnpos x R v)
+  have hpm : h*‖v‖ ≤ pm := by
+    have hh' := rounded_positive_pairing (g (yy (-v))) mu B R h hmu hB.le hR.le hh.le
+      hgm.1 hgm.2.2 hlarge x (yy (-v)) (-v) (directional_rounding_error hnpos x R (-v))
+    simp only [map_neg,norm_neg] at hh'
+    dsimp [pm]
+    linarith
+  have herr (u : Coord) : |(b+(normalizedLogJet n (V u) x v).re)-
+      ((b+fderiv ℝ S x v)-a.latticeEta hUD n (z u) 0*g (yy u) (x-yy u) v)| ≤ Cr*h^2*‖v‖ := by
+    have hh' := ((hjet u).2.2.2.2.2 v).1
+    have heq : Cr/(n:ℝ)*‖v‖ = Cr*h^2*‖v‖ := by dsimp [h]; rw [half_scale_square hN]; ring
+    rw [heq] at hh'
+    convert hh' using 1
+    congr 1
+    ring
+  have hdiff : e*h*‖v‖ ≤ Rp-Rm := opposite_real_products (b+fderiv ℝ S x v)
+    Rp Rm ep em pp pm h ‖v‖ e Cr hh.le (norm_nonneg _) he.le
+    (heta n (z v) 0).1 (heta n (z (-v)) 0).1 hpp hpm (herr v) (herr (-v)) hsmall.2.1
+  have hprod : |ep*pp| ≤ E*B*L*‖v‖ := by
+    have hpabs := (bilinear_pairing_bound (g (yy v)) (x-yy v) v).trans
+      (show ‖g (yy v)‖*‖x-yy v‖*‖v‖ ≤ B*(L*h)*‖v‖ by
+        gcongr
+        · exact hgp.1
+        · exact hdist v)
+    have hepos : 0 ≤ ep := he.le.trans (heta n (z v) 0).1
+    rw [abs_mul,abs_of_nonneg hepos]
+    calc
+      ep*|pp| ≤ E*(B*(L*h)*‖v‖) := mul_le_mul (heta n (z v) 0).2 hpabs (abs_nonneg _) hE.le
+      _ ≤ E*(B*L*‖v‖) := by
+        gcongr
+        simpa using mul_le_mul_of_nonneg_left hh1 hL.le
+      _ = _ := by ring
+  have hSv : |fderiv ℝ S x v| ≤ B*‖v‖ :=
+    ((fderiv ℝ S x).le_opNorm v).trans (mul_le_mul_of_nonneg_right (hgeom x hxD).2.1 (norm_nonneg v))
+  have hErr : Cr*h^2*‖v‖ ≤ Cr*‖v‖ := by
+    have hh2 := pow_le_pow_left₀ hh.le hh1 2
+    nlinarith [mul_nonneg hCr.le (norm_nonneg v)]
+  have hlog : |(normalizedLogJet n (V v) x v).re| ≤ F*‖v‖ := by
+    have hpR := abs_le.mp ((herr v).trans hErr)
+    have hpP := abs_le.mp hprod
+    have hpS := abs_le.mp hSv
+    dsimp [F,Rp,ep,pp] at *
+    apply abs_le.mpr
+    constructor <;> nlinarith
+  have hb : |b| ≤ |Rp|+F*‖v‖ := by
+    have ht := norm_sub_le (b+(normalizedLogJet n (V v) x v).re) (normalizedLogJet n (V v) x v).re
+    have ht' : |b| ≤ |Rp|+|(normalizedLogJet n (V v) x v).re| := by simpa only [add_sub_cancel_right,Real.norm_eq_abs] using ht
+    exact ht'.trans (add_le_add le_rfl hlog)
+  have hpair := paired_products_control b ‖v‖ Rp Rm h e F (norm_nonneg _) hh hh1 he hF hdiff hb
+  let f (i : SourceGrid U n × Fin 3) := dualWaveCoefficient n
+    (latticeWave a.cover a.beams hUD n i.1 i.2) (S x) x b v
+  have hcoef (u : Coord) : s*|b+(normalizedLogJet n (V u) x v).re| ≤ ‖f (z u,0)‖ :=
+    (mul_le_mul_of_nonneg_right (hjet u).2.2.2.2.1.1 (abs_nonneg _)).trans
+      (real_log_product_le_coefficient n (V u) (S x) x b v (hjet u).2.2.2.1)
+  have henergy := two_coefficient_energy f (z v,0) (z (-v),0) s Rp Rm hs.le (hcoef v) (hcoef (-v))
+  have hpair' := mul_le_mul_of_nonneg_left hpair (sq_nonneg s)
+  have hhbound := hpair'.trans henergy
+  change s^2*(kappa*h^2*(b^2+‖v‖^2)) ≤ 2*a.latticeEnergy hUD n hfin x b v at hhbound
+  calc
+    _ = (s^2*(kappa*h^2*(b^2+‖v‖^2)))/2 := by dsimp [h]; rw [half_scale_square hN]; ring
+    _ ≤ _ := (div_le_iff₀ (by norm_num : (0:ℝ)<2)).mpr (by linarith)
+
+end LocalCompactWaveData
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeFieldBounds.lean

@@ -0,0 +1,64 @@
+import OAI.Geometry.NodalSets.Waves.FiniteWaveDerivativeBounds
+import OAI.Geometry.NodalSets.Waves.LatticeCount
+import OAI.Geometry.NodalSets.Waves.LocalCompactWaves
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_field_derivative_bound (hUD : U ⊆ D) (hUb : Bornology.IsBounded U) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ,
+        coeff ∈ coefficientEvent (n:ℝ) →
+        ContDiff ℝ ∞ (gaussianWaveField
+          (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff) ∧
+        ∀ x : Coord, ∀ k : Fin (k0+1),
+          ‖iteratedFDeriv ℝ k.val (gaussianWaveField
+            (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff) x‖ ≤
+          C*(n:ℝ)^(k.val+3)*Real.exp ((n:ℝ)*S x) := by
+  obtain ⟨C,hC,hcard⟩ := source_coefficient_card_bound hUb
+  have hcw := a.beams.Cw_pos
+  have hbc := a.beams.c_pos
+  refine ⟨C*a.beams.Cw,mul_pos hC a.beams.Cw_pos,?_⟩
+  filter_upwards [a.estimates,eventually_gt_atTop (0:ℕ)] with n hn hnpos
+  have := finite_source_grid hUb hnpos
+  let hfin := Fintype.ofFinite (SourceGrid U n)
+  let := hfin
+  refine ⟨hfin,?_⟩
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (hn (latticeFrame a.cover hUD n i.1,i.2)).1
+  intro coeff hc
+  refine ⟨gaussianWaveField_contDiff V coeff hV,?_⟩
+  intro x k
+  have hb (i : SourceGrid U n × Fin 3) : ‖iteratedFDeriv ℝ k.val (V i) x‖ ≤
+      a.beams.Cw*(n:ℝ)^k.val*Real.exp ((n:ℝ)*S x) := by
+    have h := ((hn (latticeFrame a.cover hUD n i.1,i.2)).2.2.2.2 x).1 k
+    refine h.trans ?_
+    gcongr
+    exact sub_le_self _ (by positivity : 0 ≤ a.beams.c*(n:ℝ)*
+      (sourceEuclideanNorm (x-coverSourceCenter a.cover (latticeFrame a.cover hUD n i.1)))^2)
+  have h := gaussianWaveField_iterated_bound V coeff hV k.val x (by positivity) hc hb
+  have hcardR : (Fintype.card (SourceGrid U n × Fin 3):ℝ) ≤ C*(n:ℝ)^2 := by
+    simpa only [Nat.card_eq_fintype_card] using hcard n hnpos
+  refine h.trans ?_
+  calc
+    _ ≤ (C*(n:ℝ)^2)*(n:ℝ)*(a.beams.Cw*(n:ℝ)^k.val*Real.exp ((n:ℝ)*S x)) := by
+      gcongr
+    _ = (C*a.beams.Cw)*(n:ℝ)^(k.val+3)*Real.exp ((n:ℝ)*S x) := by
+      rw [pow_add]
+      ring
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeFrequencyAnnulus.lean

@@ -0,0 +1,39 @@
+import OAI.Geometry.NodalSets.Charts.MetricFrequencyBounds
+import OAI.Geometry.NodalSets.Elliptic.SignScaleContinuity
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_main_frequency_annulus
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ κ > 0, ∃ B > 0, ∀ (w S : Coord → ℝ) (D U : Set Coord) (m J K k0 : ℕ)
+      (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+      U ⊆ H → ∀ᶠ n : ℕ in atTop, ∀ x ∈ H, ∀ i : SourceGrid U n × Fin 3,
+      sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ) →
+      κ ≤ sourceEuclideanNorm (sourceFrequency (g (scaledLatticePoint n i.1))
+        (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) (sourceSignScale g S x)) ∧
+      sourceEuclideanNorm (sourceFrequency (g (scaledLatticePoint n i.1))
+        (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) (sourceSignScale g S x)) ≤ B := by
+  obtain ⟨κ,hκ,B,hB,hmetric⟩ := compact_metric_frequency_bounds g hH hg hp
+  refine ⟨κ,hκ,B,hB,?_⟩
+  intro w S D U m J K k0 a hHD hUD hUH
+  filter_upwards [a.source_main_scale_comparison hH hHD] with n hn
+  intro x hx i hi
+  have hy : scaledLatticePoint n i.1 ∈ H := hUH i.1.property
+  have hr := hn x hx _ hy hi
+  have hx0 : 0 < sourceSignScale g S x := by linarith [a.source_sign_scale_lower x (hHD hx)]
+  have hy0 : 0 < sourceSignScale g S (scaledLatticePoint n i.1) := by
+    linarith [a.source_sign_scale_lower _ (hUD i.1.property)]
+  apply hmetric _ hy _ _ _ hx0 hy0 _ hr.1 hr.2
+  simpa only [latticeFrame_center] using a.original_direction_length (latticeFrame a.cover hUD n i.1) i.2
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeFullPlaneWaveApprox.lean

@@ -0,0 +1,72 @@
+import OAI.Geometry.NodalSets.Waves.LatticePlaneWaveJets
+import OAI.Geometry.NodalSets.Waves.RescaledLatticeTail
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticePlaneWaveCoefficient (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x : Coord) (s : ℝ) (i : SourceGrid U n × Fin 3) (v : Coord) : ℂ :=
+  if sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ) then
+    a.latticeAlpha hUD n x i *
+      planeWave (g (scaledLatticePoint n i.1) (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2)) s v
+  else 0
+
+theorem lattice_full_jet_approximation (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U)
+    (hS : ContDiff ℝ ∞ S) (R : ℝ) (hR : 0 ≤ R) (e : ℝ) (he : 0 < e) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+      ∀ x ∈ Q, ∀ s : ℝ, 1 ≤ s → ∀ v : Coord, ‖v‖ ≤ R → ∀ k : Fin (k0+1),
+      ∑ i : SourceGrid U n × Fin 3,
+        ‖iteratedFDeriv ℝ k.val (fun z ↦
+          normalizedRescaling (latticeWave a.cover a.beams hUD n i.1 i.2) S n s
+            (a.latticeSigma hUD n x) x z - a.latticePlaneWaveCoefficient hUD n x s i z) v‖^2 ≤ e := by
+  classical
+  filter_upwards [a.lattice_main_jet_approximation hUD hU hUb hQ hQU R hR k0 (e/2) (by positivity),
+    a.rescaled_lattice_nonmain_negligible hUD hU hUb hQ hQU hS R hR (e/2) (by positivity)]
+    with n hmain htail
+  obtain ⟨hfin,hm⟩ := hmain
+  obtain ⟨hfin',ht⟩ := htail
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx s hs v hv k
+  let P := fun i : SourceGrid U n × Fin 3 ↦
+    sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ)
+  let err := fun i : SourceGrid U n × Fin 3 ↦
+    ‖iteratedFDeriv ℝ k.val (fun z ↦
+      normalizedRescaling (latticeWave a.cover a.beams hUD n i.1 i.2) S n s
+        (a.latticeSigma hUD n x) x z-a.latticePlaneWaveCoefficient hUD n x s i z) v‖^2
+  have hm' : ∑ i ∈ Finset.univ.filter P, err i ≤ e/2 := by
+    have hh := hm x hx s hs v hv k.val (by omega)
+    convert hh using 1
+    apply Finset.sum_congr rfl
+    intro i hi
+    have hp := (Finset.mem_filter.mp hi).2
+    dsimp only [P] at hp
+    simp only [err,latticePlaneWaveCoefficient,ite_eq_left hp]
+  have ht' : ∑ i ∈ Finset.univ.filter (fun i ↦ ¬P i), err i ≤ e/2 := by
+    have hh := ht x hx s hs v hv k
+    convert hh using 1
+    · apply Finset.sum_congr
+      · ext i; simp only [P,Finset.mem_filter,not_le]
+      · intro i hi
+        have hp := (Finset.mem_filter.mp hi).2
+        simp only [err,latticePlaneWaveCoefficient,ite_eq_right (not_le.mpr hp),sub_zero]
+  have hsplit := Finset.sum_filter_add_sum_filter_not (s := Finset.univ) P err
+  change ∑ i, err i ≤ e
+  linarith
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeGaussianSmallBall.lean

@@ -0,0 +1,81 @@
+import OAI.Geometry.NodalSets.Waves.EuclideanGaussianSmallBall
+import OAI.Geometry.NodalSets.Waves.GaussianJet
+import OAI.Geometry.NodalSets.Waves.LatticeCovariance
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology ENNReal RealInnerProductSpace
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeSeededJet (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (seed : Coord → ℝ) (x : Coord)
+    (coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ) : JetSpace :=
+  letI := hfin
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  normalizedRealJet (fun z ↦ seed z+gaussianWaveField V coeff z) (n:ℝ) (S x) x
+
+lemma latticeSeededJet_inner (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (seed : Coord → ℝ) (x : Coord) (v : JetSpace)
+    (coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ) :
+    ⟪v,a.latticeSeededJet hUD n hfin seed x coeff⟫ =
+      a.latticeSeededRandomDual hUD n hfin seed x (v 0) (Fin.tail (WithLp.ofLp v)) coeff := by
+  let := hfin
+  unfold latticeSeededJet latticeSeededRandomDual
+  exact normalizedRealJet_inner
+    (fun z ↦ seed z + gaussianWaveField
+      (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+      coeff z) (n : ℝ) (S x) x v
+
+theorem actual_lattice_gaussian_small_ball (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ (seed : Coord → ℝ) (x : Coord), x ∈ Q → DifferentiableAt ℝ seed x →
+      ∀ r : ℝ, 0 ≤ r →
+        (gaussianPairs.map (a.latticeSeededJet hUD n hfin seed x)) {y | ‖y‖ ≤ r} ≤
+          ENNReal.ofReal ((12*(Real.sqrt (c/(n:ℝ)))⁻¹*r/Real.sqrt (2*Real.pi))^5) := by
+  obtain ⟨c,hc,hcov⟩ := a.actual_lattice_covariance_lower_bound hUD hU hUb hQ hQU
+  refine ⟨c,hc,?_⟩
+  filter_upwards [hcov,lattice_wave_estimates a.cover a.beams hUD,
+    eventually_gt_atTop (0:ℕ)] with n hn hw hnpos
+  obtain ⟨hfin,hbound⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro seed x hx hs r hr
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV : ∀ i, DifferentiableAt ℝ (V i) x := fun i ↦
+    ((hw i.1 i.2).1.differentiable (by simp)).differentiableAt
+  have hb (v : JetSpace) : c/(n:ℝ)*‖v‖^2 ≤
+      ‖(pairJetMap (jetWaveCoefficients V n (S x) x)).adjoint v‖^2 := by
+    have h := hbound seed x hx hs (v 0) (Fin.tail (WithLp.ofLp v))
+    have he : (fun coeff ↦ ⟪v,a.latticeSeededJet hUD n hfin seed x coeff⟫) =
+        a.latticeSeededRandomDual hUD n hfin seed x (v 0) (Fin.tail (WithLp.ofLp v)) := by
+      funext coeff
+      exact a.latticeSeededJet_inner hUD n hfin seed x v coeff
+    rw [← he] at h
+    change c/(n:ℝ)*((v 0)^2+∑ i : Fin 4, (v i.succ)^2) ≤
+      Var[fun coeff ↦ ⟪v,normalizedRealJet (fun y ↦ seed y+gaussianWaveField V coeff y)
+        (n:ℝ) (S x) x⟫; gaussianPairs] at h
+    rw [seeded_gaussian_jet_variance V seed n (S x) x hV hs v] at h
+    simpa only [EuclideanSpace.real_norm_sq_eq,Fin.sum_univ_succ] using h
+  have hl := seeded_gaussian_jet_law V seed n (S x) x hV hs
+  change gaussianPairs.map (a.latticeSeededJet hUD n hfin seed x) = _ at hl
+  rw [hl]
+  have h := gaussian_map_small_ball (pairJetMap (jetWaveCoefficients V n (S x) x))
+    (normalizedRealJet seed n (S x) x) (c/(n:ℝ)) r (by positivity) hr hb
+  convert h using 1
+  norm_num
+  congr 2
+  ring
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeGeometry.lean

@@ -0,0 +1,74 @@
+import Mathlib.Algebra.Order.Floor.Ring
+import Mathlib.Data.Int.Interval
+import OAI.Geometry.NodalSets.Waves.LatticeSourceWaves
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set
+noncomputable section
+
+lemma lattice_scale_pos {n : ℕ} (hn : 0 < n) : 0 < (n:ℝ)^(-1/2:ℝ) :=
+  Real.rpow_pos_of_pos (by exact_mod_cast hn) _
+
+lemma scaledLatticePoint_injective {n : ℕ} (hn : 0 < n) : Function.Injective (scaledLatticePoint n) := by
+  intro z w h
+  funext i
+  have hh := congrFun h i
+  change (n:ℝ)^(-1/2:ℝ)*(z i:ℝ) = (n:ℝ)^(-1/2:ℝ)*(w i:ℝ) at hh
+  exact_mod_cast mul_left_cancel₀ (ne_of_gt (lattice_scale_pos hn)) hh
+
+theorem finite_source_grid {U : Set Coord} (hU : Bornology.IsBounded U)
+    {n : ℕ} (hn : 0 < n) : Finite (SourceGrid U n) := by
+  obtain ⟨B,hB,hbound⟩ := hU.exists_pos_norm_le
+  let r : ℝ := (n:ℝ)^(-1/2:ℝ)
+  have hr : 0 < r := lattice_scale_pos hn
+  let M : ℤ := ⌈B/r⌉
+  have hcoords (z : SourceGrid U n) (i : Fin 4) : z.val i ∈ Icc (-M) M := by
+    have hi := (norm_le_pi_norm (scaledLatticePoint n z) i).trans (hbound _ z.property)
+    change |r*(z.val i:ℝ)| ≤ B at hi
+    rw [abs_mul,abs_of_pos hr] at hi
+    have ha : |(z.val i:ℝ)| ≤ B/r := (le_div_iff₀ hr).mpr (by nlinarith)
+    have hM : B/r ≤ (M:ℝ) := Int.le_ceil _
+    have hpair := abs_le.mp (ha.trans hM)
+    constructor
+    · exact_mod_cast hpair.1
+    · exact_mod_cast hpair.2
+  let f : SourceGrid U n → (Fin 4 → Icc (-M) M) := fun z i ↦ ⟨z.val i,hcoords z i⟩
+  apply Finite.of_injective f
+  intro z w h
+  apply Subtype.ext
+  funext i
+  exact congrArg Subtype.val (congrFun h i)
+
+def roundedLatticeIndex (n : ℕ) (x : Coord) : Fin 4 → ℤ :=
+  fun i ↦ ⌊x i / (n:ℝ)^(-1/2:ℝ)⌋
+
+theorem rounded_lattice_distance {n : ℕ} (hn : 0 < n) (x : Coord) :
+    sourceEuclideanNorm (scaledLatticePoint n (roundedLatticeIndex n x)-x) ≤
+      2*(n:ℝ)^(-1/2:ℝ) := by
+  let r : ℝ := (n:ℝ)^(-1/2:ℝ)
+  have hr : 0 < r := lattice_scale_pos hn
+  have hb : ‖scaledLatticePoint n (roundedLatticeIndex n x)-x‖ ≤ r := by
+    apply (pi_norm_le_iff_of_nonneg hr.le).mpr
+    intro i
+    have h1 := Int.floor_le (x i/r)
+    have h2 := Int.lt_floor_add_one (x i/r)
+    have h1' := mul_le_mul_of_nonneg_left h1 hr.le
+    have h2' := mul_lt_mul_of_pos_left h2 hr
+    have he : r*(x i/r) = x i := by field_simp
+    rw [he] at h1' h2'
+    change |r*(⌊x i/r⌋:ℝ)-x i| ≤ r
+    apply abs_le.mpr
+    constructor <;> nlinarith
+  exact (sourceEuclideanNorm_le _).trans (by dsimp [r] at hb ⊢; linarith)
+
+theorem rounded_lattice_mem {U : Set Coord} {n : ℕ} (hn : 0 < n) (x : Coord)
+    (hball : {y | sourceEuclideanNorm (y-x) ≤ 2*(n:ℝ)^(-1/2:ℝ)} ⊆ U) :
+    scaledLatticePoint n (roundedLatticeIndex n x) ∈ U :=
+  hball (rounded_lattice_distance hn x)
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeGoodEvent.lean

@@ -0,0 +1,58 @@
+import OAI.Geometry.NodalSets.Elliptic.FirstJetGoodEvent
+import OAI.Geometry.NodalSets.Elliptic.FirstJetNonvanishing
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+    {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeGoodEvent (hUD : U ⊆ D) (n : ℕ) (hfin : Fintype (SourceGrid U n))
+    (S0 T0 : Coord → ℝ) (Ω : Set Coord) : Set (((SourceGrid U n × Fin 3) × Fin 2) → ℝ) :=
+  letI := hfin
+  coefficientJetGoodEvent
+    (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+    (oscillatorySeed S0 T0 n) n Ω
+    (fun x ↦ ((n:ℝ)^65)⁻¹*max (Real.exp ((n:ℝ)*S x)) (Real.exp ((n:ℝ)*S0 x)))
+
+theorem lattice_good_event_probability (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) (hS : ContDiff ℝ ∞ S)
+    (S0 T0 : Coord → ℝ) (hS0 : ContDiff ℝ ∞ S0) (hT0 : ContDiff ℝ ∞ T0)
+    {Ω : Set Coord} (hΩ : IsCompact Ω) (hk0 : 2 ≤ k0)
+    (hq : ∀ x ∈ Ω, fderiv ℝ T0 x ≠ 0)
+    {d : ℝ} (hd : 0 < d) (hgap : ∀ x ∈ Ω, x ∉ U → S x-S0 x ≤ -d) :
+    ∀ ε : ℝ, 0 < ε → ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      MeasurableSet (a.latticeGoodEvent hUD n hfin S0 T0 Ω) ∧
+      gaussianPairs (a.latticeGoodEvent hUD n hfin S0 T0 Ω)ᶜ ≤ ENNReal.ofReal ε := by
+  intro ε hε
+  obtain ⟨C,hC,hcoeff⟩ := lattice_coefficient_event_failure hUb
+  have htail := (tendsto_coefficient_tail_rate C).eventually (gt_mem_nhds (by linarith : 0 < ε/2))
+  filter_upwards [a.source_first_jet_failure_tends_zero hUD hU hUb hS S0 T0 hS0 hT0
+    hΩ hk0 hq hd hgap (ε/2) (by linarith),htail,a.estimates,eventually_gt_atTop (0:ℕ)] with n hn ht he hn0
+  obtain ⟨hfin,hjet⟩ := hn
+  let := hfin
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (he (latticeFrame a.cover hUD n i.1,i.2)).1
+  refine ⟨hfin,coefficientJetGoodEvent_measurable V (oscillatorySeed S0 T0 n)
+    hV (oscillatorySeed_contDiff S0 T0 hS0 hT0 n) n Ω _,?_⟩
+  apply (coefficientJetGoodEvent_failure_le V (oscillatorySeed S0 T0 n) n Ω _).trans
+  calc
+    _ ≤ ENNReal.ofReal (ε/2)+ENNReal.ofReal (ε/2) :=
+      add_le_add ((hcoeff n hn0 hfin).trans (ENNReal.ofReal_le_ofReal ht.le)) hjet
+    _ = ENNReal.ofReal ε := by
+      rw [← ENNReal.ofReal_add (by linarith : 0 ≤ ε/2) (by linarith : 0 ≤ ε/2)]
+      congr 1
+      ring
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeGradientExpectation.lean

@@ -0,0 +1,48 @@
+import OAI.Geometry.NodalSets.Elliptic.RescaledGradientExpectation
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_gradient_expectation
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ C > 0, ∀ (w S S0 T0 : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+      (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+      U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+      ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 → 5 ≤ k0 →
+      ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+      ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+        ∀ x ∈ Q, ∃ G : ((SourceGrid U n × Fin 3) × Fin 2 → ℝ) → ℝ,
+          Continuous G ∧ Integrable G gaussianPairs ∧ (∀ coeff, 0 ≤ G coeff) ∧
+          (∫ coeff, G coeff ∂gaussianPairs) ≤ C ∧
+          ∀ coeff L, 0 ≤ L →
+            (G coeff ≤ L ↔ ∀ v : Coord, sourceEuclideanNorm v ≤ 1 →
+              sourceEuclideanNorm (fun j ↦ fderiv ℝ (rescaledGaussianField
+                (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+                S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x coeff)
+                  v (Pi.single j 1)) ≤ L) := by
+  obtain ⟨B,hB,hmom⟩ := lattice_derivative_second_moments g hH hg hp 5
+  refine ⟨648*(B+1),by positivity,?_⟩
+  intro w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 hd gamma hgamma hgap
+  filter_upwards [hmom w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+    hS hS0 hT0 hd gamma hgamma hgap,a.estimates] with n hn hest
+  obtain ⟨hfin,hn⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (hest (latticeFrame a.cover hUD n i.1,i.2)).1
+  exact rescaled_gradient_supremum_expectation V hV S0 T0 S hS0 hT0
+    n (sourceSignScale g S x) (a.latticeSigma hUD n x) x hB.le
+    (fun v hv k hk dirs hd ↦ (hn x hx v hv k hk dirs hd).2)
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeLogJets.lean

@@ -0,0 +1,44 @@
+import OAI.Geometry.NodalSets.Elliptic.LocalLogJetBounds
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeEta (hUD : U ⊆ D) (n : ℕ) (z : SourceGrid U n) (j : Fin 3) : ℝ :=
+  a.originalEta (latticeFrame a.cover hUD n z,j)
+
+theorem lattice_logarithmic_jet_estimates (hUD : U ⊆ D) (L : ℝ) (hL : 0 < L) :
+    ∃ Ca > 0, ∃ Cr > 0, ∃ Ci > 0, ∃ c > 0, ∃ C > 0,
+      ∀ᶠ n : ℕ in atTop, ∀ (z : SourceGrid U n) (j : Fin 3) (x : Coord),
+      ‖x-scaledLatticePoint n z‖ ≤ L*(n:ℝ)^(-1/2:ℝ) →
+      let t := (latticeFrame a.cover hUD n z,j)
+      let V := latticeWave a.cover a.beams hUD n z j
+      ‖a.beams.amplitude n t x-1‖ ≤ Ca*(n:ℝ)^(-1/2:ℝ) ∧
+      (1/2:ℝ) ≤ ‖a.beams.amplitude n t x‖ ∧ ‖a.beams.amplitude n t x‖ ≤ 3/2 ∧ V x ≠ 0 ∧
+      (c ≤ ‖V x‖*Real.exp (-(n:ℝ)*S x) ∧ ‖V x‖*Real.exp (-(n:ℝ)*S x) ≤ C) ∧
+      ∀ v,
+      |(normalizedLogJet n V x v).re -
+        (fderiv ℝ S x v-a.latticeEta hUD n z j*g (scaledLatticePoint n z) (x-scaledLatticePoint n z) v)| ≤ Cr/n*‖v‖ ∧
+      |(normalizedLogJet n V x v).im - g (scaledLatticePoint n z) (a.cover.triple.q t.1 t.2) v| ≤
+        Ci*(n:ℝ)^(-1/2:ℝ)*‖v‖ := by
+  obtain ⟨Ca,hCa,Cr,hCr,Ci,hCi,c,hc,C,hC,hb⟩ := a.original_logarithmic_jet_estimates L hL
+  refine ⟨Ca,hCa,Cr,hCr,Ci,hCi,c,hc,C,hC,?_⟩
+  filter_upwards [hb] with n hn
+  intro z j x hx
+  have hx' : ‖x-coverSourceCenter a.cover (latticeFrame a.cover hUD n z)‖ ≤ L*(n:ℝ)^(-1/2:ℝ) := by
+    simpa only [latticeFrame_center] using hx
+  simpa only [latticeWave,TripleSourceWaveData.wave,latticeEta,latticeFrame_center] using
+    hn (latticeFrame a.cover hUD n z,j) x hx'
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeMainLogJets.lean

@@ -0,0 +1,66 @@
+import OAI.Geometry.NodalSets.Elliptic.LocalMainLogJets
+import OAI.Geometry.NodalSets.Elliptic.ShiftedCenterDistance
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+
+lemma eventually_shifted_main_distance (R : ℝ) :
+    ∀ᶠ n : ℕ in atTop, ∀ (s : ℝ), 1 ≤ s → ∀ (x y v : Coord), ‖v‖ ≤ R →
+      sourceEuclideanNorm (x-y) ≤ (n:ℝ)^(-5/12:ℝ) →
+      ‖x+((n:ℝ)*s)⁻¹ • v-y‖ ≤ 2*(n:ℝ)^(-5/12:ℝ) := by
+  have ht : Tendsto (fun n : ℕ ↦ (n:ℝ)^(7/12:ℝ)) atTop atTop :=
+    (tendsto_rpow_atTop (by norm_num : (0:ℝ) < 7/12)).comp tendsto_natCast_atTop_atTop
+  filter_upwards [ht.eventually (eventually_ge_atTop R),eventually_gt_atTop (0:ℕ)]
+    with n hn hnpos
+  intro s hs x y v hv hnear
+  have hn0 : (0:ℝ) < n := by exact_mod_cast hnpos
+  have hn1 : (1:ℝ) ≤ n := by exact_mod_cast hnpos
+  have hd := rescaling_displacement_bound (x := x) hn1 hs hv
+  rw [← main_radius_times_frequency hn0] at hn
+  have hshift : ‖(x+((n:ℝ)*s)⁻¹ • v)-x‖ ≤ (n:ℝ)^(-5/12:ℝ) := by nlinarith
+  have hxy := (norm_le_sourceEuclideanNorm _).trans hnear
+  have he : x+((n:ℝ)*s)⁻¹ • v-y =
+      (x+((n:ℝ)*s)⁻¹ • v-x)+(x-y) := by abel
+  rw [he]
+  exact (norm_add_le _ _).trans (by linarith)
+
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_shifted_main_log_jets (hUD : U ⊆ D) (R : ℝ) :
+    ∃ Ca > 0, ∃ Cr > 0, ∃ Ci > 0,
+      ∀ᶠ n : ℕ in atTop, ∀ (x : Coord) (s : ℝ), 1 ≤ s →
+      ∀ (v : Coord), ‖v‖ ≤ R → ∀ (i : SourceGrid U n × Fin 3),
+      sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ) →
+      let t := (latticeFrame a.cover hUD n i.1,i.2)
+      let z := x+((n:ℝ)*s)⁻¹ • v
+      ‖(a.beams.F t).symm z‖ < (n:ℝ)^(-1/3:ℝ) ∧
+      ‖a.beams.amplitude n t z-1‖ ≤ Ca*(n:ℝ)^(-5/12:ℝ) ∧
+      (1/2:ℝ) ≤ ‖a.beams.amplitude n t z‖ ∧ ‖a.beams.amplitude n t z‖ ≤ 3/2 ∧
+      latticeWave a.cover a.beams hUD n i.1 i.2 z ≠ 0 ∧ ∀ u,
+      |(normalizedLogJet n (latticeWave a.cover a.beams hUD n i.1 i.2) z u).re -
+        (fderiv ℝ S z u-a.originalEta t*g (scaledLatticePoint n i.1)
+          (z-scaledLatticePoint n i.1) u)| ≤ Cr*(n:ℝ)^(-5/6:ℝ)*‖u‖ ∧
+      |(normalizedLogJet n (latticeWave a.cover a.beams hUD n i.1 i.2) z u).im -
+        g (scaledLatticePoint n i.1) (a.cover.triple.q t.1 t.2) u| ≤
+          Ci*(n:ℝ)^(-5/12:ℝ)*‖u‖ := by
+  obtain ⟨Ca,hCa,Cr,hCr,Ci,hCi,hjets⟩ := a.original_main_logarithmic_jet_estimates 2 (by norm_num)
+  refine ⟨Ca,hCa,Cr,hCr,Ci,hCi,?_⟩
+  filter_upwards [hjets,eventually_shifted_main_distance R] with n hj hd
+  intro x s hs v hv i hi
+  have hz := hd s hs x (scaledLatticePoint n i.1) v hv hi
+  have hh := hj (latticeFrame a.cover hUD n i.1,i.2) (x+((n:ℝ)*s)⁻¹ • v)
+    (by simpa only [latticeFrame_center] using hz)
+  simpa only [latticeFrame_center,latticeWave,TripleSourceWaveData.wave] using hh
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeNeighborhoodJets.lean

@@ -0,0 +1,76 @@
+import Mathlib.Analysis.Calculus.MeanValue
+import OAI.Geometry.NodalSets.Elliptic.NeighborhoodJetBound
+import OAI.Geometry.NodalSets.Waves.LatticeGaussianSmallBall
+import OAI.Geometry.NodalSets.Waves.SeededLatticeFieldBounds
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_neighborhood_jet_bound (hUD : U ⊆ D) (hUb : Bornology.IsBounded U)
+    (hS : ContDiff ℝ ∞ S) (S0 T0 : Coord → ℝ)
+    (hS0 : ContDiff ℝ ∞ S0) (hT0 : ContDiff ℝ ∞ T0)
+    {Ω : Set Coord} (hΩ : IsCompact Ω) (hk0 : 2 ≤ k0) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ,
+        coeff ∈ coefficientEvent (n:ℝ) →
+        ∀ x ∈ highEnvelopeRegion Ω S S0 n,
+          ∀ z ∈ Metric.closedBall x ((n:ℝ)^2)⁻¹,
+            ‖fderiv ℝ (fun y ↦ a.latticeSeededJet hUD n hfin
+              (oscillatorySeed S0 T0 n) y coeff) z‖ ≤ (n:ℝ)^13 := by
+  obtain ⟨R,hR,hΩR⟩ := hΩ.isBounded.exists_pos_norm_le
+  let Q := Metric.closedBall (0:Coord) (R+1)
+  have hQ : IsCompact Q := isCompact_closedBall _ _
+  obtain ⟨A,hA,hAb⟩ := (hQ.image (hS.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le
+  have hdS : ContDiff ℝ ∞ (fun z ↦ S0 z-S z) := hS0.sub hS
+  obtain ⟨L,hL,hLb⟩ := (hQ.image (hdS.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le
+  obtain ⟨B,hB,hfield⟩ := a.seeded_lattice_field_derivative_bound hUD hUb S0 T0 hS0 hT0 hQ
+  have hfreq : ∀ᶠ n : ℕ in atTop, max L (6*(A+1)*B*Real.exp 1) ≤ (n:ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  filter_upwards [hfield,hfreq,eventually_gt_atTop (0:ℕ)] with n hn hsize hnpos
+  obtain ⟨hfin,hb⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro coeff hc x hx z hz
+  obtain ⟨hu,hbnd⟩ := hb coeff hc
+  have hn1 : (1:ℝ) ≤ n := by exact_mod_cast hnpos
+  have hnR : (0:ℝ) < n := by exact_mod_cast hnpos
+  have hdist : ‖z-x‖ ≤ ((n:ℝ)^2)⁻¹ := by simpa only [Metric.mem_closedBall,dist_eq_norm] using hz
+  have hrad : ((n:ℝ)^2)⁻¹ ≤ 1 :=
+    (inv_le_one₀ (by positivity)).mpr (one_le_pow₀ hn1)
+  have hxQ : x ∈ Q := by
+    change dist x 0 ≤ R+1
+    rw [dist_zero_right]
+    linarith [hΩR x hx.1]
+  have hzQ : z ∈ Q := by
+    change dist z 0 ≤ R+1
+    rw [dist_zero_right]
+    have ht := norm_le_norm_sub_add z x
+    linarith [hΩR x hx.1,hdist.trans hrad]
+  have hgap : (S0 z-S z)-(S0 x-S x) ≤ L*‖z-x‖ := by
+    have h := (convex_closedBall (0:Coord) (R+1)).norm_image_sub_le_of_norm_fderiv_le
+      (fun _ _ ↦ (hdS.differentiable (by simp)).differentiableAt)
+      (fun y hy ↦ hLb _ ⟨y,hy,rfl⟩) hxQ hzQ
+    exact (le_abs_self _).trans h
+  have h := normalized_jet_neighborhood_derivative_bound
+    (fun y ↦ oscillatorySeed S0 T0 n y+gaussianWaveField
+      (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff y)
+    S S0 hu hS hnpos hx hA.le hB.le hL.le
+    ((le_max_left _ _).trans hsize) ((le_max_right _ _).trans hsize)
+    hdist hgap (hAb _ ⟨z,hzQ,rfl⟩)
+    (fun k ↦ hbnd z hzQ ⟨k.val,by omega⟩)
+  exact h
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeNetSmallBall.lean

@@ -0,0 +1,79 @@
+import OAI.Geometry.NodalSets.Elliptic.SpatialNet
+import OAI.Geometry.NodalSets.Waves.LatticeGaussianSmallBall
+import OAI.Geometry.NodalSets.Waves.NetProbability
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology ENNReal
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+lemma measurable_latticeSeededJet (hUD : U ⊆ D) (n : ℕ)
+    (hfin : Fintype (SourceGrid U n)) (seed : Coord → ℝ) (x : Coord)
+    (hs : DifferentiableAt ℝ seed x)
+    (hV : ∀ z j, DifferentiableAt ℝ (latticeWave a.cover a.beams hUD n z j) x) :
+    Measurable (a.latticeSeededJet hUD n hfin seed x) := by
+  let := hfin
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have he : a.latticeSeededJet hUD n hfin seed x = fun coeff ↦
+      normalizedRealJet seed n (S x) x +
+        pairJetMap (jetWaveCoefficients V n (S x) x) (WithLp.toLp 2 coeff) := by
+    funext coeff
+    exact seeded_gaussian_jet_eq V seed n (S x) x (fun i ↦ hV i.1 i.2) hs coeff
+  rw [he]
+  fun_prop
+
+theorem actual_lattice_net_small_ball (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ E : Set Coord, E ⊆ Q → ∃ t : Finset Coord,
+        (↑t : Set Coord) ⊆ E ∧ (t.card : ℝ) ≤ C*(n:ℝ)^276 ∧
+        (∀ x ∈ E, ∃ y ∈ t, ‖x-y‖ ≤ (4*(n:ℝ)^69)⁻¹ ∧
+          sourceEuclideanNorm (x-y) ≤ (2*(n:ℝ)^69)⁻¹) ∧
+        ∀ seed : Coord → ℝ, (∀ x ∈ Q, DifferentiableAt ℝ seed x) →
+          gaussianPairs {coeff | ∃ x ∈ t,
+            ‖a.latticeSeededJet hUD n hfin seed x coeff‖ ≤ 2/(n:ℝ)^56} ≤
+          ENNReal.ofReal (C*(n:ℝ)^276*
+            (12*(Real.sqrt (c/(n:ℝ)))⁻¹*(2/(n:ℝ)^56)/Real.sqrt (2*Real.pi))^5) := by
+  obtain ⟨c,hc,hsmall⟩ := a.actual_lattice_gaussian_small_ball hUD hU hUb hQ hQU
+  obtain ⟨C,hC,hnet⟩ := jet_scale_internal_net hQ.isBounded
+  refine ⟨c,hc,C,hC,?_⟩
+  filter_upwards [hsmall,lattice_wave_estimates a.cover a.beams hUD,
+    eventually_gt_atTop (0:ℕ)] with n hn hw hnpos
+  obtain ⟨hfin,hp⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro E hEQ
+  obtain ⟨t,ht,hcard,hcover⟩ := hnet n hnpos E hEQ
+  refine ⟨t,ht,hcard,hcover,?_⟩
+  intro seed hs
+  let b := (12*(Real.sqrt (c/(n:ℝ)))⁻¹*(2/(n:ℝ)^56)/Real.sqrt (2*Real.pi))^5
+  have hb : 0 ≤ b := by dsimp [b]; positivity
+  have hp' (x : Coord) (hx : x ∈ t) :
+      gaussianPairs {coeff | ‖a.latticeSeededJet hUD n hfin seed x coeff‖ ≤ 2/(n:ℝ)^56} ≤
+        ENNReal.ofReal b := by
+    have hxQ := hEQ (ht hx)
+    have h := hp seed x hxQ (hs x hxQ) (2/(n:ℝ)^56) (by positivity)
+    rw [Measure.map_apply (a.measurable_latticeSeededJet hUD n hfin seed x (hs x hxQ)
+      (fun z j ↦ ((hw z j).1.differentiable (by simp)).differentiableAt))
+      (measurableSet_le (by fun_prop) measurable_const)] at h
+    exact h
+  have hu := finite_small_ball_union gaussianPairs t
+    (fun coeff x ↦ a.latticeSeededJet hUD n hfin seed x coeff)
+    (2/(n:ℝ)^56) (ENNReal.ofReal b) hp'
+  refine hu.trans ?_
+  rw [ENNReal.ofReal_mul (by positivity)]
+  gcongr
+  exact_mod_cast (ENNReal.ofReal_le_ofReal hcard)
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeNonmainDecay.lean

@@ -0,0 +1,72 @@
+import OAI.Geometry.NodalSets.Waves.LatticeNormalizedWeights
+
+namespace OAI
+
+namespace Yau.Probability
+open Filter
+open scoped Topology
+
+lemma tendsto_polynomial_main_center_tail (k : ℕ) (a : ℝ) (ha : 0 < a) :
+    Tendsto (fun n : ℕ ↦ (n:ℝ)^k*Real.exp (-a*(n:ℝ)^(1/6:ℝ))) atTop (𝓝 0) := by
+  have hpow : Tendsto (fun n : ℕ ↦ (n:ℝ)^(1/6:ℝ)) atTop atTop :=
+    (tendsto_rpow_atTop (by norm_num : (0:ℝ) < 1/6)).comp tendsto_natCast_atTop_atTop
+  have ht := (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (6*(k:ℝ)) a ha).comp hpow
+  convert ht using 1
+  funext n
+  simp only [Function.comp_def]
+  rw [← Real.rpow_mul (by positivity : (0:ℝ) ≤ n)]
+  rw [show (1/6:ℝ)*(6*(k:ℝ)) = (k:ℝ) by ring,Real.rpow_natCast]
+
+end Yau.Probability
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_nonmain_derivatives_negligible (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+      ∀ x ∈ Q, ∀ k : Fin (k0+1),
+        (∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+          (n:ℝ)^(-5/12:ℝ) < sourceEuclideanNorm (x-scaledLatticePoint n i.1)),
+          ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2) /
+          (a.latticeSigma hUD n x)^2 ≤ ε := by
+  classical
+  obtain ⟨c,hc,hlo⟩ := a.lattice_variance_lower_bound hUD hU hQ hQU
+  obtain ⟨C,hC,htail⟩ := a.lattice_nonmain_derivative_bound hUD
+  have hlim := (tendsto_polynomial_main_center_tail (2*k0) a.beams.c a.beams.c_pos).const_mul (C/c)
+  simp only [mul_zero] at hlim
+  filter_upwards [hlo,htail,hlim.eventually (gt_mem_nhds hε),eventually_gt_atTop (0:ℕ)]
+    with n hl ht hsmall hnpos
+  have := finite_source_grid hUb hnpos
+  let hfin := Fintype.ofFinite (SourceGrid U n)
+  refine ⟨hfin,?_⟩
+  intro x hx k
+  have hv : 0 < a.latticeVariance hUD n x :=
+    lt_of_lt_of_le (mul_pos hc (Real.exp_pos _)) (hl x hx)
+  have hn1 : (1:ℝ) ≤ n := by exact_mod_cast hnpos
+  have hp : (n:ℝ)^(2*k.val) ≤ (n:ℝ)^(2*k0) :=
+    pow_le_pow_right₀ hn1 (by have := k.isLt; omega)
+  rw [a.latticeSigma_sq]
+  apply le_trans _ hsmall.le
+  apply (div_le_iff₀ hv).mpr
+  have hh := mul_le_mul_of_nonneg_left (hl x hx)
+    (by positivity : 0 ≤ (C/c)*((n:ℝ)^(2*k0)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ))))
+  calc
+    _ ≤ C*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)) := ht x k
+    _ ≤ C*(n:ℝ)^(2*k0)*Real.exp (2*(n:ℝ)*S x)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)) := by gcongr
+    _ = ((C/c)*((n:ℝ)^(2*k0)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ))))*
+        (c*Real.exp (2*(n:ℝ)*S x)) := by field_simp
+    _ ≤ _ := hh
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeNormalizedWeights.lean

@@ -0,0 +1,94 @@
+import OAI.Geometry.NodalSets.Waves.LatticeDerivativeTail
+import OAI.Geometry.NodalSets.Waves.LatticeVarianceComparison
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeAlpha (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x : Coord) (i : SourceGrid U n × Fin 3) : ℂ :=
+  latticeWave a.cover a.beams hUD n i.1 i.2 x / (a.latticeSigma hUD n x:ℂ)
+
+lemma latticeAlpha_sum_sq (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x : Coord) (s : Finset (SourceGrid U n × Fin 3)) :
+    ∑ i ∈ s, ‖a.latticeAlpha hUD n x i‖^2 =
+      (∑ i ∈ s, ‖latticeWave a.cover a.beams hUD n i.1 i.2 x‖^2) / a.latticeVariance hUD n x := by
+  simp only [latticeAlpha,norm_div,Complex.norm_real,Real.norm_eq_abs,
+    abs_of_nonneg (show 0 ≤ a.latticeSigma hUD n x from Real.sqrt_nonneg _),
+    div_pow,a.latticeSigma_sq,Finset.sum_div]
+
+lemma latticeAlpha_total (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x : Coord) (hv : 0 < a.latticeVariance hUD n x) :
+    ∑ i, ‖a.latticeAlpha hUD n x i‖^2 = 1 := by
+  rw [a.latticeAlpha_sum_sq]
+  exact div_self hv.ne'
+
+theorem latticeAlpha_nonmain_bound (hUD : U ⊆ D) (hU : IsOpen U)
+    {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x ∈ Q,
+      0 < a.latticeVariance hUD n x ∧
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+          (n:ℝ)^(-5/12:ℝ) < sourceEuclideanNorm (x-scaledLatticePoint n i.1)),
+        ‖a.latticeAlpha hUD n x i‖^2 ≤ C*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)) := by
+  classical
+  obtain ⟨c,hc,hlo⟩ := a.lattice_variance_lower_bound hUD hU hQ hQU
+  obtain ⟨C,hC,htail⟩ := a.lattice_nonmain_derivative_bound hUD
+  refine ⟨C/c,div_pos hC hc,?_⟩
+  filter_upwards [hlo,htail] with n hl ht
+  intro hfin x hx
+  have hv : 0 < a.latticeVariance hUD n x :=
+    lt_of_lt_of_le (mul_pos hc (Real.exp_pos _)) (hl x hx)
+  refine ⟨hv,?_⟩
+  rw [a.latticeAlpha_sum_sq]
+  apply (div_le_iff₀ hv).mpr
+  have h := ht x (0 : Fin (k0+1))
+  simp only [Fin.val_zero,mul_zero,pow_zero,mul_one] at h
+  change (∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+      (n:ℝ)^(-5/12:ℝ) < sourceEuclideanNorm (x-scaledLatticePoint n i.1)),
+    ‖iteratedFDeriv ℝ 0 (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2) ≤ _ at h
+  simp only [norm_iteratedFDeriv_zero] at h
+  refine h.trans ?_
+  have hh := mul_le_mul_of_nonneg_left (hl x hx)
+    (by positivity : 0 ≤ (C/c)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)))
+  calc
+    _ = ((C/c)*Real.exp (-a.beams.c*(n:ℝ)^(1/6:ℝ)))*(c*Real.exp (2*(n:ℝ)*S x)) := by field_simp
+    _ ≤ _ := hh
+
+theorem latticeAlpha_main_mass (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+      ∀ x ∈ Q, (∑ i, ‖a.latticeAlpha hUD n x i‖^2 = 1) ∧
+        1-ε ≤ ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+          sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ)),
+          ‖a.latticeAlpha hUD n x i‖^2 := by
+  classical
+  obtain ⟨C,hC,hb⟩ := a.latticeAlpha_nonmain_bound hUD hU hQ hQU
+  have hlim := (tendsto_main_center_tail a.beams.c a.beams.c_pos).const_mul C
+  simp only [mul_zero] at hlim
+  filter_upwards [hb,hlim.eventually (gt_mem_nhds hε),eventually_gt_atTop (0:ℕ)] with n hn hsmall hnpos
+  have := finite_source_grid hUb hnpos
+  let hfin := Fintype.ofFinite (SourceGrid U n)
+  refine ⟨hfin,?_⟩
+  intro x hx
+  obtain ⟨hv,ht⟩ := hn x hx
+  have hall := a.latticeAlpha_total hUD n x hv
+  refine ⟨hall,?_⟩
+  have he := Finset.sum_filter_add_sum_filter_not (s := (Finset.univ : Finset (SourceGrid U n × Fin 3)))
+    (fun i ↦ sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ))
+    (fun i ↦ ‖a.latticeAlpha hUD n x i‖^2)
+  simp only [not_le,hall] at he
+  linarith
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticePhysicalSignSubballs.lean

@@ -0,0 +1,71 @@
+import OAI.Geometry.NodalSets.Elliptic.CompactSignEvents
+import OAI.Geometry.NodalSets.Elliptic.RescaledSignTransfer
+import OAI.Geometry.NodalSets.Waves.LatticeSignSubballs
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_physical_sign_subballs
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ r : ℝ, 0 < r ∧
+      r < tau/4 ∧ r < (1-tau)/2 ∧ ∃ p : ℝ, 0 < p ∧
+      ∀ (w S S0 T0 : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+        ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 → 5 ≤ k0 →
+        ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∀ x ∈ Q, ∃ j : Fin 4,
+            let scale := (n:ℝ)*sourceSignScale g S x
+            let f := fun coeff y ↦ oscillatorySeed S0 T0 n y + gaussianWaveField
+              (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff y
+            let A : Set (((SourceGrid U n × Fin 3) × Fin 2) → ℝ) := {coeff |
+              (∀ y : Coord, sourceEuclideanNorm (y-x) ≤ r/scale → 0 < f coeff y) ∧
+              (∀ y : Coord, sourceEuclideanNorm (y-(x+scale⁻¹ • (tau • Pi.single j 1))) ≤ r/scale →
+                f coeff y < 0)}
+            0 < scale ∧ MeasurableSet A ∧ p ≤ gaussianPairs.real A := by
+  obtain ⟨tau,ht,ht4,r,hr,hrt,hr1,p,hp0,hprob⟩ := lattice_sign_subballs_probability g hH hg hp
+  refine ⟨tau,ht,ht4,r,hr,hrt,hr1,p,hp0,?_⟩
+  intro w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 hd gamma hgamma hgap
+  obtain ⟨c,hc,C,hC,hsigma⟩ := a.lattice_sigma_comparison hUD hU hUb hQ hQU
+  filter_upwards [hprob w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+    hS hS0 hT0 hd gamma hgamma hgap,hsigma,eventually_gt_atTop (0:ℕ),a.estimates] with n hn hs hn0 hest
+  obtain ⟨hfin,hn⟩ := hn
+  obtain ⟨hfin',hs⟩ := hs
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  let : IsProbabilityMeasure (gaussianPairs (ι := SourceGrid U n × Fin 3)) := by
+    unfold gaussianPairs; infer_instance
+  refine ⟨hfin,?_⟩
+  intro x hx
+  obtain ⟨j,hj⟩ := hn x hx
+  have hsc : 0 < (n:ℝ)*sourceSignScale g S x := mul_pos (by exact_mod_cast hn0)
+    (lt_of_lt_of_le (by norm_num : (0:ℝ) < 2) (a.source_sign_scale_lower x (hUD (hQU hx))))
+  have hsig : 0 < a.latticeSigma hUD n x :=
+    (mul_pos hc (Real.exp_pos _)).trans_le (hs x hx).1
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (hest (latticeFrame a.cover hUD n i.1,i.2)).1
+  have hmeas := seeded_gaussian_sign_balls_measurable V (oscillatorySeed S0 T0 n)
+    hV (oscillatorySeed_contDiff S0 T0 hS0 hT0 n)
+    x (x+((n:ℝ)*sourceSignScale g S x)⁻¹ • (tau • Pi.single j 1))
+    (r/((n:ℝ)*sourceSignScale g S x)) (r/((n:ℝ)*sourceSignScale g S x))
+  refine ⟨j,hsc,hmeas,hj.trans ?_⟩
+  apply measureReal_mono
+  · intro coeff hcoeff
+    exact rescaled_sign_subballs_transfer _ S0 T0 S n (sourceSignScale g S x)
+        (a.latticeSigma hUD n x) x coeff hsc hsig tau r j
+        (fun v hv ↦ (hcoeff.1 v hv).2) (fun v hv ↦ (hcoeff.2 v hv).2)
+  · exact measure_ne_top _ _
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticePlaneWaveEnergy.lean

@@ -0,0 +1,90 @@
+import OAI.Geometry.NodalSets.Elliptic.FrequencyDerivativeEnergy
+import OAI.Geometry.NodalSets.Waves.LatticeFrequencyAnnulus
+import OAI.Geometry.NodalSets.Waves.LatticeFullPlaneWaveApprox
+import OAI.Geometry.NodalSets.Waves.LatticeNormalizedWeights
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+namespace LocalCompactWaveData
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+lemma latticePlaneWaveCoefficient_smooth (hUD : U ⊆ D) (n : ℕ)
+    [Fintype (SourceGrid U n)] (x : Coord) (s : ℝ) (i : SourceGrid U n × Fin 3) :
+    ContDiff ℝ ∞ (a.latticePlaneWaveCoefficient hUD n x s i) := by
+  classical
+  unfold latticePlaneWaveCoefficient
+  split_ifs
+  · exact contDiff_const.mul (planeWave_smooth _ _)
+  · exact contDiff_const
+
+lemma latticePlaneWaveCoefficient_energy (hUD : U ⊆ D) (n : ℕ)
+    [Fintype (SourceGrid U n)] (x : Coord) (s : ℝ) {B : ℝ} (hB : 1 ≤ B)
+    (hm : ∑ i : SourceGrid U n × Fin 3, ‖a.latticeAlpha hUD n x i‖^2 ≤ 1)
+    (hb : ∀ i : SourceGrid U n × Fin 3,
+      sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ) →
+      sourceEuclideanNorm (sourceFrequency (g (scaledLatticePoint n i.1))
+        (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) s) ≤ B)
+    (k : ℕ) (v : Coord) :
+    ∑ i : SourceGrid U n × Fin 3,
+      ‖iteratedFDeriv ℝ k (a.latticePlaneWaveCoefficient hUD n x s i) v‖^2 ≤
+        (k.factorial*(4*B)^k)^2 := by
+  classical
+  have hbound (i : SourceGrid U n × Fin 3) :
+      ‖iteratedFDeriv ℝ k (a.latticePlaneWaveCoefficient hUD n x s i) v‖ ≤
+        ‖a.latticeAlpha hUD n x i‖*(k.factorial*(4*B)^k) := by
+    unfold latticePlaneWaveCoefficient
+    split_ifs with hi
+    · exact weighted_planeWave_derivative_bound _ _ s hB (hb i hi) k v
+    · simp only [iteratedFDeriv_fun_zero, Pi.zero_apply, norm_zero]
+      positivity
+  calc
+    _ ≤ ∑ i : SourceGrid U n × Fin 3,
+        (‖a.latticeAlpha hUD n x i‖*(k.factorial*(4*B)^k))^2 :=
+      Finset.sum_le_sum (fun i _ ↦ pow_le_pow_left₀ (norm_nonneg _) (hbound i) 2)
+    _ = (∑ i : SourceGrid U n × Fin 3, ‖a.latticeAlpha hUD n x i‖^2)*
+        (k.factorial*(4*B)^k)^2 := by simp only [mul_pow,Finset.sum_mul]
+    _ ≤ _ := by nlinarith [sq_nonneg ((k.factorial:ℝ)*(4*B)^k)]
+end LocalCompactWaveData
+
+theorem lattice_planeWave_derivative_energy
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) (d : ℕ) :
+    ∃ C > 0, ∀ (w S : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+      (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+      U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+      ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+        ∀ x ∈ Q, ∀ v : Coord, ∀ k : ℕ, k ≤ d →
+        ∑ i : SourceGrid U n × Fin 3,
+          ‖iteratedFDeriv ℝ k
+            (a.latticePlaneWaveCoefficient hUD n x (sourceSignScale g S x) i) v‖^2 ≤ C := by
+  obtain ⟨κ,hκ,B,hB,hann⟩ := lattice_main_frequency_annulus g hH hg hp
+  let B' := max 1 B
+  let C := ((d.factorial:ℝ)*(4*B')^d)^2
+  have hB' : 1 ≤ B' := le_max_left _ _
+  have h4 : 1 ≤ 4*B' := by linarith
+  refine ⟨C,by dsimp [C]; positivity,?_⟩
+  intro w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+  filter_upwards [hann w S D U m J K k0 a hHD hUD hUH,
+    a.latticeAlpha_main_mass hUD hU hUb hQ hQU (1/2) (by norm_num)] with n hn hm
+  obtain ⟨hfin,hm⟩ := hm
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx v k hk
+  apply (a.latticePlaneWaveCoefficient_energy hUD n x _ hB' (by rw [(hm x hx).1])
+    (fun i hi ↦ ((hn x (hUH (hQU hx)) i hi).2).trans (le_max_right _ _)) k v).trans
+  have hf : (k.factorial:ℝ) ≤ d.factorial := by exact_mod_cast Nat.factorial_le hk
+  have hpow := pow_le_pow_right₀ h4 hk
+  dsimp [C]
+  gcongr
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticePlaneWaveJets.lean

@@ -0,0 +1,73 @@
+import OAI.Geometry.NodalSets.Waves.LatticeNormalizedWeights
+import OAI.Geometry.NodalSets.Waves.PlaneWaveJets2
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_main_coefficient_jets (hUD : U ⊆ D) (R : ℝ) (hR : 0 ≤ R)
+    (d0 : ℕ) (e : ℝ) (he : 0 < e) :
+    ∀ᶠ n : ℕ in atTop, ∀ x ∈ D, ∀ s : ℝ, 1 ≤ s →
+      ∀ (sigma : ℝ) (v : Coord), ‖v‖ ≤ R → ∀ i : SourceGrid U n × Fin 3,
+      sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ) → ∀ k, k ≤ d0 →
+      ‖iteratedFDeriv ℝ k (fun z ↦ normalizedRescaling (latticeWave a.cover a.beams hUD n i.1 i.2) S n s sigma x z -
+        (latticeWave a.cover a.beams hUD n i.1 i.2 x/(sigma:ℂ))*
+          planeWave (g (scaledLatticePoint n i.1) (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2)) s z) v‖ ≤
+        e*‖latticeWave a.cover a.beams hUD n i.1 i.2 x/(sigma:ℂ)‖ := by
+  have hy := continuous_coverSourceCenter a.cover
+  have hp0 t := a.nonzero_gradient _ (a.cover.center t).property
+  filter_upwards [a.beams.uniform_main_coefficient_jets a.smooth_G a.positive_G
+    a.smooth_A hy hp0 R hR d0 e he] with n hn
+  intro x hx s hs sigma v hv i hi k hk
+  have hh := hn (latticeFrame a.cover hUD n i.1,i.2) x s hs
+    (by simpa only [latticeFrame_center] using hi) sigma v hv k hk
+  have hxA := (a.germ x (a.centers_E hx)).2.2
+  have hyG := (a.germ (scaledLatticePoint n i.1) (a.centers_E (hUD i.1.property))).1
+  simpa only [latticeFrame_center,hyG.self_of_nhds,latticeWave,TripleSourceWaveData.wave,
+    normalizedRescaling,rescaledSeedNormalizer,hxA.fderiv_eq] using hh
+
+theorem lattice_main_jet_approximation (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U)
+    (R : ℝ) (hR : 0 ≤ R) (d0 : ℕ) (e : ℝ) (he : 0 < e) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+      ∀ x ∈ Q, ∀ s : ℝ, 1 ≤ s → ∀ v : Coord, ‖v‖ ≤ R → ∀ k, k ≤ d0 →
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+        sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ)),
+        ‖iteratedFDeriv ℝ k (fun z ↦ normalizedRescaling (latticeWave a.cover a.beams hUD n i.1 i.2) S n s
+          (a.latticeSigma hUD n x) x z - a.latticeAlpha hUD n x i *
+          planeWave (g (scaledLatticePoint n i.1) (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2)) s z) v‖^2 ≤ e := by
+  classical
+  filter_upwards [a.lattice_main_coefficient_jets hUD R hR d0 (Real.sqrt e) (Real.sqrt_pos.mpr he),
+    a.latticeAlpha_main_mass hUD hU hUb hQ hQU 1 zero_lt_one] with n hn hmass
+  obtain ⟨hfin,hmass⟩ := hmass
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx s hs v hv k hk
+  let I := Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+    sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ))
+  have hsum : ∑ i ∈ I, ‖a.latticeAlpha hUD n x i‖^2 ≤ 1 := by
+    rw [← (hmass x hx).1]
+    exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun _ _ _ ↦ sq_nonneg _)
+  calc
+    _ ≤ ∑ i ∈ I, e*‖a.latticeAlpha hUD n x i‖^2 := by
+      apply Finset.sum_le_sum
+      intro i hi
+      have hb := hn x (hUD (hQU hx)) s hs (a.latticeSigma hUD n x) v hv i (Finset.mem_filter.mp hi).2 k hk
+      have hh := pow_le_pow_left₀ (norm_nonneg _) hb 2
+      rw [mul_pow,Real.sq_sqrt he.le] at hh
+      exact hh
+    _ = e*(∑ i ∈ I, ‖a.latticeAlpha hUD n x i‖^2) := by rw [Finset.mul_sum]
+    _ ≤ e := by nlinarith
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeProbabilityRates.lean

@@ -0,0 +1,65 @@
+import OAI.Geometry.NodalSets.Coefficients.GaussianCoefficientTail
+import OAI.Geometry.NodalSets.Elliptic.NetDecay
+import OAI.Geometry.NodalSets.Waves.LatticeCount
+import OAI.Geometry.NodalSets.Waves.LatticeNetSmallBall
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped Topology ENNReal
+noncomputable section
+
+lemma lattice_coefficient_event_failure {U : Set Coord} (hU : Bornology.IsBounded U) :
+    ∃ C > 0, ∀ n : ℕ, 0 < n → ∀ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      (gaussianPairs (ι := SourceGrid U n × Fin 3)) (coefficientEvent (n:ℝ))ᶜ ≤
+        ENNReal.ofReal (C*(n:ℝ)^2*Real.exp (-(n:ℝ)^2/8)) := by
+  obtain ⟨C,hC,hcard⟩ := source_coefficient_card_bound hU
+  refine ⟨4*C,by positivity,?_⟩
+  intro n hn hfin
+  let := hfin
+  have h := coefficient_event_failure (ι := SourceGrid U n × Fin 3)
+    (r := (n:ℝ)) (by positivity)
+  refine h.trans (ENNReal.ofReal_le_ofReal ?_)
+  have hc : (Fintype.card (SourceGrid U n × Fin 3):ℝ) ≤ C*(n:ℝ)^2 := by
+    simpa only [Nat.card_eq_fintype_card] using hcard n hn
+  nlinarith [mul_le_mul_of_nonneg_right hc (Real.exp_nonneg (-(n:ℝ)^2/8))]
+
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem actual_lattice_net_failure_rate (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ B > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ E : Set Coord, E ⊆ Q → ∃ t : Finset Coord,
+        (↑t : Set Coord) ⊆ E ∧
+        (∀ x ∈ E, ∃ y ∈ t, ‖x-y‖ ≤ (4*(n:ℝ)^69)⁻¹ ∧
+          sourceEuclideanNorm (x-y) ≤ (2*(n:ℝ)^69)⁻¹) ∧
+        ∀ seed : Coord → ℝ, (∀ x ∈ Q, DifferentiableAt ℝ seed x) →
+          gaussianPairs {coeff | ∃ x ∈ t,
+            ‖a.latticeSeededJet hUD n hfin seed x coeff‖ ≤ 2/(n:ℝ)^56} ≤
+          ENNReal.ofReal (B/((n:ℝ)*Real.sqrt n)) := by
+  obtain ⟨c,hc,C,hC,hnet⟩ := a.actual_lattice_net_small_ball hUD hU hUb hQ hQU
+  refine ⟨C*(24/(Real.sqrt c*Real.sqrt (2*Real.pi)))^5,by positivity,?_⟩
+  filter_upwards [hnet,eventually_gt_atTop (0:ℕ)] with n hn hnpos
+  obtain ⟨hfin,hb⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro E hEQ
+  obtain ⟨t,ht,_,hcover,hprob⟩ := hb E hEQ
+  refine ⟨t,ht,hcover,?_⟩
+  intro seed hs
+  have h := hprob seed hs
+  rw [net_small_ball_rate C c n hc (by positivity)] at h
+  exact h
+
+end LocalCompactWaveData
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSignMargin.lean

@@ -0,0 +1,82 @@
+import OAI.Geometry.NodalSets.Elliptic.SignScaleSeed
+import OAI.Geometry.NodalSets.Waves.LatticeActualTwoPoint
+import OAI.Geometry.NodalSets.Waves.LatticeSignValueBounds
+import OAI.Geometry.NodalSets.Waves.TwoValueSignProbability
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory Set Filter
+open scoped ContDiff Topology ENNReal
+noncomputable section
+
+theorem lattice_sign_margin_probability
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ p : ℝ≥0∞, 0 < p ∧
+      ∀ (w S S0 T0 : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+        ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 →
+        ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∀ x ∈ Q, ∃ j : Fin 4,
+            let F := rescaledGaussianField
+              (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+              S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+            p ≤ gaussianPairs {coeff | 1 ≤ F coeff 0 ∧ F coeff (tau • Pi.single j 1) ≤ -1} := by
+  obtain ⟨tau,ht,ht4,d,hd,henergy⟩ := lattice_actual_two_point_energy g hH hg hp
+  obtain ⟨p,hp,hprob⟩ := two_value_sign_probability d 2 hd (by norm_num)
+  refine ⟨tau,ht,ht4,p,hp,?_⟩
+  intro w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 gamma hgamma hgap
+  filter_upwards [henergy w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS,
+    a.lattice_sign_coefficient_upper hUD hU hUb hQ hQU hS,
+    a.sign_scale_seed_decay hUD hU hUb hQ hQU hS S0 T0 hS0 hT0 gamma hgamma hgap 0 1 (by norm_num)]
+    with n he hu hs
+  obtain ⟨hfin,he⟩ := he
+  obtain ⟨hfin',hu⟩ := hu
+  obtain ⟨hfin'',hs⟩ := hs
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  have heq' : hfin'' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  subst hfin''
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx
+  obtain ⟨j,hj⟩ := he x hx
+  let v : Coord := tau • Pi.single j 1
+  let seed := rescaledSeed S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+  let A := fun i : SourceGrid U n × Fin 3 ↦ normalizedRescaling
+    (latticeWave a.cover a.beams hUD n i.1 i.2) S n (sourceSignScale g S x)
+    (a.latticeSigma hUD n x) x
+  let mean : EuclideanSpace ℝ (Fin 2) := WithLp.toLp 2 ![seed 0,seed v]
+  have hvnorm : ‖v‖ = tau := by
+    simp [v,norm_smul,Real.norm_eq_abs,abs_of_pos ht,Pi.norm_single]
+  have hv : sourceEuclideanNorm v ≤ 2 := (sourceEuclideanNorm_le v).trans (by rw [hvnorm]; linarith)
+  have hv0 : sourceEuclideanNorm (0:Coord) ≤ 2 := by simp [sourceEuclideanNorm]
+  have hs0 := hs x hx 0 hv0 (0 : Fin 1)
+  have hs1 := hs x hx v hv (0 : Fin 1)
+  simp only [Fin.val_zero,norm_iteratedFDeriv_zero] at hs0 hs1
+  change ‖seed 0‖ ≤ 1 at hs0
+  change ‖seed v‖ ≤ 1 at hs1
+  have hmean : ‖mean‖ ≤ 2 := by
+    have hsq : ‖mean‖^2 = (seed 0)^2+(seed v)^2 := by
+      simp [mean,EuclideanSpace.real_norm_sq_eq,Fin.sum_univ_two]
+    have h0 := pow_le_pow_left₀ (norm_nonneg _) hs0 2
+    have h1 := pow_le_pow_left₀ (norm_nonneg _) hs1 2
+    simp only [Real.norm_eq_abs,sq_abs,one_pow] at h0 h1
+    nlinarith [norm_nonneg mean]
+  have hb := hprob (fun i ↦ A i 0) (fun i ↦ A i v) mean hmean
+    (hu x hx 0 (by simp)) (hu x hx v (by rw [hvnorm]; linarith)) hj
+  refine ⟨j,?_⟩
+  convert hb using 1
+  congr 1
+  ext coeff
+  simp [rescaledGaussianField_decomposition,mean,seed,A,v,
+    pairLinearSum_eq_complex,gaussianWaveField,Complex.re_sum]
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSignSubballs.lean

@@ -0,0 +1,78 @@
+import OAI.Geometry.NodalSets.Waves.LatticeGradientExpectation
+import OAI.Geometry.NodalSets.Waves.LatticeSignMargin
+import OAI.Geometry.NodalSets.Waves.SignSubballProbability
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_sign_subballs_probability
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ r : ℝ, 0 < r ∧
+      r < tau/4 ∧ r < (1-tau)/2 ∧ ∃ p : ℝ, 0 < p ∧
+      ∀ (w S S0 T0 : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+        ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 → 5 ≤ k0 →
+        ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∀ x ∈ Q, ∃ j : Fin 4,
+            let F := rescaledGaussianField
+              (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2)
+              S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+            p ≤ gaussianPairs.real {coeff |
+              (∀ v : Coord, sourceEuclideanNorm v ≤ r →
+                sourceEuclideanNorm v ≤ 1 ∧ 0 < F coeff v) ∧
+              (∀ v : Coord, sourceEuclideanNorm (v-tau • Pi.single j 1) ≤ r →
+                sourceEuclideanNorm v ≤ 1 ∧ F coeff v < 0)} := by
+  obtain ⟨tau,ht,ht4,p,hp0,hmargin⟩ := lattice_sign_margin_probability g hH hg hp
+  obtain ⟨q,hq,hq1,hqp⟩ := positive_real_probability_floor hp0
+  obtain ⟨C,hC,hmean⟩ := lattice_gradient_expectation g hH hg hp
+  obtain ⟨L,hL,r,hr,hrt,hr1,hrL,hCL⟩ := sign_subball_constants ht (by linarith) hq hC.le
+  refine ⟨tau,ht,ht4,r,hr,hrt,hr1,q/2,by positivity,?_⟩
+  intro w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 hd gamma hgamma hgap
+  filter_upwards [hmargin w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+    hS hS0 hT0 gamma hgamma hgap,
+    hmean w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+    hS hS0 hT0 hd gamma hgamma hgap,a.estimates] with n hn hm hest
+  obtain ⟨hfin,hn⟩ := hn
+  obtain ⟨hfin',hm⟩ := hm
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  let : IsProbabilityMeasure (gaussianPairs (ι := SourceGrid U n × Fin 3)) := by
+    unfold gaussianPairs; infer_instance
+  refine ⟨hfin,?_⟩
+  intro x hx
+  obtain ⟨j,hj⟩ := hn x hx
+  obtain ⟨G,hGc,hGi,hG0,hGC,hGe⟩ := hm x hx
+  let V := fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2
+  let F := rescaledGaussianField V S0 T0 S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x
+  have hV (i : SourceGrid U n × Fin 3) : ContDiff ℝ ∞ (V i) :=
+    (hest (latticeFrame a.cover hUD n i.1,i.2)).1
+  have hF (coeff) : ContDiff ℝ ∞ (F coeff) := by
+    have he : F coeff = fun z ↦ rescaledSeed S0 T0 S n (sourceSignScale g S x)
+        (a.latticeSigma hUD n x) x z + gaussianWaveField
+          (fun i ↦ normalizedRescaling (V i) S n (sourceSignScale g S x)
+            (a.latticeSigma hUD n x) x) coeff z := by
+      ext z
+      exact rescaledGaussianField_decomposition _ _ _ _ _ _ _ _ _ _
+    rw [he]
+    exact (rescaledSeed_smooth _ _ _ hS0 hT0 _ _ _ _).add
+      (gaussianWaveField_contDiff _ _ (fun i ↦ normalizedRescaling_smooth _ (hV i) _ _ _ _ _))
+  have hqA : q ≤ gaussianPairs.real {coeff | 1 ≤ F coeff 0 ∧ F coeff (tau • Pi.single j 1) ≤ -1} := by
+    have hh := ENNReal.toReal_mono (measure_ne_top _ _) (hqp.trans hj)
+    simpa only [ENNReal.toReal_ofReal hq.le,Measure.real] using hh
+  refine ⟨j,?_⟩
+  exact sign_subballs_probability gaussianPairs F hF G hGi hG0 ht.le hr.le hL
+    (by linarith) hrL hGC hCL (fun coeff hcoeff ↦ (hGe coeff L hL.le).mp hcoeff) j hqA
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSignValueBounds.lean

@@ -0,0 +1,57 @@
+import OAI.Geometry.NodalSets.Coefficients.TwoPointCoefficientEnergy
+import OAI.Geometry.NodalSets.Elliptic.SignScaleSeed
+import OAI.Geometry.NodalSets.Waves.LatticeTwoPointCovariance
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_sign_coefficient_upper (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U)
+    (hS : ContDiff ℝ ∞ S) :
+    ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+      ∀ x ∈ Q, ∀ v : Coord, ‖v‖ ≤ 2 →
+        ∑ i : SourceGrid U n × Fin 3,
+          ‖normalizedRescaling (latticeWave a.cover a.beams hUD n i.1 i.2)
+            S n (sourceSignScale g S x) (a.latticeSigma hUD n x) x v‖^2 ≤ 4 := by
+  classical
+  filter_upwards [a.lattice_full_jet_approximation hUD hU hUb hQ hQU hS 2 (by norm_num) 1 (by norm_num),
+    a.latticeAlpha_main_mass hUD hU hUb hQ hQU (1/2) (by norm_num)] with n herr hm
+  obtain ⟨hfin,herr⟩ := herr
+  obtain ⟨hfin',hm⟩ := hm
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx v hv
+  let W := a.latticePlaneWaveCoefficient hUD n x (sourceSignScale g S x)
+  let A := fun i : SourceGrid U n × Fin 3 ↦ normalizedRescaling
+    (latticeWave a.cover a.beams hUD n i.1 i.2) S n (sourceSignScale g S x)
+    (a.latticeSigma hUD n x) x
+  have hs : 1 ≤ sourceSignScale g S x := by
+    linarith [a.source_sign_scale_lower x (hUD (hQU hx))]
+  have herr' := herr x hx _ hs v hv (0 : Fin (k0+1))
+  simp +instances only [Fin.val_zero,norm_iteratedFDeriv_zero] at herr'
+  have hW : ∑ i, ‖W i v‖^2 ≤ 1 := by
+    rw [← variance_pairLinearSum,← gaussianWaveField_eq_pair,a.lattice_plane_wave_variance,← (hm x hx).1]
+    exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun i _ _ ↦ sq_nonneg _)
+  have hh (i : SourceGrid U n × Fin 3) : ‖A i v‖^2 ≤ 2*‖A i v-W i v‖^2+2*‖W i v‖^2 := by
+    simpa only [sub_add_cancel] using complex_norm_add_sq_bound (A i v-W i v) (W i v)
+  have hsum := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (SourceGrid U n × Fin 3))) ↦ hh i)
+  simp only [Finset.sum_add_distrib,← Finset.mul_sum] at hsum
+  change (∑ i, ‖A i v‖^2) ≤ 4
+  change (∑ i, ‖A i v-W i v‖^2) ≤ 1 at herr'
+  linarith
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSourceWaves.lean

@@ -0,0 +1,82 @@
+import OAI.Geometry.NodalSets.Waves.CompactSourceWaves
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+
+def scaledLatticePoint (n : ℕ) (z : Fin 4 → ℤ) : Coord :=
+  (n:ℝ)^(-1/2:ℝ) • (fun i ↦ (z i:ℝ))
+
+abbrev SourceGrid (U : Set Coord) (n : ℕ) := {z : Fin 4 → ℤ // scaledLatticePoint n z ∈ U}
+
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+
+def selectFrame (d : SourceCompactFrameCover g S D) (x : D) : d.Parameter :=
+  Classical.choose (d.surjective_center x)
+
+lemma selectFrame_center (d : SourceCompactFrameCover g S D) (x : D) :
+    coverSourceCenter d (selectFrame d x) = x :=
+  congrArg Subtype.val (Classical.choose_spec (d.surjective_center x))
+
+def latticeFrame (d : SourceCompactFrameCover g S D) (hUD : U ⊆ D)
+    (n : ℕ) (z : SourceGrid U n) : d.Parameter :=
+  selectFrame d ⟨scaledLatticePoint n z,hUD z.property⟩
+
+lemma latticeFrame_center (d : SourceCompactFrameCover g S D) (hUD : U ⊆ D)
+    (n : ℕ) (z : SourceGrid U n) :
+    coverSourceCenter d (latticeFrame d hUD n z) = scaledLatticePoint n z :=
+  selectFrame_center d _
+
+def latticeWave (d : SourceCompactFrameCover g S D)
+    (b : TripleSourceWaveData g w S (coverSourceCenter d) d.triple m J K k0)
+    (hUD : U ⊆ D) (n : ℕ) (z : SourceGrid U n) (j : Fin 3) : Coord → ℂ :=
+  chartPushforward (b.F (latticeFrame d hUD n z,j))
+    (coordinateWave b.phi b.A J (n:ℝ) (latticeFrame d hUD n z,j))
+
+theorem lattice_wave_estimates (d : SourceCompactFrameCover g S D)
+    (b : TripleSourceWaveData g w S (coverSourceCenter d) d.triple m J K k0)
+    (hUD : U ⊆ D) :
+    ∀ᶠ n : ℕ in atTop, ∀ (z : SourceGrid U n) (j : Fin 3),
+      ContDiff ℝ ∞ (latticeWave d b hUD n z j) ∧ HasCompactSupport (latticeWave d b hUD n z j) ∧
+      tsupport (latticeWave d b hUD n z j) ⊆
+        {x | sourceEuclideanNorm (x-scaledLatticePoint n z) ≤ b.R*(n:ℝ)^(-1/3:ℝ)} ∧
+      ∀ x : Coord,
+        (∀ k : Fin (k0+1), ‖iteratedFDeriv ℝ k.val (latticeWave d b hUD n z j) x‖ ≤
+          b.Cw*(n:ℝ)^k.val*Real.exp ((n:ℝ)*S x-b.c*(n:ℝ)*(sourceEuclideanNorm (x-scaledLatticePoint n z))^2)) ∧
+        DerivativeBound k0 (fun x ↦ sourceWeightedOperator g w (latticeWave d b hUD n z j) x +
+          ((4:ℂ)*(n:ℂ)^2+6*(n:ℂ))*latticeWave d b hUD n z j x) x
+            (b.Cr*(n:ℝ)^(-(K:ℝ))*Real.exp ((n:ℝ)*S x)) := by
+  filter_upwards [b.estimates] with n hn
+  intro z j
+  simpa only [latticeWave,latticeFrame_center] using hn (latticeFrame d hUD n z,j)
+
+theorem lattice_direction_properties (d : SourceCompactFrameCover g S D)
+    (hUD : U ⊆ D) (n : ℕ) (z : SourceGrid U n) :
+    let x := scaledLatticePoint n z
+    let q := d.triple.q (latticeFrame d hUD n z)
+    LinearIndependent ℝ q ∧ ∀ j,
+      g x (metricGradient g S x) (q j) = 0 ∧
+      g x (q j) (q j) = g x (metricGradient g S x) (metricGradient g S x)+4 ∧
+      0 < sourceHessian g S x (metricGradient g S x) (metricGradient g S x)+sourceHessian g S x (q j) (q j) := by
+  have he := latticeFrame_center d hUD n z
+  refine ⟨d.triple.independent _,?_⟩
+  intro j
+  have hp := d.triple.perpendicular (latticeFrame d hUD n z) j
+  have hl := d.triple.length (latticeFrame d hUD n z) j
+  have hs := d.triple.strict (latticeFrame d hUD n z) j
+  change g (coverSourceCenter d _) (metricGradient g S (coverSourceCenter d _)) _ = 0 at hp
+  change g (coverSourceCenter d _) _ _ = g (coverSourceCenter d _) (metricGradient g S (coverSourceCenter d _))
+    (metricGradient g S (coverSourceCenter d _))+4 at hl
+  change 0 < sourceHessian g S (coverSourceCenter d _) (metricGradient g S (coverSourceCenter d _))
+    (metricGradient g S (coverSourceCenter d _))+sourceHessian g S (coverSourceCenter d _) _ _ at hs
+  rw [he] at hp hl hs
+  exact ⟨hp,hl,hs⟩
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSphereExtension.lean

@@ -0,0 +1,46 @@
+import OAI.Geometry.NodalSets.Charts.SeedChartScalarExtension
+import OAI.Geometry.NodalSets.Coefficients.LatticeResidualSupport
+
+namespace OAI
+
+namespace Yau.Target
+open Manifold Yau.Geometry Yau.Jets Yau.Probability Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Yau.Jets.Coord → Yau.Jets.Coord →L[ℝ] Yau.Jets.Coord →L[ℝ] ℝ}
+variable {w S : Yau.Jets.Coord → ℝ} {D U : Set Yau.Jets.Coord} {m J K k0 : ℕ}
+variable (b : LocalCompactWaveData g w S D m J K k0)
+
+theorem literal_lattice_sphere_extension (hD : IsCompact D) (hUD : U ⊆ D)
+    (hUb : Bornology.IsBounded U) {Ω : Set Yau.Jets.Coord} (hΩ : IsOpen Ω) (hDΩ : D ⊆ Ω) :
+    ∃ Q : Set Yau.Jets.Coord, IsCompact Q ∧ Q ⊆ Ω ∧
+      ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+        letI := hfin
+        ∀ coeff : ((SourceGrid U n × Fin 3) × Fin 2) → ℝ,
+          let v := gaussianWaveField
+            (fun i : SourceGrid U n × Fin 3 ↦ latticeWave b.cover b.beams hUD n i.1 i.2) coeff
+          ContDiff ℝ ∞ (fun x ↦ seedCoordinateField n x+v x) →
+          ∃ u : Base → ℝ, ContMDiff (𝓡 4) 𝓘(ℝ,ℝ) ∞ u ∧
+            tsupport (u-sphericalSeed n) ⊆ seedSphereFromCoord '' Q ∧
+            ∀ x, u (seedSphereFromCoord x) = seedCoordinateField n x+v x := by
+  obtain ⟨Q,hQ,hQΩ,hDQ,hbound⟩ := b.lattice_residual_support hD hUD hUb hΩ hDΩ
+  refine ⟨Q,hQ,hQΩ,?_⟩
+  filter_upwards [hbound] with n hn
+  obtain ⟨hfin,hb⟩ := hn
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro coeff v hu
+  have hv : ContDiff ℝ ∞ v := by
+    have he : v = fun x ↦ (seedCoordinateField n x+v x)-seedCoordinateField n x := by
+      funext x; ring
+    rw [he]
+    exact hu.sub (seedCoordinateField_smooth n)
+  have hs := (hb coeff).1
+  obtain ⟨u,hus,hup,hval⟩ := seed_plus_compact_sphere_field v hv
+    (hQ.of_isClosed_subset isClosed_closure hs) n
+  exact ⟨u,hus,hup.trans (image_mono hs),hval⟩
+
+end
+end Yau.Target
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeSuccessfulPacking.lean

@@ -0,0 +1,95 @@
+import OAI.Geometry.NodalSets.Elliptic.SignScalePacking
+import OAI.Geometry.NodalSets.Elliptic.SuccessfulTestSelection
+import OAI.Geometry.NodalSets.Waves.LatticeGoodEvent
+import OAI.Geometry.NodalSets.Waves.LatticePhysicalSignSubballs
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory
+open scoped ContDiff Topology
+noncomputable section
+
+theorem lattice_successful_packing
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ r : ℝ, 0 < r ∧
+      r < tau/4 ∧ r < (1-tau)/2 ∧ ∃ c : ℝ, 0 < c ∧
+      ∀ (w S S0 T0 : Coord → ℝ) (D U Q Ω : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+        ContDiff ℝ ∞ S → ContDiff ℝ ∞ S0 → ContDiff ℝ ∞ T0 → 5 ≤ k0 →
+        ∀ gamma > 0, (∀ x ∈ Q, S0 x+gamma ≤ S x) →
+        IsCompact Ω → (∀ x ∈ Ω, fderiv ℝ T0 x ≠ 0) →
+        ∀ d > 0, (∀ x ∈ Ω, x ∉ U → S x-S0 x ≤ -d) →
+        0 < (∫ x in Q, sourceSignScale g S x) →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∃ t : Finset Coord, ∃ j : t → Fin 4,
+          ∃ coeff ∈ a.latticeGoodEvent hUD n hfin S0 T0 Ω, ∃ u : Finset t,
+            let R := fun x ↦ ((n:ℝ)*sourceSignScale g S x)⁻¹
+            let f := fun y ↦ oscillatorySeed S0 T0 n y + gaussianWaveField
+              (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff y
+            (↑t : Set Coord) ⊆ Q ∧
+            (↑t : Set Coord).PairwiseDisjoint (fun x ↦ sourceClosedBall x (R x)) ∧
+            (∀ x ∈ t, 0 < R x ∧ sourceClosedBall x (5*R x) ⊆ U) ∧
+            (∀ x ∈ u,
+              (∀ y ∈ sourceClosedBall x (r*R x), 0 < f y) ∧
+              (∀ y ∈ sourceClosedBall ((x : Coord)+R x • (tau • Pi.single (j x) 1)) (r*R x), f y < 0)) ∧
+            c*((n:ℝ)*(∫ x in Q, sourceSignScale g S x)) ≤ ∑ x ∈ u, (R x)^3 := by
+  classical
+  obtain ⟨tau,ht,ht4,r,hr,hrt,hr1,p,hp0,hprob⟩ := lattice_physical_sign_subballs g hH hg hp
+  let C : ℝ := 2*(Real.pi^2/2)*5^4
+  have hC : 0 < C := by dsimp [C]; positivity
+  refine ⟨tau,ht,ht4,r,hr,hrt,hr1,p/(2*C),by positivity,?_⟩
+  intro w S S0 T0 D U Q Ω m J K k0 a hHD hUD hUH hU hUb hQ hQU hS hS0 hT0 hk0
+    gamma hgamma hgap hΩ hq d hd hout hmass
+  filter_upwards [hprob w S S0 T0 D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+    hS hS0 hT0 hk0 gamma hgamma hgap,
+    a.source_sign_scale_packing hQ hU hQU hUD,
+    a.lattice_good_event_probability hUD hU hUb hS S0 T0 hS0 hT0 hΩ (by omega) hq hd hout
+      (p/4) (by positivity)] with n hsign hpack hgood
+  obtain ⟨hfin,hsign⟩ := hsign
+  obtain ⟨hfin',hgood⟩ := hgood
+  have heq : hfin' = hfin := Subsingleton.elim _ _
+  subst hfin'
+  let := hfin
+  let : IsProbabilityMeasure (gaussianPairs (ι := SourceGrid U n × Fin 3)) := by
+    unfold gaussianPairs; infer_instance
+  obtain ⟨hn,t,htQ,htdis,htcov,htU,hvol⟩ := hpack
+  let R := fun x ↦ ((n:ℝ)*sourceSignScale g S x)⁻¹
+  let f := fun coeff y ↦ oscillatorySeed S0 T0 n y + gaussianWaveField
+    (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff y
+  choose j hj using (fun x : t ↦ hsign x (htQ x.property))
+  let A := fun x : t ↦ {coeff |
+    (∀ y ∈ sourceClosedBall x (r*R x), 0 < f coeff y) ∧
+    (∀ y ∈ sourceClosedBall ((x : Coord)+R x • (tau • Pi.single (j x) 1)) (r*R x), f coeff y < 0)}
+  have hA (x : t) : MeasurableSet (A x) ∧ p ≤ gaussianPairs.real (A x) := by
+    simpa only [A,f,R,sourceClosedBall,mem_ofPred_eq,div_eq_mul_inv] using (hj x).2
+  have hsum : (∑ x : t, (R x)^3) = ∑ x ∈ t, (R x)^3 := by
+    exact Finset.sum_coe_sort t (fun x ↦ (R x)^3)
+  have hvol' : (n:ℝ)*(∫ x in Q, sourceSignScale g S x) ≤ C * ∑ x : t, (R x)^3 := by
+    rw [hsum]
+    exact hvol
+  have hT : 0 < ∑ x : t, (R x)^3 := by
+    have hh : 0 < (n:ℝ)*(∫ x in Q, sourceSignScale g S x) := mul_pos (by exact_mod_cast hn) hmass
+    nlinarith
+  have hfail : (gaussianPairs (a.latticeGoodEvent hUD n hfin S0 T0 Ω)ᶜ).toReal < p/2 := by
+    have hh := ENNReal.toReal_mono ENNReal.ofReal_ne_top hgood.2
+    rw [ENNReal.toReal_ofReal (by positivity : 0 ≤ p/4)] at hh
+    linarith
+  obtain ⟨coeff,hcoeff,u,hu,hw⟩ := exists_good_successful_tests
+    (fun x : t ↦ (R x)^3) (fun x ↦ (pow_pos (htU x x.property).1 3).le) hT
+    A (fun x ↦ (hA x).1) hp0 (fun x ↦ (hA x).2)
+    (a.latticeGoodEvent hUD n hfin S0 T0 Ω) hgood.1 hfail
+  refine ⟨hfin,t,j,coeff,hcoeff,u,htQ,htdis,htU,hu,?_⟩
+  calc
+    p/(2*C)*((n:ℝ)*(∫ x in Q, sourceSignScale g S x)) ≤
+        p/(2*C)*(C*∑ x : t, (R x)^3) := mul_le_mul_of_nonneg_left hvol' (by positivity)
+    _ = p*(∑ x : t, (R x)^3)/2 := by field_simp
+    _ ≤ _ := hw
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeTwoPointCovariance.lean

@@ -0,0 +1,57 @@
+import OAI.Geometry.NodalSets.Charts.MetricFrequencyBounds
+import OAI.Geometry.NodalSets.Waves.LatticeFullPlaneWaveApprox
+import OAI.Geometry.NodalSets.Waves.PlaneWaveCovariance
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory Set Filter
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+lemma lattice_plane_wave_variance (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x v : Coord) (s : ℝ) :
+    Var[fun coeff ↦ gaussianWaveField (a.latticePlaneWaveCoefficient hUD n x s) coeff v;gaussianPairs] =
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+        sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ)),
+        ‖a.latticeAlpha hUD n x i‖^2 := by
+  classical
+  rw [gaussianWaveField_eq_pair,variance_pairLinearSum,Finset.sum_filter]
+  apply Finset.sum_congr rfl
+  intro i _
+  dsimp only [latticePlaneWaveCoefficient]
+  split_ifs <;> simp [planeWave_norm]
+
+lemma lattice_plane_wave_covariance (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (x : Coord) (s tau : ℝ) (j : Fin 4) :
+    cov[(fun coeff ↦ gaussianWaveField (a.latticePlaneWaveCoefficient hUD n x s) coeff 0),
+      (fun coeff ↦ gaussianWaveField (a.latticePlaneWaveCoefficient hUD n x s)
+        coeff (tau • Pi.single j 1));gaussianPairs] =
+      ∑ i ∈ Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+        sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ)),
+        ‖a.latticeAlpha hUD n x i‖^2 * Real.cos (tau *
+          sourceFrequency (g (scaledLatticePoint n i.1))
+            (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) s j) := by
+  classical
+  rw [gaussianWaveField_eq_pair,gaussianWaveField_eq_pair,covariance_pairLinearSum,Finset.sum_filter]
+  apply Finset.sum_congr rfl
+  intro i _
+  dsimp only [latticePlaneWaveCoefficient]
+  split_ifs
+  · simp only [planeWave_zero,mul_one]
+    rw [show planeWave (g (scaledLatticePoint n i.1)
+        (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2)) s (tau • Pi.single j 1) =
+        Complex.exp (Complex.I * (tau * sourceFrequency (g (scaledLatticePoint n i.1))
+          (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) s j : ℝ)) by
+        simp [planeWave,sourceFrequency,map_smul,smul_eq_mul,mul_div_assoc]]
+    exact complex_rotated_pairing _ _
+  · simp
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeTwoPointGap.lean

@@ -0,0 +1,80 @@
+import OAI.Geometry.NodalSets.Waves.CosineCovarianceBounds
+import OAI.Geometry.NodalSets.Waves.LatticeTwoPointCovariance
+import OAI.Geometry.NodalSets.Waves.PlaneWaveSecondMoment
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability MeasureTheory ProbabilityTheory Set Filter
+open scoped Topology
+noncomputable section
+
+theorem lattice_plane_wave_two_point_gap
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) {H : Set Coord}
+    (hH : IsCompact H) (hg : ContinuousOn g H)
+    (hp : ∀ y ∈ H, ∀ v, v ≠ 0 → 0 < g y v v) :
+    ∃ tau : ℝ, 0 < tau ∧ tau < 1/4 ∧ ∃ delta > 0,
+      ∀ (w S : Coord → ℝ) (D U Q : Set Coord) (m J K k0 : ℕ)
+        (a : LocalCompactWaveData g w S D m J K k0) (_ : H ⊆ D) (hUD : U ⊆ D),
+        U ⊆ H → IsOpen U → Bornology.IsBounded U → IsCompact Q → Q ⊆ U →
+        ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n), letI := hfin
+          ∀ x ∈ Q, ∃ j : Fin 4,
+            let G := fun v coeff ↦ gaussianWaveField
+              (a.latticePlaneWaveCoefficient hUD n x (sourceSignScale g S x)) coeff v
+            let M := Var[G 0;gaussianPairs]
+            let C := cov[G 0,G (tau • Pi.single j 1);gaussianPairs]
+            (1/2:ℝ) ≤ M ∧ M ≤ 1 ∧
+              Var[G (tau • Pi.single j 1);gaussianPairs] = M ∧
+              M/2 ≤ C ∧ C ≤ M-delta := by
+  classical
+  obtain ⟨κ,hκ,B,hB,hann⟩ := lattice_main_frequency_annulus g hH hg hp
+  let tau : ℝ := 1/(8*(B+1))
+  have ht : 0 < tau := by dsimp [tau]; positivity
+  have ht4 : tau < 1/4 := by
+    dsimp [tau]
+    apply (div_lt_iff₀ (by positivity : 0 < 8*(B+1))).mpr
+    linarith
+  have hsmall : tau*B ≤ 1 := by
+    dsimp [tau]
+    rw [one_div,mul_comm,← div_eq_mul_inv]
+    apply (div_le_iff₀ (by positivity : 0 < 8*(B+1))).mpr
+    linarith
+  let delta : ℝ := (2/Real.pi^2)*tau^2*(κ^2/8)
+  have hd : 0 < delta := by dsimp [delta]; positivity
+  refine ⟨tau,ht,ht4,delta,hd,?_⟩
+  intro w S D U Q m J K k0 a hHD hUD hUH hU hUb hQ hQU
+  filter_upwards [hann w S D U m J K k0 a hHD hUD hUH,
+    a.latticeAlpha_main_mass hUD hU hUb hQ hQU (1/2) (by norm_num)] with n hn hm
+  obtain ⟨hfin,hm⟩ := hm
+  let := hfin
+  refine ⟨hfin,?_⟩
+  intro x hx
+  let F := Finset.univ.filter (fun i : SourceGrid U n × Fin 3 ↦
+    sourceEuclideanNorm (x-scaledLatticePoint n i.1) ≤ (n:ℝ)^(-5/12:ℝ))
+  let alpha := a.latticeAlpha hUD n x
+  let k := fun i : SourceGrid U n × Fin 3 ↦ sourceFrequency (g (scaledLatticePoint n i.1))
+    (a.cover.triple.q (latticeFrame a.cover hUD n i.1) i.2) (sourceSignScale g S x)
+  have hmass : (1/2:ℝ) ≤ ∑ i ∈ F, ‖alpha i‖^2 := by
+    have := (hm x hx).2
+    dsimp only [F,alpha]
+    linarith
+  have hmass1 : ∑ i ∈ F, ‖alpha i‖^2 ≤ 1 := by
+    rw [← (hm x hx).1]
+    exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun i _ _ ↦ sq_nonneg _)
+  have hb (i : SourceGrid U n × Fin 3) (hi : i ∈ F) :
+      κ ≤ sourceEuclideanNorm (k i) ∧ sourceEuclideanNorm (k i) ≤ B :=
+    hn x (hUH (hQU hx)) i (Finset.mem_filter.mp hi).2
+  obtain ⟨j,hj⟩ := coordinate_second_moment F alpha k κ hκ.le hmass (fun i hi ↦ (hb i hi).1)
+  have hcoord (i : SourceGrid U n × Fin 3) (hi : i ∈ F) : |k i j| ≤ B :=
+    (norm_le_pi_norm (k i) j).trans ((norm_le_sourceEuclideanNorm _).trans (hb i hi).2)
+  have hbounds := cosine_covariance_bounds F (fun i ↦ ‖alpha i‖^2) (fun i ↦ k i j)
+    tau B (κ^2/8) (fun i hi ↦ sq_nonneg _) ht.le hsmall hcoord hj
+  refine ⟨j,?_⟩
+  dsimp only
+  rw [a.lattice_plane_wave_variance,a.lattice_plane_wave_variance,a.lattice_plane_wave_covariance]
+  exact ⟨hmass,hmass1,rfl,hbounds.1,hbounds.2⟩
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeValueVariance.lean

@@ -0,0 +1,45 @@
+import OAI.Geometry.NodalSets.Waves.GaussianWaveJet
+import OAI.Geometry.NodalSets.Waves.LatticeNormalizedWeights
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Yau.Probability Set Filter MeasureTheory ProbabilityTheory
+noncomputable section
+
+lemma gaussianWaveField_value_variance {ι : Type*} [Fintype ι]
+    (V : ι → Coord → ℂ) (seed : Coord → ℝ) (x : Coord) :
+    Var[fun coeff ↦ seed x+gaussianWaveField V coeff x; gaussianPairs] =
+      ∑ i, ‖V i x‖^2 := by
+  have he : (fun coeff ↦ gaussianWaveField V coeff x) = pairLinearSum (fun i ↦ V i x) := by
+    funext coeff
+    rw [pairLinearSum_eq_complex]
+    simp only [gaussianWaveField,Complex.re_sum]
+  let : IsProbabilityMeasure (gaussianPairs (ι := ι)) := by
+    change IsProbabilityMeasure (Measure.pi (fun _ : ι × Fin 2 ↦ gaussianReal 0 1))
+    infer_instance
+  have hc : Continuous (pairLinearSum (fun i ↦ V i x)) := by
+    unfold pairLinearSum
+    fun_prop
+  change Var[(fun coeff ↦ seed x+(fun coeff ↦ gaussianWaveField V coeff x) coeff); gaussianPairs] = _
+  rw [he,variance_const_add hc.aestronglyMeasurable,variance_pairLinearSum]
+
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+lemma lattice_value_variance (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)]
+    (seed : Coord → ℝ) (x : Coord) :
+    Var[fun coeff ↦ seed x+gaussianWaveField
+      (fun i : SourceGrid U n × Fin 3 ↦ latticeWave a.cover a.beams hUD n i.1 i.2) coeff x;
+      gaussianPairs] = (a.latticeSigma hUD n x)^2 := by
+  rw [a.latticeSigma_sq]
+  exact gaussianWaveField_value_variance _ seed x
+
+end LocalCompactWaveData
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeVarianceComparison.lean

@@ -0,0 +1,84 @@
+import OAI.Geometry.NodalSets.Waves.LatticeEnergyLowerBound
+import OAI.Geometry.NodalSets.Waves.LatticeLogJets
+import OAI.Geometry.NodalSets.Waves.LatticeVarianceUpper
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Metric Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+theorem lattice_variance_lower_bound (hUD : U ⊆ D) (hU : IsOpen U)
+    {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x ∈ Q,
+      c*Real.exp (2*(n:ℝ)*S x) ≤ a.latticeVariance hUD n x := by
+  obtain ⟨Ca,hCa,Cr,hCr,Ci,hCi,c,hc,C,hC,hb⟩ :=
+    a.lattice_logarithmic_jet_estimates hUD 2 (by norm_num)
+  obtain ⟨r,hr,hinner⟩ := compact_inner_ball hQ hU hQU
+  refine ⟨c^2,pow_pos hc 2,?_⟩
+  filter_upwards [hb,eventually_gt_atTop (0:ℕ),
+    eventually_nat_frequency (half_scale_eventually 2 1 r hr)] with n hn hnpos hsmall
+  intro hfin x hx
+  have hd := (norm_le_sourceEuclideanNorm _).trans (rounded_lattice_distance hnpos x)
+  have hmem : scaledLatticePoint n (roundedLatticeIndex n x) ∈ U :=
+    hinner x hx (by simpa only [mem_closedBall,dist_eq_norm] using hd.trans hsmall.2.1)
+  let z : SourceGrid U n := ⟨roundedLatticeIndex n x,hmem⟩
+  have hd' : ‖x-scaledLatticePoint n z‖ ≤ 2*(n:ℝ)^(-1/2:ℝ) := by
+    rw [norm_sub_rev]; exact hd
+  have hl := (hn z 0 x hd').2.2.2.2.1
+  have hle : c*Real.exp ((n:ℝ)*S x) ≤ ‖latticeWave a.cover a.beams hUD n z 0 x‖ := by
+    have hh := mul_le_mul_of_nonneg_right hl.1 (Real.exp_nonneg ((n:ℝ)*S x))
+    simpa only [mul_assoc,← Real.exp_add,neg_mul,neg_add_cancel,Real.exp_zero,mul_one] using hh
+  have hs := pow_le_pow_left₀ (by positivity : 0 ≤ c*Real.exp ((n:ℝ)*S x)) hle 2
+  have he : (c*Real.exp ((n:ℝ)*S x))^2 = c^2*Real.exp (2*(n:ℝ)*S x) := by
+    rw [mul_pow,← Real.exp_nat_mul]
+    congr 2
+    ring
+  rw [he] at hs
+  apply hs.trans
+  unfold latticeVariance
+  exact Finset.single_le_sum (fun i _ ↦ sq_nonneg ‖latticeWave a.cover a.beams hUD n i.1 i.2 x‖)
+    (Finset.mem_univ (z,(0:Fin 3)))
+
+theorem lattice_sigma_comparison (hUD : U ⊆ D) (hU : IsOpen U)
+    (hUb : Bornology.IsBounded U) {Q : Set Coord} (hQ : IsCompact Q) (hQU : Q ⊆ U) :
+    ∃ c > 0, ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∃ hfin : Fintype (SourceGrid U n),
+      letI := hfin
+      ∀ x ∈ Q, c*Real.exp ((n:ℝ)*S x) ≤ a.latticeSigma hUD n x ∧
+        a.latticeSigma hUD n x ≤ C*Real.exp ((n:ℝ)*S x) := by
+  obtain ⟨c,hc,hlo⟩ := a.lattice_variance_lower_bound hUD hU hQ hQU
+  obtain ⟨C,hC,hup⟩ := a.lattice_variance_upper_bound hUD
+  refine ⟨Real.sqrt c,Real.sqrt_pos.mpr hc,Real.sqrt C,Real.sqrt_pos.mpr hC,?_⟩
+  filter_upwards [hlo,hup,eventually_gt_atTop (0:ℕ)] with n hl hu hn
+  have := finite_source_grid hUb hn
+  let hfin := Fintype.ofFinite (SourceGrid U n)
+  refine ⟨hfin,?_⟩
+  intro x hx
+  have hl' := hl x hx
+  have hu' := hu x
+  have hs := a.latticeSigma_sq hUD n x
+  have hnon : 0 ≤ a.latticeSigma hUD n x := Real.sqrt_nonneg _
+  have he : (Real.exp ((n:ℝ)*S x))^2 = Real.exp (2*(n:ℝ)*S x) := by
+    rw [← Real.exp_nat_mul]
+    congr 1
+    ring
+  have hc2 := Real.sq_sqrt hc.le
+  have hC2 := Real.sq_sqrt hC.le
+  constructor
+  · apply (sq_le_sq₀ (by positivity) hnon).mp
+    rw [mul_pow,hc2,he,hs]
+    exact hl'
+  · apply (sq_le_sq₀ hnon (by positivity)).mp
+    rw [mul_pow,hC2,he,hs]
+    exact hu'
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LatticeVarianceUpper.lean

@@ -0,0 +1,87 @@
+import OAI.Geometry.NodalSets.Waves.LocalCompactWaves
+import OAI.Geometry.NodalSets.Waves.ScaledLatticeGaussianSum
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D U : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+def latticeVariance (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)] (x : Coord) : ℝ :=
+  ∑ i : SourceGrid U n × Fin 3, ‖latticeWave a.cover a.beams hUD n i.1 i.2 x‖^2
+
+def latticeSigma (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)] (x : Coord) : ℝ :=
+  Real.sqrt (a.latticeVariance hUD n x)
+
+lemma latticeVariance_nonneg (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)] (x : Coord) :
+    0 ≤ a.latticeVariance hUD n x := Finset.sum_nonneg (fun _ _ ↦ sq_nonneg _)
+
+lemma latticeSigma_sq (hUD : U ⊆ D) (n : ℕ) [Fintype (SourceGrid U n)] (x : Coord) :
+    (a.latticeSigma hUD n x)^2 = a.latticeVariance hUD n x :=
+  Real.sq_sqrt (a.latticeVariance_nonneg hUD n x)
+
+theorem lattice_derivative_square_sum_bound (hUD : U ⊆ D) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x : Coord,
+      ∀ k : Fin (k0+1),
+      ∑ i : SourceGrid U n × Fin 3,
+        ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 ≤
+        C*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x) := by
+  obtain ⟨B,hB,hgauss⟩ := source_lattice_gaussian_sum (show 0 < 2*a.beams.c by have := a.beams.c_pos; positivity)
+  refine ⟨3*a.beams.Cw^2*B,by have := a.beams.Cw_pos; positivity,?_⟩
+  filter_upwards [a.estimates,eventually_gt_atTop (0:ℕ)] with n hn hnpos
+  intro hfin x k
+  let R := a.beams.Cw^2*(n:ℝ)^(2*k.val)*Real.exp (2*(n:ℝ)*S x)
+  have hR : 0 ≤ R := by dsimp [R]; positivity
+  have hb (i : SourceGrid U n × Fin 3) :
+      ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 ≤
+        R*Real.exp (-(2*a.beams.c)*(n:ℝ)*(sourceEuclideanNorm (x-scaledLatticePoint n i.1))^2) := by
+    have h := ((hn (latticeFrame a.cover hUD n i.1,i.2)).2.2.2.2 x).1 k
+    simp only [latticeFrame_center] at h
+    change ‖iteratedFDeriv ℝ k.val (latticeWave a.cover a.beams hUD n i.1 i.2) x‖ ≤ _ at h
+    have hh := pow_le_pow_left₀ (norm_nonneg _) h 2
+    refine hh.trans_eq ?_
+    dsimp [R]
+    rw [mul_pow,mul_pow,← Real.exp_nat_mul,← pow_mul]
+    simp only [mul_assoc,← Real.exp_add]
+    congr 2 <;> ring_nf
+  calc
+    _ ≤ ∑ i : SourceGrid U n × Fin 3, R*Real.exp (-(2*a.beams.c)*(n:ℝ)*
+        (sourceEuclideanNorm (x-scaledLatticePoint n i.1))^2) := Finset.sum_le_sum (fun i _ ↦ hb i)
+    _ = 3*R*∑ z : SourceGrid U n, Real.exp (-(2*a.beams.c)*(n:ℝ)*
+        (sourceEuclideanNorm (x-scaledLatticePoint n z))^2) := by
+      rw [Fintype.sum_prod_type]
+      simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+      rw [← Finset.mul_sum,← Finset.mul_sum,mul_assoc]
+      dsimp [R]
+      ring
+    _ ≤ 3*R*B := mul_le_mul_of_nonneg_left (hgauss U n hnpos x) (by positivity)
+    _ = _ := by dsimp [R]; ring
+
+theorem lattice_variance_upper_bound (hUD : U ⊆ D) :
+    ∃ C > 0, ∀ᶠ n : ℕ in atTop, ∀ [Fintype (SourceGrid U n)], ∀ x : Coord,
+      a.latticeVariance hUD n x ≤ C*Real.exp (2*(n:ℝ)*S x) := by
+  obtain ⟨C,hC,hb⟩ := a.lattice_derivative_square_sum_bound hUD
+  refine ⟨C,hC,?_⟩
+  filter_upwards [hb] with n hn
+  intro hfin x
+  calc
+    a.latticeVariance hUD n x =
+        ∑ i : SourceGrid U n × Fin 3,
+          ‖iteratedFDeriv ℝ 0 (latticeWave a.cover a.beams hUD n i.1 i.2) x‖^2 := by
+      apply Finset.sum_congr rfl
+      intro i hi
+      exact congrArg (fun z : ℝ ↦ z^2)
+        (norm_iteratedFDeriv_zero (𝕜 := ℝ)
+          (f := latticeWave a.cover a.beams hUD n i.1 i.2) (x := x)).symm
+    _ ≤ _ := by simpa only [Fin.val_zero,mul_zero,pow_zero,mul_one] using! hn x 0
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LocalCompactWaves.lean

@@ -0,0 +1,82 @@
+import OAI.Geometry.NodalSets.Elliptic.CompactSourceRepresentatives
+import OAI.Geometry.NodalSets.Waves.CompactSourceWaves
+import OAI.Geometry.NodalSets.Waves.LocalSourceWaveTransfer
+import OAI.Geometry.NodalSets.Waves.WaveSecondJet
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+attribute [local instance] clmTopology clmAdd clmModule
+
+structure LocalCompactWaveData
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) (w S : Coord → ℝ)
+    (D : Set Coord) (m J K k0 : ℕ) where
+  G : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ
+  W : Coord → ℝ
+  A : Coord → ℝ
+  E : Set Coord
+  smooth_G : ContDiff ℝ ∞ G
+  smooth_W : ContDiff ℝ ∞ W
+  smooth_A : ContDiff ℝ ∞ A
+  symmetric_G : ∀ x u v, G x u v = G x v u
+  positive_G : ∀ x v, v ≠ 0 → 0 < G x v v
+  open_E : IsOpen E
+  centers_E : D ⊆ E
+  germ : ∀ x ∈ E, (G =ᶠ[𝓝 x] g) ∧ (W =ᶠ[𝓝 x] w) ∧ (A =ᶠ[𝓝 x] S)
+  nonzero_gradient : ∀ x ∈ D, metricGradient G A x ≠ 0
+  cover : SourceCompactFrameCover G A D
+  beams : TripleSourceWaveData G W A (coverSourceCenter cover) cover.triple m J K k0
+  estimates : ∀ᶠ n : ℕ in atTop, ∀ t : cover.Parameter × Fin 3,
+    ContDiff ℝ ∞ (beams.wave (n:ℝ) t) ∧ HasCompactSupport (beams.wave (n:ℝ) t) ∧
+    tsupport (beams.wave (n:ℝ) t) ⊆ E ∧
+    tsupport (beams.wave (n:ℝ) t) ⊆
+      {z | sourceEuclideanNorm (z-coverSourceCenter cover t.1) ≤ beams.R*(n:ℝ)^(-1/3:ℝ)} ∧
+    ∀ z : Coord,
+      (∀ k : Fin (k0+1), ‖iteratedFDeriv ℝ k.val (beams.wave (n:ℝ) t) z‖ ≤
+        beams.Cw*(n:ℝ)^k.val*Real.exp ((n:ℝ)*S z-beams.c*(n:ℝ)*(sourceEuclideanNorm (z-coverSourceCenter cover t.1))^2)) ∧
+      DerivativeBound k0 (fun z ↦ sourceWeightedOperator g w (beams.wave (n:ℝ) t) z +
+        ((4:ℂ)*(n:ℂ)^2+6*(n:ℂ))*beams.wave (n:ℝ) t z) z
+          (beams.Cr*(n:ℝ)^(-(K:ℝ))*Real.exp ((n:ℝ)*S z))
+
+theorem construct_local_compact_waves {D U : Set Coord} (hD : IsCompact D)
+    (hU : IsOpen U) (hDU : D ⊆ U) (hUn : U.Nonempty)
+    (g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ) (hg : ContDiffOn ℝ ∞ g U)
+    (hs : ∀ x ∈ U, ∀ u v, g x u v = g x v u)
+    (hp : ∀ x ∈ U, ∀ v, v ≠ 0 → 0 < g x v v)
+    (w S : Coord → ℝ) (hw : ContDiffOn ℝ ∞ w U) (hS : ContDiffOn ℝ ∞ S U)
+    (hwp : ∀ x ∈ U, 0 < w x) (hp0 : ∀ x ∈ D, metricGradient g S x ≠ 0)
+    (hdir : ∀ x ∈ D, ∃ v : Coord, g x (metricGradient g S x) v = 0 ∧ g x v v = 1 ∧
+      0 < sourceHessian g S x (metricGradient g S x) (metricGradient g S x)+
+        (g x (metricGradient g S x) (metricGradient g S x)+4)*sourceHessian g S x v v)
+    (m J K k0 : ℕ) (hm : 3*K+4*k0+6 < m+1) (hJ : K+k0+1 ≤ J) :
+    Nonempty (LocalCompactWaveData g w S D m J K k0) := by
+  obtain ⟨G,W,A,E,hG,hW,hA,hGs,hGp,hE,hDE,hEU,hWp,he⟩ :=
+    compact_source_representatives hD hU hDU hUn g hg hs hp w S hw hS hwp
+  have hn (x : Coord) (hx : x ∈ D) : metricGradient G A x ≠ 0 := by
+    rw [(he x (hDE hx)).2.2.2.1]
+    exact hp0 x hx
+  have hd (x : Coord) (hx : x ∈ D) : ∃ v : Coord,
+      G x (metricGradient G A x) v = 0 ∧ G x v v = 1 ∧
+      0 < sourceHessian G A x (metricGradient G A x) (metricGradient G A x)+
+        (G x (metricGradient G A x) (metricGradient G A x)+4)*sourceHessian G A x v v := by
+    obtain ⟨hge,_,_,hpEq,hHEq⟩ := he x (hDE hx)
+    rw [hge.self_of_nhds,hpEq,hHEq]
+    exact hdir x hx
+  obtain ⟨d,⟨b⟩,_⟩ := construct_compact_source_waves G hG hGs hGp W hW A hA
+    hD hE hDE hWp hn hd m J K k0 hm hJ
+  have hest := local_source_wave_transfer g G w W S A
+    (fun t : d.Parameter × Fin 3 ↦ coverSourceCenter d t.1)
+    ((continuous_coverSourceCenter d).comp continuous_fst) hE
+    (fun t ↦ hDE (d.center t.1).property)
+    (fun x hx ↦ ⟨(he x hx).1,(he x hx).2.1,(he x hx).2.2.1.self_of_nhds⟩)
+    (fun n t ↦ b.wave (n:ℝ) t) k0 K b.c b.Cw b.Cr b.R b.Cw_pos b.Cr_pos b.estimates
+  exact ⟨⟨G,W,A,E,hG,hW,hA,hGs,hGp,hE,hDE,
+    (fun x hx ↦ ⟨(he x hx).1,(he x hx).2.1,(he x hx).2.2.1⟩),hn,d,b,hest⟩⟩
+
+end
+end Yau.Geometry
+
+end OAI

lean/OAI/Geometry/NodalSets/Waves/LocalCovarianceGeometry.lean

@@ -0,0 +1,53 @@
+import OAI.Geometry.NodalSets.Charts.MetricCoercivity
+import OAI.Geometry.NodalSets.Elliptic.LocalDirectionBounds
+import OAI.Geometry.NodalSets.Waves.LatticeLogJets
+
+namespace OAI
+
+namespace Yau.Geometry
+open Yau.Jets Set Filter
+open scoped ContDiff Topology
+noncomputable section
+variable {g : Coord → Coord →L[ℝ] Coord →L[ℝ] ℝ} {w S : Coord → ℝ}
+variable {D : Set Coord} {m J K k0 : ℕ}
+namespace LocalCompactWaveData
+variable (a : LocalCompactWaveData g w S D m J K k0)
+
+include a in
+theorem original_covariance_geometry : ∃ mu > 0, ∃ B > 0, ∀ x ∈ D,
+    ‖g x‖ ≤ B ∧ ‖fderiv ℝ S x‖ ≤ B ∧ ∀ v, mu*‖v‖^2 ≤ g x v v := by
+  let y := coverSourceCenter a.cover
+  have hy := continuous_coverSourceCenter a.cover
+  obtain ⟨mu,hmu,B,hB,hg⟩ := uniform_metric_coercivity (a.G ∘ y)
+    (a.smooth_G.continuous.comp hy) (fun t ↦ a.positive_G (y t))
+  have hc : Continuous (fun t ↦ fderiv ℝ a.A (y t)) :=
+    (a.smooth_A.continuous_fderiv (by simp)).comp hy
+  obtain ⟨M,hM,hm⟩ := (isCompact_univ.image hc).isBounded.exists_pos_norm_le
+  refine ⟨mu,hmu,B+M,by positivity,?_⟩
+  intro x hx
+  let t := selectFrame a.cover ⟨x,hx⟩
+  have he : y t = x := selectFrame_center a.cover ⟨x,hx⟩
+  have hG := hg t
+  change ‖a.G (y t)‖ ≤ B ∧ ∀ v, mu*‖v‖^2 ≤ a.G (y t) v v at hG
+  rw [he] at hG
+  have hA := hm _ ⟨t,mem_univ _,rfl⟩
+  change ‖fderiv ℝ a.A (y t)‖ ≤ M at hA
+  rw [he] at hA
+  obtain ⟨hge,_,hae⟩ := a.germ x (a.centers_E hx)
+  rw [hge.self_of_nhds] at hG
+  rw [hae.fderiv_eq] at hA
+  exact ⟨hG.1.trans (by linarith),hA.trans (by linarith),hG.2⟩
+
+theorem lattice_eta_bounds {U : Set Coord} (hUD : U ⊆ D) :
+    ∃ e > 0, ∃ E > 0, ∀ n (z : SourceGrid U n) j,
+      e ≤ a.latticeEta hUD n z j ∧ a.latticeEta hUD n z j ≤ E := by
+  obtain ⟨_,_,e,he,E,hE,hb⟩ := a.original_direction_bounds
+  refine ⟨e,he,E,hE,?_⟩
+  intro n z j
+  exact (hb (latticeFrame a.cover hUD n z)).2 j
+
+end LocalCompactWaveData
+end
+end Yau.Geometry
+
+end OAI