Add lean source and binary files (part 86)

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei.lean

@@ -0,0 +1,113 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.Cubature
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.DensitySynthesis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerApproximation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerInitialBox
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerRegisters
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.EulerTrajectory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowActualBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowActualFirstBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowCompactExtension
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowDeterminant
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowFirstBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowGlobalExistence
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowGlobalRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowHigherComposition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowImplicit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowIntervalUniqueness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowJacobianVariation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowJetCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowJetGronwall
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowJetVariation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLiouville
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLocalBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLocalDomain
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLocalEquation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowLocalModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowMixedDerivative
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowPathEquation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowPathFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowPathJets
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowSliceBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowSpatialRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowUniform
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.FlowVariational
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussEightNodes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussLocalPositionCell
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussPhysicalCell
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussPositionCell
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussTensorError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserChargeBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserCoordinateDifferences
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserDerivatives
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserDifferenceBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserEndpoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserFlow
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserFlowRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserFlux
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserGridPotential
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserIntegrability
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserIntegralBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserInverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserJacobian
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserNumericalBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserTransport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserUniformDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserUniformInverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserUniformVelocity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserVelocityNumerics
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearCoordinateOutput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearCross
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearCutoff
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearGridCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearGridPotential
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearMeshBalance
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearMultiplier
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearNearEstimate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearPacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearPerturbedComplement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearPromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearQuadratureScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearRounding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearTensorCompression
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.RoundedEuler
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.RoundingPolynomialBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabBoxResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabBoxSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabConfinement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabHighAspectRatio
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabInterior
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabKernelEstimates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabLineFlatness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabLineIntegral
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabMonotonicity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabOrbitalResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabOriginQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabOriginSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabOriginValue
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabPlanarIntegral
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabPlanarTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabPolynomialResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabProfile
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabRegularization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabResidualScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabSections
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabVerticalCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedCoulombDerivative
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedFarQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedHybrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedNearForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedNearGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedNodes

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/SlabResidualScale.lean

@@ -0,0 +1,100 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabOrbitalResidual
+
+namespace OAI
+
+/-! A polynomial choice of slab dimensions makes the actual orbital
+residual small. The twenty-fourth moment absorbs the total slab mass. -/
+
+noncomputable section
+open MeasureTheory
+namespace ContinuumCoulomb
+
+theorem slabDomain_volume {H S : ℝ} (hH : 0 ≤ H) (hS : 0 ≤ S) :
+    volume.real (slabDomain H S) = 8*H^2*S := by
+  have h := (slabProduct_measurePreserving H S).measureReal_preimage
+    (s := Set.univ) MeasurableSet.univ.nullMeasurableSet
+  rw [Set.preimage_univ, measureReal_restrict_apply_univ] at h
+  rw [← h, Measure.real, slabProductMeasure, Measure.pi_univ, Fin.prod_univ_three,
+    ENNReal.toReal_mul, ENNReal.toReal_mul]
+  simp only [slabAxisMeasure, Measure.restrict_apply_univ, Real.volume_Icc]
+  norm_num [slabSide, ENNReal.toReal_ofReal, hH, hS]
+  ring
+
+def slabGrowthConstant (rho : ℝ) : ℝ :=
+  rho*(|NeutralAtom.kernelBallMass 1|+8)
+
+theorem slabUniformBound_polynomial {rho T : ℝ} (hrho : 0 ≤ rho) (hT : 1 ≤ T) :
+    slabUniformBound rho (T^4) T ≤ slabGrowthConstant rho*T^9 := by
+  rw [slabUniformBound, slabDomain_volume (by positivity) (by linarith)]
+  have hp : 1 ≤ T^9 := one_le_pow₀ hT
+  have h1 : rho*NeutralAtom.kernelBallMass 1 ≤ rho*|NeutralAtom.kernelBallMass 1| *T^9 := by
+    calc
+      _ ≤ rho*|NeutralAtom.kernelBallMass 1| := mul_le_mul_of_nonneg_left (le_abs_self _) hrho
+      _ ≤ _ := le_mul_of_one_le_right (mul_nonneg hrho (abs_nonneg _)) hp
+  dsimp [slabGrowthConstant]
+  nlinarith only [h1]
+
+def slabResidualPolynomialBound (rho freq : ℝ) (u : PlanarPosition) : ℝ :=
+  72*Real.pi^2*rho^2+8192*rho^2*localizedDensityMoment freq u 4+
+    8*(slabGrowthConstant rho)^2*localizedDensityMoment freq u 24+
+    8*Real.pi^2*rho^2*localizedDensityMoment freq u 24
+
+private theorem div_pow_le_div_sq {T C : ℝ} (hT : 1 ≤ T) (hC : 0 ≤ C)
+    {k : ℕ} (hk : 2 ≤ k) : C/T^k ≤ C/T^2 :=
+  div_le_div_of_nonneg_left hC (by positivity) (pow_le_pow_right₀ hT hk)
+
+theorem slabOrbitalResidual_polynomial_bound {rho T freq : ℝ}
+    (hrho : 0 ≤ rho) (hT : 2 ≤ T) (hfreq : 0 < freq) (u : PlanarPosition) :
+    (∫ x, slabOrbitalResidual rho (T^4) T freq u x^2) ≤
+      slabResidualPolynomialBound rho freq u/T^2 := by
+  have hTpos : 0 < T := by linarith
+  have hT1 : 1 ≤ T := by linarith
+  have hT4 : T ≤ T^4/2 := by
+    have h2 : 2*T ≤ T^2 := by nlinarith [mul_nonneg hTpos.le (sub_nonneg.mpr hT)]
+    have h4 : T^2 ≤ T^4 := by
+      exact pow_le_pow_right₀ hT1 (by decide : 2 ≤ 4)
+    linarith
+  have h := slabOrbitalResidual_square_bound hrho (pow_pos hTpos 4) hTpos.le hfreq
+    hTpos hT4 le_rfl u
+  have hB0 : 0 ≤ slabUniformBound rho (T^4) T := by
+    have h0 := slabPotential_abs_bound hrho (pow_nonneg hTpos.le 4) hTpos.le (0 : Position)
+    exact (abs_nonneg _).trans h0
+  have hB := (sq_le_sq₀ hB0 (by dsimp [slabGrowthConstant]; positivity)).mpr
+    (slabUniformBound_polynomial hrho hT1)
+  have hBterm : 2*(2*slabUniformBound rho (T^4) T)^2*
+      (localizedDensityMoment freq u 24/T^24) ≤
+      8*(slabGrowthConstant rho)^2*localizedDensityMoment freq u 24/T^6 := by
+    have hb := mul_le_mul_of_nonneg_right hB
+      (show 0 ≤ 8*(localizedDensityMoment freq u 24/T^24) by
+        exact mul_nonneg (by norm_num) (div_nonneg (localizedDensityMoment_nonnegative _ _ _)
+          (pow_nonneg hTpos.le _)))
+    convert hb using 1
+    all_goals field_simp [ne_of_gt hTpos]
+    all_goals ring
+  have he1 : 2*(6*Real.pi*rho*T^3/T^4)^2 = 72*Real.pi^2*rho^2/T^2 := by
+    field_simp [ne_of_gt hTpos]
+    ring
+  have he2 : 2*(64*rho*T/T^4)^2*localizedDensityMoment freq u 4 =
+      8192*rho^2*localizedDensityMoment freq u 4/T^6 := by
+    field_simp [ne_of_gt hTpos]
+    ring
+  have he4 : 2*(2*Real.pi*rho)^2*(localizedDensityMoment freq u 24/T^20) =
+      8*Real.pi^2*rho^2*localizedDensityMoment freq u 24/T^20 := by ring
+  rw [he1,he2,he4] at h
+  have h2 := div_pow_le_div_sq hT1
+    (mul_nonneg (mul_nonneg (by norm_num : (0:ℝ)≤8192) (sq_nonneg rho))
+      (localizedDensityMoment_nonnegative freq u 4)) (by decide : 2 ≤ 6)
+  have h3 := div_pow_le_div_sq hT1
+    (mul_nonneg (mul_nonneg (by norm_num : (0:ℝ)≤8) (sq_nonneg (slabGrowthConstant rho)))
+      (localizedDensityMoment_nonnegative freq u 24)) (by decide : 2 ≤ 6)
+  have h4 := div_pow_le_div_sq hT1
+    (mul_nonneg (by positivity : 0 ≤ 8*Real.pi^2*rho^2)
+      (localizedDensityMoment_nonnegative freq u 24)) (by decide : 2 ≤ 20)
+  have hs := h.trans (add_le_add (add_le_add (add_le_add le_rfl h2) (hBterm.trans h3)) h4)
+  simpa only [slabResidualPolynomialBound, add_div] using hs
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/SlabSections.lean

@@ -0,0 +1,200 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabRegularization
+
+namespace OAI
+
+/-! Finite product sections of the actual rectangular slab measure. -/
+
+noncomputable section
+open MeasureTheory Filter
+open scoped BigOperators Topology
+namespace ContinuumCoulomb
+
+def slabSide (H S : ℝ) (i : Fin 3) : ℝ := if i = 2 then S else H
+
+def slabAxisMeasure (H S : ℝ) (i : Fin 3) : Measure ℝ :=
+  volume.restrict (Set.Icc (-slabSide H S i) (slabSide H S i))
+
+def slabProductMeasure (H S : ℝ) : Measure (Fin 3 → ℝ) :=
+  Measure.pi (slabAxisMeasure H S)
+
+def slabProductDomain (H S : ℝ) : Set (Fin 3 → ℝ) :=
+  Set.univ.pi (fun i => Set.Icc (-slabSide H S i) (slabSide H S i))
+
+theorem slabProductDomain_preimage (H S : ℝ) :
+    (MeasurableEquiv.toLp 2 (Fin 3 → ℝ)).symm ⁻¹' slabProductDomain H S = slabDomain H S := by
+  ext x
+  change (∀ i : Fin 3, i ∈ Set.univ → -slabSide H S i ≤ x i ∧ x i ≤ slabSide H S i) ↔
+    |x 0| ≤ H ∧ |x 1| ≤ H ∧ |x 2| ≤ S
+  simp only [Set.mem_univ, true_implies, abs_le]
+  constructor
+  · intro h
+    exact ⟨by simpa [slabSide] using h 0,
+      by simpa [slabSide] using h 1, by simpa [slabSide] using h 2⟩
+  · rintro ⟨h0, h1, h2⟩ i
+    fin_cases i
+    · simpa [slabSide] using h0
+    · simpa [slabSide] using h1
+    · simpa [slabSide] using h2
+
+theorem slabProductMeasure_eq (H S : ℝ) :
+    slabProductMeasure H S = (volume : Measure (Fin 3 → ℝ)).restrict (slabProductDomain H S) := by
+  exact (Measure.restrict_pi_pi (fun _ : Fin 3 => (volume : Measure ℝ))
+    (fun i => Set.Icc (-slabSide H S i) (slabSide H S i))).symm
+
+theorem slabProduct_measurePreserving (H S : ℝ) :
+    MeasurePreserving (MeasurableEquiv.toLp 2 (Fin 3 → ℝ))
+      (slabProductMeasure H S) (volume.restrict (slabDomain H S)) := by
+  have hm := (EuclideanSpace.volume_preserving_symm_measurableEquiv_toLp (Fin 3)).restrict_preimage
+    (s := slabProductDomain H S)
+    (MeasurableSet.univ_pi (fun i => measurableSet_Icc))
+  rw [slabProductDomain_preimage, ← slabProductMeasure_eq] at hm
+  exact MeasurePreserving.symm (MeasurableEquiv.toLp 2 (Fin 3 → ℝ)).symm hm
+
+theorem slabProduct_integral (H S : ℝ) (f : Position → ℝ) :
+    (∫ x, f (WithLp.toLp 2 x) ∂slabProductMeasure H S) =
+      ∫ y in slabDomain H S, f y := by
+  exact (slabProduct_measurePreserving H S).integral_comp' f
+
+theorem slabProduct_integrable (H S : ℝ) (f : Position → ℝ) :
+    Integrable (fun x => f (WithLp.toLp 2 x)) (slabProductMeasure H S) ↔
+      IntegrableOn f (slabDomain H S) :=
+  (slabProduct_measurePreserving H S).integrable_comp_emb
+    (MeasurableEquiv.toLp 2 (Fin 3 → ℝ)).measurableEmbedding
+
+theorem regularizedKernel_eq_sqrt (epsilon : ℝ) (x : Position) :
+    NeutralAtom.regularizedKernel epsilon x = (Real.sqrt (‖x‖^2+epsilon^2))⁻¹ := by
+  rw [NeutralAtom.regularizedKernel, Real.sqrt_eq_rpow]
+  convert Real.rpow_neg (add_nonneg (sq_nonneg ‖x‖) (sq_nonneg epsilon)) (1/2:ℝ) using 1
+  norm_num
+
+theorem regularizedKernel_section (epsilon : ℝ) (y : Position) (i : Fin 3)
+    (t : ℝ) (v : Fin 2 → ℝ) :
+    NeutralAtom.regularizedKernel epsilon (y-WithLp.toLp 2 (i.insertNth t v)) =
+      coulombLineKernel
+        (epsilon^2+∑ j : Fin 2, (y (i.succAbove j)-v j)^2) (y i-t) := by
+  rw [regularizedKernel_eq_sqrt]
+  unfold coulombLineKernel
+  congr 2
+  rw [EuclideanSpace.real_norm_sq_eq, Fin.sum_univ_succAbove _ i]
+  simp only [PiLp.sub_apply, Fin.insertNth_apply_same,
+    Fin.insertNth_apply_succAbove]
+  ring
+
+instance slabAxisMeasure_finite (H S : ℝ) (i : Fin 3) :
+    IsFiniteMeasure (slabAxisMeasure H S i) := by
+  unfold slabAxisMeasure
+  infer_instance
+
+def zeroPositionCoordinate (i : Fin 3) (y : Position) : Position :=
+  WithLp.toLp 2 (Function.update (WithLp.ofLp y) i 0)
+
+theorem zeroPositionCoordinate_same (i : Fin 3) (y : Position) :
+    zeroPositionCoordinate i y i = 0 := by simp [zeroPositionCoordinate]
+
+theorem zeroPositionCoordinate_other (i : Fin 3) (y : Position) (j : Fin 2) :
+    zeroPositionCoordinate i y (i.succAbove j) = y (i.succAbove j) := by
+  simp [zeroPositionCoordinate, Fin.succAbove_ne]
+
+private theorem regularizedProduct_integrable {epsilon H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) :
+    Integrable (fun x : Fin 3 → ℝ => NeutralAtom.regularizedKernel epsilon
+      (y-WithLp.toLp 2 x)) (slabProductMeasure H S) :=
+  (slabProduct_integrable H S _).mpr (regularizedSlab_integrableOn hepsilon hH hS y)
+
+private theorem regularizedSection_integrable {epsilon H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) (i : Fin 3) :
+    Integrable (fun p : ℝ × (Fin 2 → ℝ) => NeutralAtom.regularizedKernel epsilon
+      (y-WithLp.toLp 2 (i.insertNth p.1 p.2)))
+      ((slabAxisMeasure H S i).prod
+        (Measure.pi (fun j : Fin 2 => slabAxisMeasure H S (i.succAbove j)))) := by
+  have hp := (measurePreserving_piFinSuccAbove (slabAxisMeasure H S) i).symm
+  have h := (hp.integrable_comp_emb
+    (MeasurableEquiv.piFinSuccAbove (fun _ : Fin 3 => ℝ) i).symm.measurableEmbedding).mpr
+    (regularizedProduct_integrable hepsilon hH hS y)
+  exact h
+
+theorem regularizedSlab_sectionIntegral {epsilon H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) (i : Fin 3) :
+    (∫ x in slabDomain H S, NeutralAtom.regularizedKernel epsilon (y-x)) =
+      ∫ v : Fin 2 → ℝ, ∫ t : ℝ,
+        NeutralAtom.regularizedKernel epsilon (y-WithLp.toLp 2 (i.insertNth t v))
+        ∂slabAxisMeasure H S i
+        ∂Measure.pi (fun j : Fin 2 => slabAxisMeasure H S (i.succAbove j)) := by
+  rw [← slabProduct_integral H S (fun x => NeutralAtom.regularizedKernel epsilon (y-x))]
+  change (∫ x : Fin 3 → ℝ, NeutralAtom.regularizedKernel epsilon (y-WithLp.toLp 2 x)
+    ∂Measure.pi (slabAxisMeasure H S)) = _
+  rw [← ((measurePreserving_piFinSuccAbove (slabAxisMeasure H S) i).symm).integral_comp']
+  simp only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv]
+  exact integral_prod_symm _ (regularizedSection_integrable hepsilon hH hS y i)
+
+private theorem coulombLine_setIntegral_le_center {A H : ℝ} (hA : 0 < A) (hH : 0 ≤ H)
+    (x : ℝ) :
+    (∫ t in Set.Icc (-H) H, coulombLineKernel A (x-t)) ≤
+      ∫ t in Set.Icc (-H) H, coulombLineKernel A (0-t) := by
+  have h := coulombLineIntegral_le_center hA hH x
+  simp only [centeredLineIntegral_translate,
+    intervalIntegral.integral_of_le (show -H ≤ H by linarith),
+    ← integral_Icc_eq_integral_Ioc] at h
+  exact h
+
+/-- Centering one coordinate increases the attractive Coulomb integral.
+The statement holds for the actual finite slab, before taking the singular limit. -/
+theorem regularizedSlab_coordinate_max {epsilon H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) (i : Fin 3) :
+    (∫ x in slabDomain H S, NeutralAtom.regularizedKernel epsilon (y-x)) ≤
+      ∫ x in slabDomain H S, NeutralAtom.regularizedKernel epsilon
+        (zeroPositionCoordinate i y-x) := by
+  rw [regularizedSlab_sectionIntegral hepsilon hH hS y i,
+    regularizedSlab_sectionIntegral hepsilon hH hS (zeroPositionCoordinate i y) i]
+  apply integral_mono
+    (regularizedSection_integrable hepsilon hH hS y i).integral_prod_right
+    (regularizedSection_integrable hepsilon hH hS (zeroPositionCoordinate i y) i).integral_prod_right
+  intro v
+  simp_rw [regularizedKernel_section, zeroPositionCoordinate_same, zeroPositionCoordinate_other]
+  have hA : 0 < epsilon^2+∑ j : Fin 2, (y (i.succAbove j)-v j)^2 :=
+    add_pos_of_pos_of_nonneg (sq_pos_of_ne_zero hepsilon)
+      (Finset.sum_nonneg (fun _ _ => sq_nonneg _))
+  have hside : 0 ≤ slabSide H S i := by unfold slabSide; split <;> assumption
+  exact coulombLine_setIntegral_le_center hA hside (y i)
+
+/-- The actual singular finite-slab potential is minimized in each centered
+coordinate. The regularized comparison passes through a dominated limit. -/
+theorem slabPotential_coordinate_min {rho H S : ℝ} (hrho : 0 ≤ rho)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) (i : Fin 3) :
+    slabPotential rho H S (zeroPositionCoordinate i y) ≤ slabPotential rho H S y := by
+  let epsilon : ℕ → ℝ := fun n => ((n:ℝ)+1)⁻¹
+  have hep (n : ℕ) : 0 < epsilon n := by dsimp [epsilon]; positivity
+  have heps : Tendsto epsilon atTop (𝓝 0) :=
+    tendsto_inv_atTop_zero.comp
+      (tendsto_atTop_add_const_right _ 1 tendsto_natCast_atTop_atTop)
+  apply le_of_tendsto_of_tendsto
+    (regularizedSlabPotential_tendsto hep heps rho hH hS (zeroPositionCoordinate i y))
+    (regularizedSlabPotential_tendsto hep heps rho hH hS y)
+  exact Filter.Eventually.of_forall (fun n =>
+    mul_le_mul_of_nonpos_left (regularizedSlab_coordinate_max (hep n).ne' hH hS y i)
+      (neg_nonpos.mpr hrho))
+
+theorem slabPotential_minimum {rho H S : ℝ} (hrho : 0 ≤ rho)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (y : Position) :
+    slabPotential rho H S 0 ≤ slabPotential rho H S y := by
+  have h0 := slabPotential_coordinate_min hrho hH hS y 0
+  have h1 := slabPotential_coordinate_min hrho hH hS (zeroPositionCoordinate 0 y) 1
+  have h2 := slabPotential_coordinate_min hrho hH hS
+    (zeroPositionCoordinate 1 (zeroPositionCoordinate 0 y)) 2
+  have he : zeroPositionCoordinate 2 (zeroPositionCoordinate 1 (zeroPositionCoordinate 0 y)) = 0 := by
+    ext j
+    fin_cases j <;> simp [zeroPositionCoordinate]
+  rw [he] at h2
+  exact h2.trans (h1.trans h0)
+
+theorem slabPotential_nonpositive {rho : ℝ} (hrho : 0 ≤ rho) (H S : ℝ) (y : Position) :
+    slabPotential rho H S y ≤ 0 := by
+  rw [slabPotential_eq_setIntegral]
+  exact mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hrho)
+    (integral_nonneg (fun x => inv_nonneg.mpr (norm_nonneg (y-x))))
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/SlabVerticalCoordinates.lean

@@ -0,0 +1,98 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabPlanarTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabSections
+
+namespace OAI
+
+/-! Vertical-first coordinates for the actual three-dimensional slab. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators
+namespace ContinuumCoulomb
+
+def slabVerticalEquiv : Position ≃ᵐ ℝ × PlanarPosition :=
+  (MeasurableEquiv.toLp 2 (Fin 3 → ℝ)).symm.trans
+    ((MeasurableEquiv.piFinSuccAbove (fun _ : Fin 3 => ℝ) 2).trans
+      ((MeasurableEquiv.refl ℝ).prodCongr (MeasurableEquiv.toLp 2 (Fin 2 → ℝ))))
+
+theorem slabVerticalEquiv_symm_apply (p : ℝ × PlanarPosition) :
+    slabVerticalEquiv.symm p = WithLp.toLp 2 ![p.2 0, p.2 1, p.1] := by
+  ext i
+  fin_cases i <;> rfl
+
+theorem slabVerticalEquiv_apply (x : Position) :
+    slabVerticalEquiv x = (x 2, WithLp.toLp 2 ![x 0, x 1]) := by
+  apply Prod.ext
+  · rfl
+  · ext i
+    fin_cases i <;> rfl
+
+theorem slabVerticalEquiv_measurePreserving : MeasurePreserving slabVerticalEquiv :=
+  ((MeasurePreserving.id volume).prod (PiLp.volume_preserving_toLp (Fin 2))).comp
+    ((volume_preserving_piFinSuccAbove (fun _ : Fin 3 => ℝ) 2).comp
+      (PiLp.volume_preserving_ofLp (Fin 3)))
+
+theorem slabVerticalEquiv_preimage (H S : ℝ) :
+    slabVerticalEquiv ⁻¹' (Set.Icc (-S) S ×ˢ slabPlanarBox H) = slabDomain H S := by
+  ext x
+  simp only [Set.mem_preimage, Set.mem_prod, Set.mem_Icc, slabVerticalEquiv_apply,
+    slabPlanarBox, Set.mem_ofPred_eq, Matrix.cons_val_zero,
+    Matrix.cons_val_one, Matrix.cons_val_fin_one, slabDomain, abs_le]
+  tauto
+
+theorem slabVertical_setIntegral (H S : ℝ) (f : Position → ℝ) :
+    (∫ x in slabDomain H S, f x) =
+      ∫ p in Set.Icc (-S) S ×ˢ slabPlanarBox H, f (slabVerticalEquiv.symm p) := by
+  have h := slabVerticalEquiv_measurePreserving.restrict_preimage
+    (s := Set.Icc (-S) S ×ˢ slabPlanarBox H)
+    (measurableSet_Icc.prod (slabPlanarBox_measurable H))
+  rw [slabVerticalEquiv_preimage] at h
+  simpa only [Function.comp_apply, MeasurableEquiv.symm_apply_apply] using
+    h.integral_comp' (f ∘ slabVerticalEquiv.symm)
+
+def slabAxisPoint (z : ℝ) : Position := WithLp.toLp 2 ![0,0,z]
+
+theorem regularizedSlab_vertical_kernel (epsilon z : ℝ) (p : ℝ × PlanarPosition) :
+    NeutralAtom.regularizedKernel epsilon (slabAxisPoint z-slabVerticalEquiv.symm p) =
+      coulombLineKernel (epsilon^2+(z-p.1)^2) ‖p.2‖ := by
+  rw [regularizedKernel_eq_sqrt, slabVerticalEquiv_symm_apply]
+  unfold coulombLineKernel
+  congr 2
+  rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq]
+  simp only [slabAxisPoint, PiLp.sub_apply, Fin.sum_univ_succ,
+    Fin.sum_univ_zero, Matrix.cons_val_zero, Matrix.cons_val_succ, Matrix.cons_val_fin_one,
+    zero_sub, neg_sq]
+  rw [Fin.succ_zero_eq_one]
+  ring
+
+theorem regularizedSlab_vertical_integrable {epsilon H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (z : ℝ) :
+    IntegrableOn (fun p : ℝ × PlanarPosition =>
+      coulombLineKernel (epsilon^2+(z-p.1)^2) ‖p.2‖)
+      (Set.Icc (-S) S ×ˢ slabPlanarBox H) := by
+  have h := slabVerticalEquiv_measurePreserving.restrict_preimage
+    (s := Set.Icc (-S) S ×ˢ slabPlanarBox H)
+    (measurableSet_Icc.prod (slabPlanarBox_measurable H))
+  rw [slabVerticalEquiv_preimage] at h
+  have hs := (MeasurePreserving.symm slabVerticalEquiv h).integrable_comp_emb
+    (g := fun x : Position => NeutralAtom.regularizedKernel epsilon (slabAxisPoint z-x))
+    slabVerticalEquiv.symm.measurableEmbedding
+  exact (hs.mpr (regularizedSlab_integrableOn hepsilon hH hS (slabAxisPoint z))).congr
+    (Filter.Eventually.of_forall (regularizedSlab_vertical_kernel epsilon z))
+
+theorem regularizedSlab_vertical (epsilon rho : ℝ) {H S : ℝ} (hepsilon : epsilon ≠ 0)
+    (hH : 0 ≤ H) (hS : 0 ≤ S) (z : ℝ) :
+    regularizedSlabPotential epsilon rho H S (slabAxisPoint z) =
+      -rho * ∫ w in Set.Icc (-S) S, ∫ p in slabPlanarBox H,
+        coulombLineKernel (epsilon^2+(z-w)^2) ‖p‖ := by
+  unfold regularizedSlabPotential
+  rw [slabVertical_setIntegral]
+  simp_rw [regularizedSlab_vertical_kernel]
+  rw [Measure.volume_eq_prod, setIntegral_prod _
+    (regularizedSlab_vertical_integrable hepsilon hH hS z)]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedCoulombDerivative.lean

@@ -0,0 +1,97 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombFarCell
+import Mathlib.Analysis.Calculus.ContDiff.Bounds
+
+namespace OAI
+
+/-! Fourth derivatives of the Coulomb integrand after the Moser map. The
+estimate is local at a point and needs no regularity across the pole. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+
+theorem fourth_composite_norm_bound (f : Position → ℝ) (G : Position → Position) (x : Position)
+    (hf : ContDiffAt ℝ 4 f (G x)) (hG : ContDiff ℝ 4 G) {C D : ℝ}
+    (hC : ∀ k : ℕ, k ≤ 4 → ‖iteratedFDeriv ℝ k f (G x)‖ ≤ C)
+    (hD : ∀ k : ℕ, 1 ≤ k → k ≤ 4 → ‖iteratedFDeriv ℝ k G x‖ ≤ D^k) :
+    ‖iteratedFDeriv ℝ 4 (f ∘ G) x‖ ≤ 24*C*D^4 := by
+  obtain ⟨U,hU,hx,hfU⟩ := hf.contDiffOn' le_rfl (by norm_num)
+  have hfU : ContDiffOn ℝ 4 f U := by simpa using hfU
+  have hS : IsOpen (G ⁻¹' U) := hU.preimage hG.continuous
+  have hc := norm_iteratedFDerivWithin_comp_le hfU hG.contDiffOn (n := 4) le_rfl
+    hU.uniqueDiffOn hS.uniqueDiffOn (fun _ hy => hy) hx
+    (fun k hk => by
+      rw [iteratedFDerivWithin_eq_iteratedFDeriv hU.uniqueDiffOn (hf.of_le (by exact_mod_cast hk)) hx]
+      exact hC k hk)
+    (fun k hk hk' => by
+      rw [iteratedFDerivWithin_eq_iteratedFDeriv (f := G) (x := x) (s := G ⁻¹' U) hS.uniqueDiffOn
+        (hG.of_le (by exact_mod_cast hk')).contDiffAt hx]
+      exact hD k hk hk')
+  rw [iteratedFDerivWithin_eq_iteratedFDeriv (f := f ∘ G) (x := x) (s := G ⁻¹' U) hS.uniqueDiffOn (hf.comp x hG.contDiffAt) hx] at hc
+  norm_num only [Nat.factorial] at hc
+  exact hc
+
+theorem coulomb_kernel_jets_near_bound :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (z : Position) (r : ℝ), 0 < r → r ≤ 1 → r ≤ ‖z‖ →
+      ∀ k : ℕ, k ≤ 4 → ‖iteratedFDeriv ℝ k Coulomb.coulombKernel z‖ ≤ C/r^5 := by
+  obtain ⟨C,hC,hbound⟩ := coulombKernel_derivative_decay
+  refine ⟨C,hC,fun z r hr hr1 hz k hk => ?_⟩
+  have hzne : z ≠ 0 := norm_pos_iff.mp (hr.trans_le hz)
+  have hb := hbound ⟨k,by omega⟩ z hzne
+  apply (le_div_iff₀ (pow_pos hr 5)).mpr
+  have hp : r^5 ≤ ‖z‖^(k+1) := by
+    calc
+      _ ≤ r^(k+1) := pow_le_pow_of_le_one hr.le hr1 (by omega)
+      _ ≤ _ := pow_le_pow_left₀ hr.le hz _
+  exact (mul_le_mul_of_nonneg_left hp (norm_nonneg _)).trans hb
+
+theorem transportedCoulomb_fourth_bound :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (G : Position → Position), ContDiff ℝ 4 G →
+      ∀ (y x : Position) (r D : ℝ), 0 < r → r ≤ 1 → r ≤ ‖y-G x‖ →
+      (∀ k : ℕ, 1 ≤ k → k ≤ 4 → ‖iteratedFDeriv ℝ k G x‖ ≤ D^k) →
+      ‖iteratedFDeriv ℝ 4 (fun b => Coulomb.coulombKernel (y-G b)) x‖ ≤ 24*C*D^4/r^5 := by
+  obtain ⟨C,hC,hbound⟩ := coulomb_kernel_jets_near_bound
+  refine ⟨C,hC,fun G hG y x r D hr hr1 hdist hD => ?_⟩
+  have hne : y-G x ≠ 0 := norm_pos_iff.mp (hr.trans_le hdist)
+  have hf : ContDiffAt ℝ 4 (fun z => Coulomb.coulombKernel (y-z)) (G x) :=
+    ((coulombKernel_contDiffAt hne).of_le
+      (ENat.natCast_le_of_coe_top_le_withTop le_rfl 4)).comp (G x) (contDiffAt_const.sub contDiffAt_id)
+  have hb := fourth_composite_norm_bound (fun z => Coulomb.coulombKernel (y-z)) G x hf hG
+    (fun k hk => by rw [translatedCoulomb_derivative_norm]; exact hbound _ r hr hr1 hdist k hk) hD
+  apply hb.trans_eq
+  ring
+
+theorem transportedCoulomb_cell_error :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (G : Position → Position), ContDiff ℝ 4 G →
+      ∀ (y b : Position) (h r D : ℝ), 0 ≤ h → 0 < r → r ≤ 1 →
+      (∀ x ∈ Set.Icc (-1:ℝ) 1, ∀ v ∈ Set.Icc (-1:ℝ) 1,
+        ∀ z ∈ Set.Icc (-1:ℝ) 1, r ≤ ‖y-G (cubePoint b (h/2) x v z)‖) →
+      (∀ x ∈ Set.Icc (-1:ℝ) 1, ∀ v ∈ Set.Icc (-1:ℝ) 1,
+        ∀ z ∈ Set.Icc (-1:ℝ) 1, ∀ k : ℕ, 1 ≤ k → k ≤ 4 →
+        ‖iteratedFDeriv ℝ k G (cubePoint b (h/2) x v z)‖ ≤ D^k) →
+      |positionCellGauss b h (fun a => Coulomb.coulombKernel (y-G a))-
+        positionCellIntegral b h (fun a => Coulomb.coulombKernel (y-G a))| ≤
+        24*C*D^4*h^7/r^5 := by
+  obtain ⟨C,hC,hbound⟩ := transportedCoulomb_fourth_bound
+  refine ⟨C,hC,fun G hG y b h r D hh hr hr1 hdist hD => ?_⟩
+  have hf (x : ℝ) (hx : x ∈ Set.Icc (-1:ℝ) 1) (v : ℝ) (hv : v ∈ Set.Icc (-1:ℝ) 1)
+      (z : ℝ) (hz : z ∈ Set.Icc (-1:ℝ) 1) :
+      ContDiffAt ℝ 4 (fun a => Coulomb.coulombKernel (y-G a)) (cubePoint b (h/2) x v z) := by
+    have hn : y-G (cubePoint b (h/2) x v z) ≠ 0 :=
+      norm_pos_iff.mp (hr.trans_le (hdist x hx v hv z hz))
+    have hi : ContDiffAt ℝ 4 (fun a => y-G a) (cubePoint b (h/2) x v z) :=
+      contDiffAt_const.sub hG.contDiffAt
+    exact ContDiffAt.comp (g := Coulomb.coulombKernel) (f := fun a : Position => y-G a)
+      (cubePoint b (h/2) x v z) ((coulombKernel_contDiffAt hn).of_le
+        (ENat.natCast_le_of_coe_top_le_withTop le_rfl 4)) hi
+  have hC0 : 0 ≤ C := le_trans (by norm_num) hC
+  have he := positionCellGauss_error_local (fun a => Coulomb.coulombKernel (y-G a)) b hh
+    (by positivity : 0 ≤ 24*C*D^4/r^5) hf
+    (fun x hx v hv z hz => hbound G hG y _ r D hr hr1 (hdist x hx v hv z hz) (hD x hx v hv z hz))
+  apply he.trans_eq
+  ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedFarQuadrature.lean

@@ -0,0 +1,132 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedHybrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.GaussGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ExceptionalCellVolume
+
+namespace OAI
+
+/-! Local fourth-order error with the nondecaying transport correction
+charged only to cells meeting the compact well support. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators Classical NNReal
+namespace ContinuumCoulomb
+
+def cellHits (E : Set Position) (b : Position) (h : ℝ) : ℝ :=
+  if ∃ z ∈ positionCube b h, z ∈ E then 1 else 0
+
+theorem cellHits_nonneg (E : Set Position) (b : Position) (h : ℝ) : 0 ≤ cellHits E b h := by
+  unfold cellHits
+  split_ifs <;> norm_num
+
+theorem cellHits_indicator_le (E : Set Position) (b : Position) (h : ℝ)
+    {x : Position} (hx : x ∈ positionCube b h) :
+    (if x ∈ E then (1:ℝ) else 0) ≤ cellHits E b h := by
+  by_cases hE : x ∈ E
+  · simp [hE,cellHits,show ∃ z ∈ positionCube b h, z ∈ E from ⟨x,hx,hE⟩]
+  · simpa only [ite_eq_right hE] using cellHits_nonneg E b h
+
+theorem manufactured_cellHits_volume_bound {ι : Type*} [Fintype ι]
+    (index : ι → Fin 3 → ℤ) (hindex : Function.Injective index)
+    {h S : ℝ} (hh : 0 < h) (hh1 : h ≤ 1) (hS : 1 ≤ S)
+    (freq scale : ℝ) {m : ℕ} (u : Fin m → PlanarPosition) :
+    (∑ i, cellHits (tsupport (manufacturedWellField freq scale S u))
+      (gaussCellCenter h (index i)) h*h^3) ≤ 216*m*S := by
+  let s := Finset.univ.filter (fun i => ∃ z ∈ positionCube (gaussCellCenter h (index i)) h,
+    z ∈ tsupport (manufacturedWellField freq scale S u))
+  have hi : Function.Injective (fun i : {i // i ∈ s} => index i.val) := by
+    intro i j hij
+    exact Subtype.ext (hindex hij)
+  have he := exceptional_cell_volume_bound (fun i : {i // i ∈ s} => index i.val) hi
+    hh hh1 hS freq scale u (fun i => (Finset.mem_filter.mp i.property).2)
+  simpa only [Fintype.card_coe,s,cellHits,ite_mul,one_mul,zero_mul,← Finset.sum_filter,
+    Finset.sum_const,nsmul_eq_mul] using he
+
+theorem transportedCoulomb_far_cell_hybrid_error :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (G : Position → Position), ContDiff ℝ 4 G →
+      ∀ (E : Set Position), IsClosed E → (∀ x, x ∉ E → G x = x) →
+      ∀ (D : ℝ), 1 ≤ D →
+      (∀ x, ∀ k : ℕ, 1 ≤ k → k ≤ 4 → ‖iteratedFDeriv ℝ k G x‖ ≤ D^k) →
+      ∀ (L : ℝ≥0), 0 < L → LipschitzWith L G →
+      ∀ (y b : Position) (h : ℝ), 0 < h → 4*(L:ℝ)*h ≤ ‖y-G b‖ →
+      |positionCellGauss b h (fun x => Coulomb.coulombKernel (y-G x))-
+        positionCellIntegral b h (fun x => Coulomb.coulombKernel (y-G x))| ≤
+        (24*C*D^4)*(32/‖y-G b‖^5+cellHits E b h)*h^7 := by
+  obtain ⟨C,hC,hbound⟩ := transportedCoulomb_hybrid_fourth_bound
+  refine ⟨C,hC,fun G hG E hE hfix D hD hGD L hL hLip y b h hh hfar => ?_⟩
+  have hC0 : 0 ≤ C := (by norm_num : (0:ℝ) ≤ 1).trans hC
+  have hd : 0 < ‖y-G b‖ := lt_of_lt_of_le (by positivity) hfar
+  have hf (x : ℝ) (hx : x ∈ Set.Icc (-1:ℝ) 1) (v : ℝ) (hv : v ∈ Set.Icc (-1:ℝ) 1)
+      (z : ℝ) (hz : z ∈ Set.Icc (-1:ℝ) 1) :
+      ContDiffAt ℝ 4 (fun a => Coulomb.coulombKernel (y-G a)) (cubePoint b (h/2) x v z) := by
+    have hc := cubePoint_mem_positionCube b hh.le hx hv hz
+    have hn := (transported_far_cube_distances hh G hL hLip hfar hc).1
+    have hne : y-G (cubePoint b (h/2) x v z) ≠ 0 :=
+      norm_pos_iff.mp (lt_of_lt_of_le (by positivity : (0:ℝ) < (L:ℝ)*h) hn.le)
+    exact ContDiffAt.comp (g := Coulomb.coulombKernel) (f := fun a : Position => y-G a)
+      _ ((coulombKernel_contDiffAt hne).of_le
+        (ENat.natCast_le_of_coe_top_le_withTop le_rfl 4)) (contDiffAt_const.sub hG.contDiffAt)
+  apply positionCellGauss_error_local _ b hh.le
+    (mul_nonneg (by positivity) (add_nonneg (by positivity) (cellHits_nonneg E b h))) hf
+  intro x hx v hv z hz
+  let a := cubePoint b (h/2) x v z
+  have hc : a ∈ positionCube b h := cubePoint_mem_positionCube b hh.le hx hv hz
+  have ha := transported_far_cube_distances hh G hL hLip hfar hc
+  have hapos : 0 < ‖y-G a‖ := lt_of_lt_of_le (by positivity : (0:ℝ) < (L:ℝ)*h) ha.1.le
+  have hp : 1/‖y-G a‖^5 ≤ 32/‖y-G b‖^5 := by
+    have he := one_div_le_one_div_of_le (pow_pos (by positivity : 0 < ‖y-G b‖/2) 5)
+      (pow_le_pow_left₀ (by positivity : 0 ≤ ‖y-G b‖/2) ha.2.1 5)
+    apply he.trans_eq
+    field_simp
+    norm_num
+  apply (hbound G hG E hE hfix D hD hGD y a (norm_pos_iff.mp hapos)).trans
+  exact mul_le_mul_of_nonneg_left (add_le_add hp (cellHits_indicator_le E b h hc)) (by positivity)
+
+theorem transportedCoulomb_far_grid_hybrid_error :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (G : Position → Position), ContDiff ℝ 4 G →
+      ∀ (E : Set Position), IsClosed E → (∀ x, x ∉ E → G x = x) →
+      ∀ (D : ℝ), 1 ≤ D →
+      (∀ x, ∀ k : ℕ, 1 ≤ k �� k ≤ 4 → ‖iteratedFDeriv ℝ k G x‖ ≤ D^k) →
+      ∀ (L : ℝ≥0), 0 < L → LipschitzWith L G →
+      ∀ {ι : Type} [Fintype ι] (index : ι → Fin 3 → ℤ)
+        (y : Position) (h : ℝ), 0 < h →
+      (∀ i, 4*(L:ℝ)*h ≤ ‖y-G (gaussCellCenter h (index i))‖) →
+      |(∑ i, positionCellGauss (gaussCellCenter h (index i)) h
+        (fun x => Coulomb.coulombKernel (y-G x)))-
+        (∑ i, positionCellIntegral (gaussCellCenter h (index i)) h
+          (fun x => Coulomb.coulombKernel (y-G x)))| ≤
+        24*C*D^4*h^4*(32*(∑ i, h^3/‖y-G (gaussCellCenter h (index i))‖^5)+
+          ∑ i, cellHits E (gaussCellCenter h (index i)) h*h^3) := by
+  obtain ⟨C,hC,hbound⟩ := transportedCoulomb_far_cell_hybrid_error
+  refine ⟨C,hC,?_⟩
+  intro G hG E hE hfix D hD hGD L hL hLip ι _ index y h hh hfar
+  have he := weighted_cubature_error h 1
+    (fun i => positionCellGauss (gaussCellCenter h (index i)) h
+      (fun x => Coulomb.coulombKernel (y-G x)))
+    (fun i => positionCellIntegral (gaussCellCenter h (index i)) h
+      (fun x => Coulomb.coulombKernel (y-G x)))
+    (fun i => 24*C*D^4*(32/‖y-G (gaussCellCenter h (index i))‖^5+
+      cellHits E (gaussCellCenter h (index i)) h))
+    zero_le_one (fun i => hbound G hG E hE hfix D hD hGD L hL hLip y _ h hh (hfar i))
+  simp only [one_mul] at he
+  apply he.trans_eq
+  have hs : (∑ i, (24*C*D^4*(32/‖y-G (gaussCellCenter h (index i))‖^5+
+      cellHits E (gaussCellCenter h (index i)) h))*h^3) =
+      (24*C*D^4)*(32*(∑ i, h^3/‖y-G (gaussCellCenter h (index i))‖^5)+
+        ∑ i, cellHits E (gaussCellCenter h (index i)) h*h^3) := by
+    calc
+      _ = ∑ i, (24*C*D^4)*(32*(h^3/‖y-G (gaussCellCenter h (index i))‖^5)+
+          cellHits E (gaussCellCenter h (index i)) h*h^3) := by
+        apply Finset.sum_congr rfl
+        intro i _
+        ring
+      _ = _ := by rw [← Finset.mul_sum,Finset.sum_add_distrib,← Finset.mul_sum]
+  rw [hs]
+  ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedGrid.lean

@@ -0,0 +1,95 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserIntegralBound
+
+namespace OAI
+
+/-! The far-cell inverse-fifth sum after the actual density transport.
+Its constant does not depend on the slab's horizontal extent. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators NNReal
+namespace ContinuumCoulomb
+
+theorem transported_far_cube_distances {h : ℝ} (hh : 0 < h)
+    (G : Position → Position) {L : ℝ≥0} (hL : 0 < L) (hG : LipschitzWith L G)
+    {y b x : Position} (hfar : 4*(L:ℝ)*h ≤ ‖y-G b‖) (hx : x ∈ positionCube b h) :
+    (L:ℝ)*h < ‖y-G x‖ ∧ ‖y-G b‖/2 ≤ ‖y-G x‖ ∧ ‖y-G x‖ ≤ 2*‖y-G b‖ := by
+  have hhL : 0 < (L:ℝ)*h := mul_pos (by exact_mod_cast hL) hh
+  have hn : ‖G x-G b‖ ≤ (L:ℝ)*h :=
+    (hG.norm_sub_le x b).trans (mul_le_mul_of_nonneg_left
+      (positionCube_norm_sub_le hh.le hx) L.coe_nonneg)
+  have ha := norm_sub_le_norm_sub_add_norm_sub y (G x) (G b)
+  have hb := norm_sub_le_norm_sub_add_norm_sub y (G b) (G x)
+  rw [norm_sub_rev (G b) (G x)] at hb
+  constructor
+  · nlinarith
+  constructor <;> nlinarith
+
+theorem transported_inverseFifth_far_cube_bound {h : ℝ} (hh : 0 < h)
+    (G : Position → Position) {L : ℝ≥0} (hL : 0 < L) (hG : LipschitzWith L G)
+    (y b : Position) (hfar : 4*(L:ℝ)*h ≤ ‖y-G b‖) :
+    h^3/‖y-G b‖^5 ≤
+      32*(∫ x in positionCube b h, inverseFifthTail ((L:ℝ)*h) (y-G x)) := by
+  have hr : 0 < (L:ℝ)*h := mul_pos (by exact_mod_cast hL) hh
+  have hd : 0 < ‖y-G b‖ := lt_of_lt_of_le (by positivity) hfar
+  have hi : IntegrableOn (fun x => inverseFifthTail ((L:ℝ)*h) (y-G x)) (positionCube b h) := by
+    apply IntegrableOn.of_bound (positionCube_isCompact b hh.le).measure_lt_top
+      (((inverseFifthTail_measurable _).comp (continuous_const.sub hG.continuous).measurable).aestronglyMeasurable.restrict)
+      (1/((L:ℝ)*h)^5)
+    exact Filter.Eventually.of_forall (fun x => by
+      change ‖inverseFifthTail ((L:ℝ)*h) (y-G x)‖ ≤ 1/((L:ℝ)*h)^5
+      rw [Real.norm_of_nonneg (inverseFifthTail_nonneg _ _)]
+      exact inverseFifthTail_le hr _)
+  have hp (x : Position) (hx : x ∈ positionCube b h) :
+      1/‖y-G b‖^5 ≤ 32*inverseFifthTail ((L:ℝ)*h) (y-G x) := by
+    obtain ⟨hxgt,_hxl,hxu⟩ := transported_far_cube_distances hh G hL hG hfar hx
+    have hdx := hr.trans hxgt
+    rw [inverseFifthTail_eq_inv_pow _ hxgt,mul_one_div]
+    apply (div_le_div_iff₀ (pow_pos hd 5) (pow_pos hdx 5)).mpr
+    have hb := pow_le_pow_left₀ (norm_nonneg (y-G x)) hxu 5
+    nlinarith [show (2*‖y-G b‖)^5 = 32*‖y-G b‖^5 by ring]
+  have he := setIntegral_mono_on
+    (integrableOn_const (C := 1/‖y-G b‖^5)
+      ((positionCube_isCompact b hh.le).measure_lt_top (μ := volume)).ne)
+    (hi.const_mul 32) (positionCube_isClosed b h).measurableSet hp
+  have hv : (volume.restrict (positionCube b h)).real Set.univ = h^3 := by
+    simpa only [Measure.real,Measure.restrict_apply_univ] using positionCube_volume b hh.le
+  simpa only [integral_const,smul_eq_mul,hv,integral_const_mul,div_eq_mul_inv,mul_one,one_mul] using he
+
+theorem moser_inverseFifth_grid_sum_bound (hpublished : PublishedC4FlowInput)
+    {rho H S : ℝ} (hrho : 0 < rho) (hH : 0 ≤ H) (hS : 0 ≤ S)
+    (V : Position → ℝ) (hV : ContDiff ℝ 6 V)
+    (hbound : ∀ x, |manufacturedCharge V x| ≤ rho/2)
+    (hsupport : tsupport V ⊆ slabDomain H S)
+    (G : Position → ℝ → Position) (hG : IsUnitTimeFlow (moserVelocity rho V) G)
+    (hbij : Function.Bijective (fun x => G x 1))
+    (hfix : ∀ x, x ∉ tsupport V → G x 1 = x)
+    {L : ℝ≥0} (hL : 0 < L) (hLip : LipschitzWith L (fun x => G x 1))
+    {ι : Type*} [Fintype ι] (index : ι → Fin 3 → ℤ) (hindex : Function.Injective index)
+    {h : ℝ} (hh : 0 < h)
+    (hsub : ∀ i, positionCube (gaussCellCenter h (index i)) h ⊆ slabDomain H S)
+    (y : Position) (hfar : ∀ i, 4*(L:ℝ)*h ≤ ‖y-G (gaussCellCenter h (index i)) 1‖) :
+    (∑ i, h^3/‖y-G (gaussCellCenter h (index i)) 1‖^5) ≤ 96*Real.pi/((L:ℝ)*h)^2 := by
+  have hr : 0 < (L:ℝ)*h := mul_pos (by exact_mod_cast hL) hh
+  calc
+    _ ≤ ∑ i, 32*(∫ x in positionCube (gaussCellCenter h (index i)) h,
+        inverseFifthTail ((L:ℝ)*h) (y-G x 1)) :=
+      Finset.sum_le_sum (fun i _ => transported_inverseFifth_far_cube_bound hh
+        (fun x => G x 1) hL hLip y _ (hfar i))
+    _ = 32*(∑ i, ∫ x in positionCube (gaussCellCenter h (index i)) h,
+        inverseFifthTail ((L:ℝ)*h) (y-G x 1)) := (Finset.mul_sum _ _ _).symm
+    _ ≤ 32*(∫ x in slabDomain H S, inverseFifthTail ((L:ℝ)*h) (y-G x 1)) :=
+      mul_le_mul_of_nonneg_left (grid_cell_integral_sum_le_on index hindex hh hsub _
+        (transportedInverseFifth_integrableOn hH hS hr _ hLip.continuous y)
+        (fun x => inverseFifthTail_nonneg _ _)) (by norm_num)
+    _ ≤ 32*(3*Real.pi/((L:ℝ)*h)^2) := mul_le_mul_of_nonneg_left
+      (moser_inverseFifth_tail_bound hpublished hrho V hV hbound hsupport G hG hbij hfix y hr)
+      (by norm_num)
+    _ = _ := by ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedHybrid.lean

@@ -0,0 +1,87 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedCoulombDerivative
+
+namespace OAI
+
+/-! The transport correction is confined to the support of the field. Outside
+that set only the integrable inverse-fifth Coulomb derivative remains. -/
+
+noncomputable section
+open Filter
+open scoped Topology Classical
+namespace ContinuumCoulomb
+
+theorem coulomb_kernel_jets_hybrid_bound :
+    ∃ C : ℝ, 1 ≤ C ∧
+      (∀ (z : Position), z ≠ 0 → ∀ k : ℕ, k ≤ 4 →
+        ‖iteratedFDeriv ℝ k Coulomb.coulombKernel z‖ ≤ C*(1+1/‖z‖^5)) ∧
+      (∀ (z : Position), z ≠ 0 →
+        ‖iteratedFDeriv ℝ 4 Coulomb.coulombKernel z‖ ≤ C/‖z‖^5) := by
+  obtain ⟨C,hC,hbound⟩ := coulombKernel_derivative_decay
+  have hC0 : 0 ≤ C := (by norm_num : (0:ℝ) ≤ 1).trans hC
+  refine ⟨C,hC,?_,?_⟩
+  · intro z hz k hk
+    have hd : 0 < ‖z‖ := norm_pos_iff.mpr hz
+    have hb := hbound ⟨k,by omega⟩ z hz
+    by_cases hd1 : ‖z‖ ≤ 1
+    · have hp : ‖z‖^5 ≤ ‖z‖^(k+1) :=
+        pow_le_pow_of_le_one hd.le hd1 (by omega)
+      have he : ‖iteratedFDeriv ℝ k Coulomb.coulombKernel z‖ ≤ C/‖z‖^5 := by
+        apply (le_div_iff₀ (pow_pos hd 5)).mpr
+        exact (mul_le_mul_of_nonneg_left hp (norm_nonneg _)).trans hb
+      rw [mul_add,mul_one,mul_one_div]
+      linarith
+    · have hp : 1 ≤ ‖z‖^(k+1) := one_le_pow₀ (le_of_not_ge hd1)
+      have hm : ‖iteratedFDeriv ℝ k Coulomb.coulombKernel z‖ ≤
+          ‖iteratedFDeriv ℝ k Coulomb.coulombKernel z‖*‖z‖^(k+1) := by
+        simpa only [mul_one] using
+          mul_le_mul_of_nonneg_left hp (norm_nonneg (iteratedFDeriv ℝ k Coulomb.coulombKernel z))
+      have he := hm.trans hb
+      rw [mul_add,mul_one,mul_one_div]
+      linarith [div_nonneg hC0 (pow_nonneg hd.le 5)]
+  · intro z hz
+    apply (le_div_iff₀ (pow_pos (norm_pos_iff.mpr hz) 5)).mpr
+    exact hbound (4:Fin 5) z hz
+
+theorem transportedCoulomb_hybrid_fourth_bound :
+    ∃ C : ℝ, 1 ≤ C ∧ ∀ (G : Position → Position), ContDiff ℝ 4 G →
+      ∀ (E : Set Position), IsClosed E → (∀ x, x ∉ E → G x = x) →
+      ∀ (D : ℝ), 1 ≤ D →
+      (∀ x, ∀ k : ℕ, 1 ≤ k → k ≤ 4 → ‖iteratedFDeriv ℝ k G x‖ ≤ D^k) →
+      ∀ (y x : Position), y-G x ≠ 0 →
+      ‖iteratedFDeriv ℝ 4 (fun b => Coulomb.coulombKernel (y-G b)) x‖ ≤
+        24*C*D^4*(1/‖y-G x‖^5 + if x ∈ E then 1 else 0) := by
+  classical
+  obtain ⟨C,hC,hbound,hpure⟩ := coulomb_kernel_jets_hybrid_bound
+  refine ⟨C,hC,fun G hG E hE hfix D hD hGD y x hne => ?_⟩
+  have hC0 : 0 ≤ C := (by norm_num : (0:ℝ) ≤ 1).trans hC
+  have hf : ContDiffAt ℝ 4 (fun z => Coulomb.coulombKernel (y-z)) (G x) :=
+    ((coulombKernel_contDiffAt hne).of_le
+      (ENat.natCast_le_of_coe_top_le_withTop le_rfl 4)).comp (G x)
+        (contDiffAt_const.sub contDiffAt_id)
+  by_cases hx : x ∈ E
+  · have he := fourth_composite_norm_bound (fun z => Coulomb.coulombKernel (y-z)) G x hf hG
+      (fun k hk => by rw [translatedCoulomb_derivative_norm]; exact hbound _ hne k hk)
+      (hGD x)
+    simp only [ite_eq_left hx]
+    apply he.trans_eq
+    ring
+  · have hlocal : G =ᶠ[𝓝 x] id := by
+      filter_upwards [hE.isOpen_compl.mem_nhds hx] with z hz
+      exact hfix z hz
+    have heq : (fun b => Coulomb.coulombKernel (y-G b)) =ᶠ[𝓝 x]
+        (fun b => Coulomb.coulombKernel (y-b)) := by
+      filter_upwards [hlocal] with b hb
+      rw [hb]
+      rfl
+    rw [(heq.iteratedFDeriv ℝ 4).eq_of_nhds,translatedCoulomb_derivative_norm]
+    have he := hpure (y-x) (by simpa only [hfix x hx] using hne)
+    have hfac : C ≤ 24*C*D^4 := by nlinarith [one_le_pow₀ hD (n := 4)]
+    simp only [ite_eq_right hx,add_zero,hfix x hx]
+    exact he.trans (by simpa only [div_eq_mul_inv,mul_one,one_mul] using
+      mul_le_mul_of_nonneg_right hfac (inv_nonneg.mpr (pow_nonneg (norm_nonneg (y-x)) 5)))
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedNearForm.lean

@@ -0,0 +1,50 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ScaledNuclearNear
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedNodes
+
+namespace OAI
+
+/-! The actual transported Gauss nuclei satisfy the separation hypothesis
+in the full weak-H1 near-field bound, uniformly over the chosen finite grid. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators NNReal
+namespace ContinuumCoulomb
+
+theorem transportedGauss_separation {m : ℕ} {h : ℝ} (hh : 0 < h)
+    (index : Fin m → GaussLatticeIndex) (hindex : Function.Injective index)
+    (G : Position → Position) {K : ℝ≥0} (hK : 0 < K) (hG : AntilipschitzWith K G)
+    (a b : Fin m) (hab : a ≠ b) :
+    h/(3*(K:ℝ)) ≤ ‖G (gaussLatticePoint h (index a))-G (gaussLatticePoint h (index b))‖ := by
+  have hb := gaussLatticePoint_separation hh (index a) (index b) (fun he => hab (hindex he))
+  have ht := hG.le_mul_dist (gaussLatticePoint h (index a)) (gaussLatticePoint h (index b))
+  simp only [dist_eq_norm] at ht
+  apply (div_le_iff₀ (show 0 < 3*(K:ℝ) by positivity)).mpr
+  nlinarith
+
+theorem transportedGauss_near_form {κ : ℝ} (hκ : 0 < κ)
+    (K : ℝ≥0) (hK : 0 < K) :
+    ∃ A : ℝ, 1 ≤ A ∧ ∀ (m n : ℕ) (u : Coulomb.H1Vector n)
+      (s : SpinConfiguration n) (i : Fin n) (h ρ : ℝ),
+      0 < h → h ≤ 1 → 0 ≤ ρ →
+      ∀ (index : Fin m → GaussLatticeIndex), Function.Injective index →
+      ∀ (G : Position → Position), AntilipschitzWith K G →
+      (ρ*h^3/8)*(∑ a, ∫ x in electronBall i (G (gaussLatticePoint h (index a))) (κ*h),
+        Coulomb.coulombKernel (Coulomb.position x i-G (gaussLatticePoint h (index a)))*
+          ‖u.value s x‖^2) ≤
+      ρ*A*h^2*((∫ x, ‖u.value s x‖^2)+
+        ∑ k : Fin 3, ∫ x, ‖u.gradient s (i,k) x‖^2) := by
+  have hσ : 0 < 1/(3*(K:ℝ)) := by positivity
+  obtain ⟨A,hA,hbound⟩ := scaled_nuclear_near_bound hκ hσ
+  refine ⟨A,hA,fun m n u s i h ρ hh hh1 hρ index hindex G hG => ?_⟩
+  apply hbound m n u s i (fun a => G (gaussLatticePoint h (index a))) h ρ hh hh1 hρ
+  intro a b hab
+  have he := transportedGauss_separation hh index hindex G hK hG a b hab
+  convert he using 1
+  ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedNearGrid.lean

@@ -0,0 +1,74 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserIntegrability
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeIntegral
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.TransportedGrid
+
+namespace OAI
+
+/-! Near cells have uniformly bounded continuous Coulomb mass after the
+actual Moser transport. The bound is independent of the enclosing box. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators NNReal
+namespace ContinuumCoulomb
+
+theorem transported_near_cube_distance {h : ℝ} (hh : 0 < h)
+    (G : Position → Position) {L : ℝ≥0} (hL : 0 < L) (hG : LipschitzWith L G)
+    {y b x : Position} (hnear : ‖y-G b‖ ≤ 4*(L:ℝ)*h) (hx : x ∈ positionCube b h) :
+    ‖y-G x‖ < 6*(L:ℝ)*h := by
+  have hn : ‖G x-G b‖ ≤ (L:ℝ)*h :=
+    (hG.norm_sub_le x b).trans (mul_le_mul_of_nonneg_left
+      (positionCube_norm_sub_le hh.le hx) L.coe_nonneg)
+  have ht := norm_sub_le_norm_sub_add_norm_sub y (G b) (G x)
+  rw [norm_sub_rev (G b) (G x)] at ht
+  have hp : 0 < (L:ℝ)*h := mul_pos (by exact_mod_cast hL) hh
+  linarith
+
+theorem transported_near_kernel_eq {h : ℝ} (hh : 0 < h)
+    (G : Position → Position) {L : ℝ≥0} (hL : 0 < L) (hG : LipschitzWith L G)
+    {y b x : Position} (hnear : ‖y-G b‖ ≤ 4*(L:ℝ)*h) (hx : x ∈ positionCube b h) :
+    Coulomb.coulombKernel (y-G x) = Coulomb.truncatedCoulomb (6*(L:ℝ)*h) (y-G x) := by
+  have hm : y-G x ∈ Metric.ball (0:Position) (6*(L:ℝ)*h) := by
+    simpa only [Metric.mem_ball,dist_zero_right] using
+      transported_near_cube_distance hh G hL hG hnear hx
+  exact (Set.indicator_of_mem hm _).symm
+
+theorem moser_near_grid_integral_bound (hpublished : PublishedC4FlowInput)
+    {rho H S : ℝ} (hrho : 0 < rho) (hH : 0 ≤ H) (hS : 0 ≤ S)
+    (V : Position → ℝ) (hV : ContDiff ℝ 6 V)
+    (hbound : ∀ x, |manufacturedCharge V x| ≤ rho/2)
+    (hsupport : tsupport V ⊆ slabDomain H S)
+    (G : Position → ℝ → Position) (hG : IsUnitTimeFlow (moserVelocity rho V) G)
+    (hbij : Function.Bijective (fun x => G x 1))
+    (hfix : ∀ x, x ∉ tsupport V → G x 1 = x)
+    {L : ℝ≥0} (hL : 0 < L) (hLip : LipschitzWith L (fun x => G x 1))
+    {ι : Type*} [Fintype ι] (index : ι → Fin 3 → ℤ) (hindex : Function.Injective index)
+    {h : ℝ} (hh : 0 < h)
+    (hsub : ∀ i, positionCube (gaussCellCenter h (index i)) h ⊆ slabDomain H S)
+    (y : Position) (hnear : ∀ i, ‖y-G (gaussCellCenter h (index i)) 1‖ ≤ 4*(L:ℝ)*h) :
+    (∑ i, positionCellIntegral (gaussCellCenter h (index i)) h
+      (fun x => Coulomb.coulombKernel (y-G x 1))) ≤ 108*Real.pi*(L:ℝ)^2*h^2 := by
+  have hi := moser_coulomb_integrableOn hpublished hrho hH hS V hV hbound hsupport G hG hbij hfix y
+  have ht := moser_truncatedCoulomb_integrable hpublished hrho V hV hbound hsupport
+    G hG hbij hfix y (6*(L:ℝ)*h)
+  calc
+    _ = ∑ i, ∫ x in positionCube (gaussCellCenter h (index i)) h,
+        Coulomb.truncatedCoulomb (6*(L:ℝ)*h) (y-G x 1) := by
+      apply Finset.sum_congr rfl
+      intro i _
+      rw [positionCellIntegral_eq_setIntegral _ hh.le _ (hi.mono_set (hsub i))]
+      apply setIntegral_congr_fun (positionCube_isClosed _ _).measurableSet
+      intro x hx
+      exact transported_near_kernel_eq hh (fun x => G x 1) hL hLip (hnear i) hx
+    _ ≤ ∫ x in slabDomain H S, Coulomb.truncatedCoulomb (6*(L:ℝ)*h) (y-G x 1) :=
+      grid_cell_integral_sum_le_on index hindex hh hsub _ ht
+        (fun x => Coulomb.truncatedCoulomb_nonneg _ _)
+    _ ≤ 3*Real.pi*(6*(L:ℝ)*h)^2 :=
+      moser_truncatedCoulomb_bound hpublished hrho V hV hbound hsupport G hG hbij hfix y (by positivity)
+    _ = _ := by ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Nuclei/TransportedNodes.lean

@@ -0,0 +1,96 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.MoserInverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.Cubature
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearCoordinates
+
+namespace OAI
+
+/-! The actual tensor Gauss nodes on a cubic lattice are separated before
+transport, after transport, and after rational rounding. The enclosing finite
+set of cells will determine the nucleus count in the final construction. -/
+
+noncomputable section
+open scoped NNReal
+namespace ContinuumCoulomb
+
+abbrev GaussLatticeIndex := (Fin 3 → ℤ) × (Fin 3 → Fin 2)
+
+def gaussLatticePoint (h : ℝ) (i : GaussLatticeIndex) : Position :=
+  WithLp.toLp 2 (fun a => h * ((i.1 a : ℝ) + gaussNode (i.2 a) / 2))
+
+theorem gaussAbscissa_bounds : (1 / 2 : ℝ) < gaussAbscissa ∧ gaussAbscissa < 2 / 3 := by
+  have hp := gaussAbscissa_pos
+  have hs := gaussAbscissa_sq
+  constructor <;> nlinarith
+
+theorem gaussNode_bounds (b : Fin 2) :
+    -gaussAbscissa ≤ gaussNode b ∧ gaussNode b ≤ gaussAbscissa := by
+  fin_cases b <;> norm_num [gaussNode, gaussAbscissa_pos.le]
+
+theorem gauss_lattice_coordinate_separation {h : ℝ} (hh : 0 < h)
+    (k l : ℤ) (b c : Fin 2) (hne : k ≠ l ∨ b ≠ c) :
+    h / 3 ≤ |h * ((k : ℝ) + gaussNode b / 2) -
+      h * ((l : ℝ) + gaussNode c / 2)| := by
+  have hb := gaussNode_bounds b
+  have hc := gaussNode_bounds c
+  have ha := gaussAbscissa_bounds
+  rcases lt_trichotomy k l with hkl | hkl | hkl
+  · have hi : (k : ℝ) + 1 ≤ l := by exact_mod_cast (show k + 1 ≤ l by omega)
+    have hprod := mul_nonneg hh.le (show 0 ≤ gaussNode c - gaussNode b + 2 * gaussAbscissa by linarith)
+    have hscale := mul_pos hh (show 0 < (2 / 3 : ℝ) - gaussAbscissa by linarith)
+    have hInt := mul_nonneg hh.le (show 0 ≤ (l : ℝ) - k - 1 by linarith)
+    nlinarith [neg_le_abs (h * ((k : ℝ) + gaussNode b / 2) -
+      h * ((l : ℝ) + gaussNode c / 2))]
+  · subst l
+    have hbc : b ≠ c := hne.resolve_left (not_not.mpr rfl)
+    have hplus := le_abs_self (h * ((k : ℝ) + gaussNode b / 2) -
+      h * ((k : ℝ) + gaussNode c / 2))
+    have hminus := neg_le_abs (h * ((k : ℝ) + gaussNode b / 2) -
+      h * ((k : ℝ) + gaussNode c / 2))
+    have hscale := mul_pos hh (show 0 < gaussAbscissa - (1 / 3 : ℝ) by linarith)
+    fin_cases b <;> fin_cases c <;> norm_num [gaussNode] at * <;> nlinarith
+  · have hi : (l : ℝ) + 1 ≤ k := by exact_mod_cast (show l + 1 ≤ k by omega)
+    have hprod := mul_nonneg hh.le (show 0 ≤ gaussNode b - gaussNode c + 2 * gaussAbscissa by linarith)
+    have hscale := mul_pos hh (show 0 < (2 / 3 : ℝ) - gaussAbscissa by linarith)
+    have hInt := mul_nonneg hh.le (show 0 ≤ (k : ℝ) - l - 1 by linarith)
+    nlinarith [le_abs_self (h * ((k : ℝ) + gaussNode b / 2) -
+      h * ((l : ℝ) + gaussNode c / 2))]
+
+theorem gaussLatticePoint_separation {h : ℝ} (hh : 0 < h)
+    (i j : GaussLatticeIndex) (hne : i ≠ j) :
+    h / 3 ≤ ‖gaussLatticePoint h i - gaussLatticePoint h j‖ := by
+  have hex : ∃ a, i.1 a ≠ j.1 a ∨ i.2 a ≠ j.2 a := by
+    by_contra hn
+    push Not at hn
+    exact hne (Prod.ext (funext (fun a => (hn a).1)) (funext (fun a => (hn a).2)))
+  obtain ⟨a, ha⟩ := hex
+  have hcoord := gauss_lattice_coordinate_separation hh (i.1 a) (j.1 a) (i.2 a) (j.2 a) ha
+  have hb := PiLp.norm_apply_le (gaussLatticePoint h i - gaussLatticePoint h j) a
+  change |h * ((i.1 a : ℝ) + gaussNode (i.2 a) / 2) -
+    h * ((j.1 a : ℝ) + gaussNode (j.2 a) / 2)| ≤ _ at hb
+  exact hcoord.trans hb
+
+/-- The inverse Lipschitz estimate gives a quantitative separation suitable
+for rational nuclear placement, for any finite selection of cells. -/
+theorem transportedGauss_rounding_injective {m denominator : ℕ}
+    (hdenom : 0 < denominator) {h : ℝ} (hh : 0 < h)
+    (index : Fin m → GaussLatticeIndex) (hindex : Function.Injective index)
+    (G : Position → Position) {C : ℝ≥0} (hC : 0 < C)
+    (hG : AntilipschitzWith C G)
+    (hprecision : 6 / (denominator : ℝ) < h / (3 * (C : ℝ))) :
+    Function.Injective (fun i => roundPosition denominator (G (gaussLatticePoint h (index i)))) := by
+  apply roundPosition_injective hdenom
+  intro i j hij
+  have hbase := gaussLatticePoint_separation hh (index i) (index j) (fun h => hij (hindex h))
+  have htrans := hG.le_mul_dist (gaussLatticePoint h (index i)) (gaussLatticePoint h (index j))
+  simp only [dist_eq_norm] at htrans
+  have hdiv : h / (3 * (C : ℝ)) ≤
+      ‖G (gaussLatticePoint h (index i)) - G (gaussLatticePoint h (index j))‖ := by
+    apply (div_le_iff₀ (show 0 < 3 * (C : ℝ) by positivity)).mpr
+    nlinarith
+  exact hprecision.trans_le hdiv
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle.lean

@@ -0,0 +1,432 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.AbsoluteNuclearForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.AffinePhysicalOutput
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.AffinePhysicalThreshold
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ApproximateBisection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.AtomicOutputs
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.BoundedFormCross
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.BoundedPotentialOperator
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisectionLocation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisectionMachine
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisectionSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedContactCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationComponents
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationParameters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedGraphError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedHoppingBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedLipschitzBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedMatrixError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationCoefficientError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationCoulombBrackets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationEndpointSigns
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationGraphBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationMesh
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationRationalBracket
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationSquareError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedCoulombKernel
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedCoulombMass
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedCoulombTruncation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedRawModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedWells
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CenteredGaussEquiv
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CenteredGaussLabels
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CenteredGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CenteredPhysicalThreshold
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalH1
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalResidualPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalSlater
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalSlaterKinetic
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalSlaterSynthesis
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ClassicalTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactCoulombJets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactCoulombSmooth
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactNuclearPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactOrbitalDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactOrbitalNuclearError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactOrbitalQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactSobolevCore
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactSourceGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactSourcePairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CompactSourceTransport
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ComplexFormSplit
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ComplexMollification
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactAdjustment
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactBaseSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCalibratedGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCalibrationScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCanonicalEdge
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactClosedCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactDisplacement
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactEdgeNumber
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactExtent
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGadgetStability
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGadgets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGeometryBlockSemantics
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGlobal
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGlobalSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactHeightBisection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactHeightBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactHeightEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactMediator
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactMediatorGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactMediatorLinks
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactPathBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactPolynomialGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactPositionArray
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactQuotientBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactRationalCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactRationalGadget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactRationalGlobal
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactRationalLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactSourceGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactSourceInputCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactStrips
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactTemplates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoordinateLaplacian
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoreOrbitalCongruence
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoreOrbitalProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoreTensorFiber
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedComplement
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedCrossBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedCrossForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedDiagonalBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedManufacturedResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedNuclearError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedOneElectronProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedRemainderGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedResidualPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CorrectedStateCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombCubeCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombCubeModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombEvaluationError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombEvaluationParameters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombFarCell
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombGram
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombGramApprox
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombInverseFifth
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombKernelHomogeneity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombKernelSmooth
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombNormalizationError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPacketCoercivity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPacketTests
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPackets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPairEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPairSum
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombPoisson
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombQuadratureBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombRawEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombSourceCubature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombTargetLipschitz
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombTargetRange
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombTruncationSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CountertermEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeIntegral
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeMeasure
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.DiagonalPenalty
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.DirectionalFourthDerivative
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ExceptionalCellVolume
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ExplicitVerticalCutoff
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.FullSpinTensorCoefficients
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.FullTensorComplement
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianFrequency
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianJetBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianLine
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianMollification
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianPacket
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianPoincare
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GaussianScalar
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GraphCoefficientStability
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GridGroundUpper
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GridNodePrecision
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GridNuclei
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GroundRoundingInterval
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.H1BoundedForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.H1FiniteProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.H1GraphCore
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.H1PairingBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HeatDensityModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HeatKernelModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HeatSampleError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HoppingBox
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HoppingQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HoppingSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HydrogenInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.InverseFifthCutoffGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.InverseFifthGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.IsolatedForms
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.IsolatedPerturbation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.IsolatedSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCorrectedMatrixError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCorrectedOneBody
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulomb
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombBox
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombLipschitz
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombNumerics
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombRadial
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombSymmetry
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulombTranslation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCountertermMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCounterterms
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedDensityMoment
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedDualMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedDuality
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedFockStates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedFourIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedGradientMoments
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedGram
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedGramConstants
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedGramSpacing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedGroundUpper
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHigherMoments
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHubbard
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHubbardEntries
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHubbardForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHubbardTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedLeakage
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedLinearCoulomb
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedLinearOrbitals
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedMatrixDecayBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedModeDerivatives
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedModes
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedMomentTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedMultiwellResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedNuclearHardy
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedOneBody
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedOneBodyMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedOrbitalGram
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedOverlapSpacing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedRawDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedSpinOperator
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedTensorResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedTransition
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedWellMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedWellResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedCoercivity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedCompactQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedComplement
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedComplementBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedEuler
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedFarGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedFieldBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedFieldEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedFrequency
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGapScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGridError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGridGroundComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGridParameters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGridWitness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedGrowingGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedHubbardComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedManyElectron
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedNuclearComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedNuclearForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedNuclearTensorLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedOneElectronGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedOrbitalNuclearError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedOrbitalResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedPolynomialComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedPreciseResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedProjectedLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedResidualGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedResidualMajorant
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedResidualPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedResidualParameters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedResidualScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedScalarParameters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedScaleThreshold
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedSlabLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTensorCoercivity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTensorDiagonal
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTensorGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTensorLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTensorProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedTransport
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedUniformComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedUniformFlow
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedUniformGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedVelocityEvaluation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedWeakResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ManufacturedWellField
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.MixedSlater
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.MovingWells
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.NormalizationArithmetic
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.NormalizationQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.NormalizationSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.NumericalGridRounding
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.NumericalSquare
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneBodyScaleBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronClosure
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronComplexLaplacian
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronFormDecomposition
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronProjectedLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OneElectronTrial
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalBasisExtension
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalCellVolume
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalComplementCount
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalCutoff
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalCutoffTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalDerivative
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalGraphBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalJetBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalNuclearTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.OrbitalTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarCompactnessEstimates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarCutoffTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarDistributionAxes
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarExponentialEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarFieldBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarForcing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarForcingModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarFrameBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGapFromUniqueness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGradientMoments
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGroundDuality
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGroundIdentity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGroundTransform
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarGroundUniqueness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatBoxBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatBoxCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatDifferential
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatEvolution
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatKernel
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatLimit
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatTimeModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHeatTruncation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHopping
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarHoppingBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarIMS
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarIMSBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarLaplaceIBP
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarLocalization
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarLowerTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeDecay
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeDerivatives
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeH1
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeJets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarModeProperties
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarMultiwellGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarMultiwellMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarMultiwellProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarMultiwellScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarNearGroundCompactness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarNormalizationBox
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarNormalizationTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarNormalized
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarOverlap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarPartition
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarPolynomialScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarProjectionGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarRadial
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarResolvent
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarResolventEquation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarResolventModulus
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarResolventTails
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarScaleChoice
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSharpDecay
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSiteCutoffs
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSliceProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSobolev
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSobolevDuality
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarSpectralInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarTestCauchy
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarTranslatedGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarUniformCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWeakConstant
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWellBottom
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWellLocalization
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWellMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWellNumerics
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarWellOverlap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PrefactorCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PrefactorSourceCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PrefactorSourceContactCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PrefactorSpacing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalBoxRound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalClamp
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalContactBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalContactMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalExponential
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalFieldDifferences
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalGaussNodes
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalHeatBox
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalHeatPlaneError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalHeatSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalLogScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalResolventError
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalSixQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalSmoothTransition
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalSquareRoot
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalTaylorRegisters
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalTripleQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RayleighGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RealMollification
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RealOneElectronState
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RealOrbitalResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RealSpinOrbitals
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RectangleQuadrature
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ResolventNumericalBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ResolventSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ScalarMollification
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ScalarScaleBudgets
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ScaledNuclearNear
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SeparatedNuclearNear
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SharpBlockPerturbation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ShiftedHubbardBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ShiftedPhysicalForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SingleSpinSource
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SlowLogarithmicExtent
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SmoothCutoffApproximation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SobolevDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SobolevDensityInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitFormIdentity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitFormIntegrals
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitFrameBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitIntegratedBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitProjectionBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitProjectionPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitPullback
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitSpectralBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.SplitTestFunctions
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TM2Composition
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ThirdOrderBottom
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ThirdOrderPerturbation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ThirdOrderScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TransformedGauss
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TransformedGaussList
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TransformedGaussSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TruncatedNuclearForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.UnitBinaryInclusion
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.UnitProgramGroundInterval
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalCappedForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalCappedGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalCappedScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalCutoffTail
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalFactorization
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalMode
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalOscillatorGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalResidual
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalSliceProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.VerticalSpectralInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WeakComplexLaplacian
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WeakH1Laplacian
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WeakH1Pairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WellCapDerivatives
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WellCapRegularity
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WellCover
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WellFieldOrbitalResidual

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/AbsoluteNuclearForm.lean

@@ -0,0 +1,66 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearGridPotential
+import OAI.MathematicalPhysics.ContinuumCoulomb.ManyBody.WeightedPotentialBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.SlabRegularity
+
+namespace OAI
+
+/-! Absolute-value form bound for unit-nucleus replacement. It holds
+for every spin component of every many-electron weak-H1 state. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators NNReal
+namespace ContinuumCoulomb
+
+theorem manufactured_grid_absolute_form_error (hpublished : PublishedC4FlowInput)
+    (L K : ℝ≥0) (hL : 0 < L) (hK : 0 < K) :
+    ∃ C A : ℝ, 1 ≤ C ∧ 1 ≤ A ∧
+    ∀ (rho H S freq scale : ℝ) (m : ℕ) (u : Fin m → PlanarPosition),
+      0 < rho → 0 ≤ H → 1 ≤ S →
+      (∀ x, |manufacturedCharge (manufacturedWellField freq scale S u) x| ≤ rho/2) →
+      tsupport (manufacturedWellField freq scale S u) ⊆ slabDomain H S →
+      ∀ (G : Position → ℝ → Position),
+      IsUnitTimeFlow (moserVelocity rho (manufacturedWellField freq scale S u)) G →
+      Function.Bijective (fun x => G x 1) →
+      (∀ x, x ∉ tsupport (manufacturedWellField freq scale S u) → G x 1 = x) →
+      ∀ (D : ℝ), 1 ≤ D →
+      (∀ x, ∀ k : ℕ, 1 ≤ k → k ≤ 4 → ‖iteratedFDeriv ℝ k (fun x => G x 1) x‖ ≤ D^k) →
+      LipschitzWith L (fun x => G x 1) → AntilipschitzWith K (fun x => G x 1) →
+      ∀ {ι : Type} [Fintype ι] (index : ι → Fin 3 → ℤ), Function.Injective index →
+      ∀ (h : ℝ), 0 < h → h ≤ 1 →
+      (⋃ i, positionCube (gaussCellCenter h (index i)) h) = slabDomain H S →
+      ∀ (n : ℕ) (w : Coulomb.H1Vector n) (s : SpinConfiguration n) (i : Fin n),
+      Integrable (fun x => |gridNuclearPotential index (fun x => G x 1) rho h (Coulomb.position x i)-
+        (slabPotential rho H S (Coulomb.position x i)+
+          manufacturedWellField freq scale S u (Coulomb.position x i))| * ‖w.value s x‖^2) ∧
+      (∫ x, |gridNuclearPotential index (fun x => G x 1) rho h (Coulomb.position x i)-
+        (slabPotential rho H S (Coulomb.position x i)+
+          manufacturedWellField freq scale S u (Coulomb.position x i))| *‖w.value s x‖^2) ≤
+      rho*(24*C*D^4*(3072*Real.pi*h^2/(L:ℝ)^2+216*m*S*h^4)+108*Real.pi*(L:ℝ)^2*h^2)*
+        (∫ x, ‖w.value s x‖^2)+
+      rho*A*h^2*((∫ x, ‖w.value s x‖^2)+∑ k : Fin 3, ∫ x, ‖w.gradient s (i,k) x‖^2) := by
+  obtain ⟨C,hC,hpoint⟩ := manufactured_grid_potential_error hpublished
+  have hκ : 0 < 6*(L:ℝ) := by positivity
+  obtain ⟨A,hA,hnear⟩ := transportedGauss_truncated_form hκ K hK
+  refine ⟨C,A,hC,hA,?_⟩
+  intro rho H S freq scale m u hrho hH hS hcharge hsupp G hflow hbij hfix D hD hGD hLip hAnti
+    ι _ index hindex h hh hh1 hcover n w s i
+  let F : Position → ℝ := fun y => gridNuclearPotential index (fun x => G x 1) rho h y-
+    (slabPotential rho H S y+manufacturedWellField freq scale S u y)
+  let B := rho*(24*C*D^4*(3072*Real.pi*h^2/(L:ℝ)^2+216*m*S*h^4)+108*Real.pi*(L:ℝ)^2*h^2)
+  let R : ι × (Fin 3 → Fin 2) → Position := fun a => G (gaussLatticePoint h (gridGaussIndex index a)) 1
+  have hF : Measurable F := (gridNuclearPotential_measurable index (fun x => G x 1) rho h).sub
+    (((slabPotential_continuous hrho.le hH (by linarith)).add
+      (manufacturedWellField_C7 freq scale S u).continuous).measurable)
+  have he := weighted_potential_absolute_bound w s i F hF R (6*(L:ℝ)*h) B (rho*h^3/8)
+    (hpoint rho H S freq scale m u hrho hH hS hcharge hsupp G hflow hbij hfix
+      D hD hGD L hL hLip index hindex h hh hh1 hcover)
+  have hn := hnear n w s i h rho hh hh1 hrho.le (gridGaussIndex index)
+    (gridGaussIndex_injective index hindex) (fun x => G x 1) hAnti
+  exact ⟨he.1, he.2.trans (add_le_add le_rfl hn)⟩
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/AffinePhysicalOutput.lean

@@ -0,0 +1,78 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.AffinePhysicalThresholdProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.UnitCoulombProgram
+
+namespace OAI
+
+/-! A canonical unit-charge instance with the complete physical scalar offset.
+The coordinate and threshold metadata remain explicit until the source program
+supplies the same fixed polynomial scales to both components. -/
+
+namespace ContinuumCoulomb.AffinePhysicalOutput
+open ExactQuantumFactoring.BitStackProgram
+
+abbrev Input := PhysicalNuclearProgram.Input × AffinePhysicalThreshold.Input
+
+def inputCode : Input → List Bool :=
+  prodCode PhysicalNuclearProgram.inputCode AffinePhysicalThreshold.inputCode
+
+noncomputable def argument (rho : ℕ) (x : Input) : UnitCoulombProgram.Input :=
+  (x.1,(x.2.1.2.1,AffinePhysicalThreshold.value rho x.2))
+
+noncomputable def value (rho U C K : ℕ) (x : Input) : UnitCoulomb :=
+  UnitCoulombProgram.value rho U C K (argument rho x)
+
+noncomputable opaque argumentProgram (rho : ℕ) :
+    Procedure inputCode UnitCoulombProgram.inputCode (argument rho) := by
+  let geom := Procedure.first PhysicalNuclearProgram.inputCode AffinePhysicalThreshold.inputCode
+  let numbers := Procedure.second PhysicalNuclearProgram.inputCode AffinePhysicalThreshold.inputCode
+  let count := AffinePhysicalThreshold.electronsProgram.comp numbers
+  let endpoints := (AffinePhysicalThreshold.program rho).comp numbers
+  exact geom.pair (count.pair endpoints)
+
+noncomputable opaque program (rho U C K : ℕ) :
+    Procedure inputCode unitCoulombCodec.encode (value rho U C K) :=
+  (UnitCoulombProgram.program rho U C K).comp (argumentProgram rho)
+
+noncomputable def certificate (rho U C K : ℕ) :
+    Turing.TM2ComputableInPolyTime inputCode unitCoulombCodec.encode (value rho U C K) :=
+  (program rho U C K).toTM2
+
+theorem nuclei (rho U C K : ℕ) (x : Input) :
+    (value rho U C K x).nuclei = PhysicalNuclearProgram.nuclei rho U C K x.1 := rfl
+
+theorem electrons (rho U C K : ℕ) (x : Input) :
+    (value rho U C K x).electrons = x.2.1.2.1 := rfl
+
+theorem lower (rho U C K : ℕ) (x : Input) :
+    (value rho U C K x).lower.value = (AffinePhysicalThreshold.value rho x.2).1 :=
+  NuclearCoordinateOutput.rational_value _
+
+theorem upper (rho U C K : ℕ) (x : Input) :
+    (value rho U C K x).upper.value = (AffinePhysicalThreshold.value rho x.2).2 :=
+  NuclearCoordinateOutput.rational_value _
+
+theorem actual_error (rho U C K : ℕ) (hrho : 0 < rho) (x : Input)
+    (hmesh : 0 < x.2.1.1.1) {m : ℕ}
+    (u : Fin m → CoulombPairSum.Point) (hu : Function.Injective u)
+    (hsites : x.2.2.2.1 = List.ofFn u) :
+    let v := CoulombPairSum.exactTotal (GaussianFrequency.frequency rho) u
+    |((value rho U C K x).lower.value:ℝ)-
+      (AffinePhysicalThreshold.exactValue rho x.2 v).1| ≤ 1/(x.2.1.2.2.1+1:ℝ) ∧
+    |((value rho U C K x).upper.value:ℝ)-
+      (AffinePhysicalThreshold.exactValue rho x.2 v).2| ≤ 1/(x.2.1.2.2.1+1:ℝ) := by
+  dsimp only
+  rw [lower,upper]
+  exact AffinePhysicalThreshold.actual_error rho hrho x.2 hmesh u hu hsites
+
+theorem valid (rho U C K : ℕ) (x : Input) (hne : 0 < x.2.1.2.1)
+    (hpositions : ((PhysicalNuclearProgram.nuclei rho U C K x.1).map BinaryPosition.value).Nodup)
+    (hgap : (1:ℚ) ≤ CenteredPhysicalThreshold.amplification rho x.2.1.1.1*x.2.2.1^2*
+      (x.2.1.2.2.2.2-x.2.1.2.2.2.1)) : (value rho U C K x).Valid := by
+  apply UnitCoulombProgram.valid rho U C K (x.1,(x.2.1.2.1,AffinePhysicalThreshold.value rho x.2))
+    hne hpositions
+  rw [AffinePhysicalThreshold.gap]
+  exact hgap
+
+end ContinuumCoulomb.AffinePhysicalOutput
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/AffinePhysicalThreshold.lean

@@ -0,0 +1,127 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CenteredPhysicalThresholdProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CoulombPairSumProgram
+
+namespace OAI
+
+/-! The complete scalar shift in the unit-charge construction. Input endpoints
+already contain the exact mediator offset. The remaining finite shift is the
+sum of edge weights and the off-site Coulomb energy; only the latter and the
+one-particle reference require numerical approximation. -/
+
+noncomputable section
+namespace ContinuumCoulomb.AffinePhysicalThreshold
+
+abbrev Input := CenteredPhysicalThreshold.Input × (ℚ × (List CoulombPairSum.Point × List ℚ))
+
+def pairPrecision (x : Input) : ℕ :=
+  (8*x.1.1.1^3+1)*(2*(x.1.2.2.1+1))
+
+def pairValue (rho : ℕ) (x : Input) : ℚ :=
+  CoulombPairSum.value rho (pairPrecision x,x.2.2.1)
+
+def finiteValue (rho : ℕ) (x : Input) : ℚ×ℚ :=
+  (x.2.1^2*(x.1.2.2.2.1-x.2.2.2.sum)-pairValue rho x,
+   x.2.1^2*(x.1.2.2.2.2-x.2.2.2.sum)-pairValue rho x)
+
+def argument (rho : ℕ) (x : Input) : CenteredPhysicalThreshold.Input :=
+  (x.1.1,(x.1.2.1,(2*(x.1.2.2.1+1),finiteValue rho x)))
+
+def value (rho : ℕ) (x : Input) : ℚ×ℚ :=
+  CenteredPhysicalThreshold.value rho (argument rho x)
+
+def exactFinite (x : Input) (v : ℝ) : ℝ×ℝ :=
+  ((x.2.1:ℝ)^2*((x.1.2.2.2.1:ℝ)-(x.2.2.2.sum:ℝ))-v,
+   (x.2.1:ℝ)^2*((x.1.2.2.2.2:ℝ)-(x.2.2.2.sum:ℝ))-v)
+
+def exactValue (rho : ℕ) (x : Input) (v : ℝ) : ℝ×ℝ :=
+  (CenteredPhysicalThreshold.actualOffset rho x.1+
+      (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*(exactFinite x v).1,
+   CenteredPhysicalThreshold.actualOffset rho x.1+
+      (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*(exactFinite x v).2)
+
+theorem pair_budget (rho : ℕ) (hrho : 0 < rho) (x : Input) :
+    (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)/(pairPrecision x+1:ℝ) ≤
+      1/(2*((x.1.2.2.1:ℝ)+1)) := by
+  have ha := CenteredPhysicalThreshold.amplification_bound rho x.1.1.1 hrho
+  have hp : 0 < 2*((x.1.2.2.1:ℝ)+1) := by positivity
+  have hd : 0 < (pairPrecision x:ℝ)+1 := by positivity
+  apply (div_le_div_iff₀ hd hp).mpr
+  have hm := mul_le_mul_of_nonneg_right ha.2 hp.le
+  simp only [pairPrecision,Nat.cast_mul,Nat.cast_add,Nat.cast_one,Nat.cast_pow,
+    Nat.cast_ofNat]
+  nlinarith
+
+theorem reference_budget (x : Input) :
+    1/((2*(x.1.2.2.1+1):ℕ)+1:ℝ) ≤ 1/(2*((x.1.2.2.1:ℝ)+1)) := by
+  apply one_div_le_one_div_of_le (by positivity)
+  simp only [Nat.cast_add,Nat.cast_mul,Nat.cast_ofNat,Nat.cast_one]
+  linarith
+
+theorem value_error (rho : ℕ) (hrho : 0 < rho) (x : Input)
+    (hmesh : 0 < x.1.1.1) (v : ℝ)
+    (hv : |(pairValue rho x:ℝ)-v| ≤ 1/(pairPrecision x+1:ℝ)) :
+    |((value rho x).1:ℝ)-(exactValue rho x v).1| ≤ 1/(x.1.2.2.1+1:ℝ) ∧
+    |((value rho x).2:ℝ)-(exactValue rho x v).2| ≤ 1/(x.1.2.2.1+1:ℝ) := by
+  have ha := CenteredPhysicalThreshold.amplification_bound rho x.1.1.1 hrho
+  have hp : 0 < (x.1.2.2.1:ℝ)+1 := by positivity
+  have hoff := (CenteredPhysicalThreshold.offset_error rho hrho (argument rho x) hmesh).trans
+    (reference_budget x)
+  have hpair : (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*
+      |(pairValue rho x:ℝ)-v| ≤ 1/(2*((x.1.2.2.1:ℝ)+1)) := by
+    apply (mul_le_mul_of_nonneg_left hv ha.1).trans
+    simpa only [mul_one_div] using pair_budget rho hrho x
+  have hsum : 1/(2*((x.1.2.2.1:ℝ)+1))+1/(2*((x.1.2.2.1:ℝ)+1)) =
+      1/((x.1.2.2.1:ℝ)+1) := by
+    field_simp [hp.ne']
+    ring
+  have hid1 : ((value rho x).1:ℝ)-(exactValue rho x v).1 =
+      ((CenteredPhysicalThreshold.offset rho (argument rho x):ℝ)-CenteredPhysicalThreshold.actualOffset rho x.1)-
+      (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*((pairValue rho x:ℝ)-v) := by
+    simp only [value,CenteredPhysicalThreshold.value,exactValue,exactFinite,argument,finiteValue,
+      Rat.cast_add,Rat.cast_sub,Rat.cast_mul,Rat.cast_pow]
+    ring
+  have hid2 : ((value rho x).2:ℝ)-(exactValue rho x v).2 =
+      ((CenteredPhysicalThreshold.offset rho (argument rho x):ℝ)-CenteredPhysicalThreshold.actualOffset rho x.1)-
+      (CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*((pairValue rho x:ℝ)-v) := by
+    simp only [value,CenteredPhysicalThreshold.value,exactValue,exactFinite,argument,finiteValue,
+      Rat.cast_add,Rat.cast_sub,Rat.cast_mul,Rat.cast_pow]
+    ring
+  have hoff' : |(CenteredPhysicalThreshold.offset rho (argument rho x):ℝ)-
+      CenteredPhysicalThreshold.actualOffset rho x.1| ≤ 1/(2*((x.1.2.2.1:ℝ)+1)) := hoff
+  have htri := abs_sub_le ((CenteredPhysicalThreshold.offset rho (argument rho x):ℝ)-
+    CenteredPhysicalThreshold.actualOffset rho x.1) 0
+    ((CenteredPhysicalThreshold.amplification rho x.1.1.1:ℝ)*((pairValue rho x:ℝ)-v))
+  simp only [sub_zero,zero_sub,abs_neg] at htri
+  have hbound := htri.trans
+    (add_le_add hoff' (by simpa only [abs_mul,abs_of_nonneg ha.1] using hpair))
+  rw [hsum] at hbound
+  constructor
+  · rw [hid1]
+    exact hbound
+  · rw [hid2]
+    exact hbound
+
+theorem actual_error (rho : ℕ) (hrho : 0 < rho) (x : Input)
+    (hmesh : 0 < x.1.1.1) {m : ℕ}
+    (u : Fin m → CoulombPairSum.Point) (hu : Function.Injective u)
+    (hsites : x.2.2.1 = List.ofFn u) :
+    let v := CoulombPairSum.exactTotal (GaussianFrequency.frequency rho) u
+    |((value rho x).1:ℝ)-(exactValue rho x v).1| ≤ 1/(x.1.2.2.1+1:ℝ) ∧
+    |((value rho x).2:ℝ)-(exactValue rho x v).2| ≤ 1/(x.1.2.2.1+1:ℝ) := by
+  apply value_error rho hrho x hmesh
+  simpa only [pairValue,hsites] using
+    CoulombPairSum.error rho (pairPrecision x) hrho u hu
+
+theorem gap (rho : ℕ) (x : Input) :
+    (value rho x).2-(value rho x).1 =
+      CenteredPhysicalThreshold.amplification rho x.1.1.1*x.2.1^2*
+        (x.1.2.2.2.2-x.1.2.2.2.1) := by
+  rw [value,CenteredPhysicalThreshold.gap]
+  simp only [argument,finiteValue]
+  ring
+
+end ContinuumCoulomb.AffinePhysicalThreshold
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/ApproximateBisection.lean

@@ -0,0 +1,220 @@
+import Mathlib.Analysis.SpecialFunctions.Pow.Real
+import Mathlib.Data.Rat.Cast.Order
+import Mathlib.Tactic
+
+namespace OAI
+
+/-! Approximate rational bisection for a Lipschitz residual.  A numerically
+ambiguous sign terminates with a certified residual bound; otherwise the
+true endpoint signs are preserved.  No monotonicity or derivative lower
+bound is required. -/
+
+namespace ContinuumCoulomb.ApproximateBisection
+
+structure Interval where
+  lo : ℚ
+  hi : ℚ
+  settled : Bool
+  deriving DecidableEq
+
+def midpoint (s : Interval) : ℚ := (s.lo + s.hi) / 2
+
+def width (s : Interval) : ℝ := (s.hi : ℝ) - s.lo
+
+def step (δ : ℚ) (evaluate : ℚ → ℚ) (s : Interval) : Interval :=
+  if s.settled then s
+  else if δ < evaluate (midpoint s) then ⟨midpoint s, s.hi, false⟩
+  else if evaluate (midpoint s) < -δ then ⟨s.lo, midpoint s, false⟩
+  else ⟨midpoint s, midpoint s, true⟩
+
+def initial (a b : ℚ) : Interval := ⟨a, b, false⟩
+
+def run (δ : ℚ) (evaluate : ℚ → ℚ) (a b : ℚ) (n : ℕ) : Interval :=
+  (step δ evaluate)^[n] (initial a b)
+
+@[simp] theorem midpoint_cast (s : Interval) :
+    (midpoint s : ℝ) = ((s.lo : ℝ) + s.hi) / 2 := by
+  simp [midpoint]
+
+theorem midpoint_mem (s : Interval) (h : s.lo ≤ s.hi) :
+    s.lo ≤ midpoint s ∧ midpoint s ≤ s.hi := by
+  dsimp [midpoint]
+  constructor <;> linarith
+
+/-- The invariant concerns actual residual values, not numerical signs. -/
+structure Invariant (a b : ℚ) (f : ℝ → ℝ) (δ : ℚ) (s : Interval) : Prop where
+  lower : a ≤ s.lo
+  upper : s.hi ≤ b
+  ordered : s.lo ≤ s.hi
+  certified : s.settled = true → s.lo = s.hi ∧ |f s.lo| ≤ 2 * (δ : ℝ)
+  signs : s.settled = false → 0 ≤ f s.lo ∧ f s.hi ≤ 0
+
+theorem initial_invariant {a b δ : ℚ} {f : ℝ → ℝ}
+    (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0) :
+    Invariant a b f δ (initial a b) := by
+  refine ⟨le_rfl, le_rfl, hab, ?_, ?_⟩
+  · simp [initial]
+  · intro _
+    exact ⟨ha, hb⟩
+
+theorem step_invariant {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ}
+    (_hδ : 0 ≤ δ)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ))
+    {s : Interval} (hs : Invariant a b f δ s) :
+    Invariant a b f δ (step δ evaluate s) := by
+  have hm := midpoint_mem s hs.ordered
+  have he := abs_le.mp (heval (midpoint s) ⟨hs.lower.trans hm.1, hm.2.trans hs.upper⟩)
+  unfold step
+  split_ifs with hd hp hn
+  · exact hs
+  · have hp' : (δ : ℝ) < evaluate (midpoint s) := by exact_mod_cast hp
+    refine ⟨hs.lower.trans hm.1, hs.upper, hm.2, ?_, ?_⟩
+    · simp
+    · intro _
+      exact ⟨by linarith [he.2], (hs.signs (by simpa using hd)).2⟩
+  · have hn' : (evaluate (midpoint s) : ℝ) < -(δ : ℝ) := by exact_mod_cast hn
+    refine ⟨hs.lower, hm.2.trans hs.upper, hm.1, ?_, ?_⟩
+    · simp
+    · intro _
+      exact ⟨(hs.signs (by simpa using hd)).1, by linarith [he.1]⟩
+  · have hp' : (evaluate (midpoint s) : ℝ) ≤ δ := by exact_mod_cast le_of_not_gt hp
+    have hn' : -(δ : ℝ) ≤ evaluate (midpoint s) := by exact_mod_cast le_of_not_gt hn
+    refine ⟨hs.lower.trans hm.1, hm.2.trans hs.upper, le_rfl, ?_, ?_⟩
+    · intro _
+      refine ⟨rfl, abs_le.mpr ?_⟩
+      constructor <;> linarith [he.1, he.2]
+    · simp
+
+theorem step_width {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ}
+    {s : Interval} (hs : Invariant a b f δ s) :
+    width (step δ evaluate s) ≤ width s / 2 := by
+  have ho : (s.lo : ℝ) ≤ s.hi := by exact_mod_cast hs.ordered
+  unfold step
+  split_ifs with hd hp hn
+  · have heq := (hs.certified hd).1
+    simp only [width, heq, sub_self, zero_div, le_refl]
+  · simp only [width, midpoint_cast]
+    linarith
+  · simp only [width, midpoint_cast]
+    linarith
+  · simp only [width, sub_self]
+    linarith
+
+theorem run_invariant {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ}
+    (hδ : 0 ≤ δ) (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ)) (n : ℕ) :
+    Invariant a b f δ (run δ evaluate a b n) := by
+  induction n with
+  | zero => exact initial_invariant hab ha hb
+  | succ n ih =>
+    change Invariant a b f δ ((step δ evaluate)^[n + 1] (initial a b))
+    rw [Function.iterate_succ_apply']
+    exact step_invariant hδ heval ih
+
+theorem run_width {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ}
+    (hδ : 0 ≤ δ) (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ)) (n : ℕ) :
+    width (run δ evaluate a b n) ≤ ((b : ℝ) - a) / 2 ^ n := by
+  induction n with
+  | zero => simp [run, initial, width]
+  | succ n ih =>
+    have hw := step_width (evaluate := evaluate) (run_invariant hδ hab ha hb heval n)
+    have hrun : run δ evaluate a b (n + 1) = step δ evaluate (run δ evaluate a b n) :=
+      Function.iterate_succ_apply' _ _ _
+    rw [hrun]
+    calc
+      width (step δ evaluate (run δ evaluate a b n)) ≤
+          width (run δ evaluate a b n) / 2 := hw
+      _ ≤ (((b : ℝ) - a) / 2 ^ n) / 2 := div_le_div_of_nonneg_right ih (by norm_num)
+      _ = ((b : ℝ) - a) / 2 ^ (n + 1) := by rw [pow_succ, div_div]
+
+theorem invariant_residual {a b δ : ℚ} {f : ℝ → ℝ} {L : ℝ}
+    (hδ : 0 ≤ δ) (hL : 0 ≤ L)
+    (hLip : ∀ x ∈ Set.Icc (a : ℝ) b, ∀ y ∈ Set.Icc (a : ℝ) b,
+      |f x - f y| ≤ L * |x - y|)
+    {s : Interval} (hs : Invariant a b f δ s) :
+    |f (midpoint s)| ≤ 2 * (δ : ℝ) + L * width s := by
+  have hl : (a : ℝ) ≤ s.lo := by exact_mod_cast hs.lower
+  have hu : (s.hi : ℝ) ≤ b := by exact_mod_cast hs.upper
+  have ho : (s.lo : ℝ) ≤ s.hi := by exact_mod_cast hs.ordered
+  have hm := midpoint_mem s hs.ordered
+  have hmlo : (s.lo : ℝ) ≤ midpoint s := by exact_mod_cast hm.1
+  have hmhi : (midpoint s : ℝ) ≤ s.hi := by exact_mod_cast hm.2
+  have hw : 0 ≤ width s := sub_nonneg.mpr ho
+  by_cases hd : s.settled = true
+  · obtain ⟨heq, herr⟩ := hs.certified hd
+    have he : midpoint s = s.lo := by simp [midpoint, heq]
+    rw [he]
+    exact herr.trans (le_add_of_nonneg_right (mul_nonneg hL hw))
+  · have hsign := hs.signs (by simpa using hd)
+    have hmemb : (midpoint s : ℝ) ∈ Set.Icc (a : ℝ) b := ⟨hl.trans hmlo, hmhi.trans hu⟩
+    have hleft := hLip (midpoint s) hmemb s.lo ⟨hl, ho.trans hu⟩
+    have hright := hLip (midpoint s) hmemb s.hi ⟨hl.trans ho, hu⟩
+    rw [abs_of_nonneg (sub_nonneg.mpr hmlo)] at hleft
+    rw [abs_of_nonpos (sub_nonpos.mpr hmhi)] at hright
+    have hlw : L * ((midpoint s : ℝ) - s.lo) ≤ L * width s :=
+      mul_le_mul_of_nonneg_left (by dsimp [width]; linarith) hL
+    have hrw : L * -((midpoint s : ℝ) - s.hi) ≤ L * width s :=
+      mul_le_mul_of_nonneg_left (by dsimp [width]; linarith) hL
+    have hδ' : 0 ≤ (δ : ℝ) := by exact_mod_cast hδ
+    apply abs_le.mpr
+    constructor
+    · have h := (neg_le_abs (f (midpoint s) - f s.lo)).trans hleft
+      linarith [hsign.1]
+    · have h := (le_abs_self (f (midpoint s) - f s.hi)).trans hright
+      linarith [hsign.2]
+
+/-- After `n` steps the returned rational has residual at most numerical
+ambiguity plus the Lipschitz constant times the halved interval width. -/
+theorem run_residual {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ} {L : ℝ}
+    (hδ : 0 ≤ δ) (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0) (hL : 0 ≤ L)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ))
+    (hLip : ∀ x ∈ Set.Icc (a : ℝ) b, ∀ y ∈ Set.Icc (a : ℝ) b,
+      |f x - f y| ≤ L * |x - y|) (n : ℕ) :
+    |f (midpoint (run δ evaluate a b n))| ≤
+      2 * (δ : ℝ) + L * (((b : ℝ) - a) / 2 ^ n) := by
+  exact (invariant_residual hδ hL hLip (run_invariant hδ hab ha hb heval n)).trans
+    (add_le_add_right (mul_le_mul_of_nonneg_left (run_width hδ hab ha hb heval n) hL) _)
+
+theorem run_mem {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ}
+    (hδ : 0 ≤ δ) (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ)) (n : ℕ) :
+    midpoint (run δ evaluate a b n) ∈ Set.Icc a b := by
+  have hi := run_invariant hδ hab ha hb heval n
+  have hm := midpoint_mem _ hi.ordered
+  exact ⟨hi.lower.trans hm.1, hm.2.trans hi.upper⟩
+
+/-- Binary magnitude bounds give a number of bisection steps linear in
+the requested precision and the magnitude exponent. -/
+theorem run_binary_precision {a b δ : ℚ} {f : ℝ → ℝ} {evaluate : ℚ → ℚ} {L : ℝ}
+    (hδ : 0 ≤ δ) (hab : a ≤ b) (ha : 0 ≤ f a) (hb : f b ≤ 0) (hL : 0 ≤ L)
+    (heval : ∀ q ∈ Set.Icc a b, |(evaluate q : ℝ) - f q| ≤ (δ : ℝ))
+    (hLip : ∀ x ∈ Set.Icc (a : ℝ) b, ∀ y ∈ Set.Icc (a : ℝ) b,
+      |f x - f y| ≤ L * |x - y|) (B p : ℕ)
+    (hδp : (δ : ℝ) ≤ (2 ^ (p + 2))⁻¹)
+    (hLB : L ≤ 2 ^ B) (hwidth : (b : ℝ) - a ≤ 2 ^ B) :
+    |f (midpoint (run δ evaluate a b (2 * B + p + 1)))| ≤ (2 ^ p : ℝ)⁻¹ := by
+  have hw : 0 ≤ (b : ℝ) - a := sub_nonneg.mpr (by exact_mod_cast hab)
+  have hprod : L * ((b : ℝ) - a) ≤ (2 ^ B : ℝ) * 2 ^ B :=
+    mul_le_mul hLB hwidth hw (by positivity)
+  have hden : 0 ≤ (2 ^ (2 * B + p + 1) : ℝ)⁻¹ := by positivity
+  have herror := run_residual hδ hab ha hb hL heval hLip (2 * B + p + 1)
+  have hnum := mul_le_mul_of_nonneg_right hprod hden
+  have hexact : 2 * (2 ^ (p + 2) : ℝ)⁻¹ +
+      (2 ^ B * 2 ^ B) * (2 ^ (2 * B + p + 1) : ℝ)⁻¹ = (2 ^ p : ℝ)⁻¹ := by
+    rw [show 2 * B + p + 1 = B + B + (p + 1) by omega]
+    simp only [pow_add, pow_succ]
+    field_simp
+    ring
+  calc
+    |f (midpoint (run δ evaluate a b (2 * B + p + 1)))| ≤
+        2 * (δ : ℝ) + (L * ((b : ℝ) - a)) * (2 ^ (2 * B + p + 1) : ℝ)⁻¹ := by
+      simpa only [div_eq_mul_inv, mul_assoc] using herror
+    _ ≤ 2 * (2 ^ (p + 2) : ℝ)⁻¹ +
+        (2 ^ B * 2 ^ B) * (2 ^ (2 * B + p + 1) : ℝ)���¹ := by
+      linarith
+    _ = (2 ^ p : ℝ)⁻¹ := hexact
+
+end ContinuumCoulomb.ApproximateBisection
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/AtomicOutputs.lean

@@ -0,0 +1,100 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.HydrogenInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Nuclei.NuclearPromise
+
+namespace OAI
+
+/-! Fixed one-electron outputs for the decidable one-spin source branch.
+The only spectral input is the precisely stated published hydrogen bottom. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open MeasureTheory
+
+theorem oneElectron_antisymmetric (w : Coulomb.H1Vector 1) : Coulomb.Antisymmetric w := by
+  intro p s
+  have hp : p=1 := Subsingleton.elim _ _
+  subst p
+  filter_upwards [] with x
+  have hx : Coulomb.permute (1 : Equiv.Perm (Fin 1)) x=x := by ext i; rfl
+  simp [hx]
+
+def atomicData : UnitNuclearData where
+  nuclei := 1
+  nuclei_pos := by decide
+  position := fun _ => 0
+  distinct := fun _ _ _ => Subsingleton.elim _ _
+  electrons := 1
+  electrons_pos := by decide
+
+theorem atomic_form (w : FormState 1) : unitCoulombForm atomicData w = hydrogenForm 0 w.val := by
+  have ha (y : Position) : Coulomb.attraction atomicData.toNuclearData.toNuclei y =
+      Coulomb.coulombKernel y := by
+    unfold Coulomb.attraction
+    erw [Fin.sum_univ_one]
+    have hr : realPosition (0 : Fin 3 → ℚ)=0 := by ext i; simp [realPosition]
+    simp only [atomicData,UnitNuclearData.toNuclearData,NuclearData.toNuclei,
+      Nat.cast_one,hr,sub_zero,one_mul]
+  have hp : Coulomb.pairEnergy w.val=0 := by simp [Coulomb.pairEnergy]
+  change Coulomb.kinetic w.val-Coulomb.nuclearEnergy atomicData.toNuclearData.toNuclei w.val+
+    Coulomb.pairEnergy w.val = hydrogenForm 0 w.val
+  simp only [hp,add_zero,Coulomb.nuclearEnergy,ha,Fin.sum_univ_one,
+    hydrogenForm,singlePoleEnergy,sub_zero]
+
+theorem atomic_ground : unitGroundEnergy atomicData = hydrogenEnergy 0 := by
+  unfold unitGroundEnergy hydrogenEnergy oneElectronEnergy
+  congr 1
+  ext e
+  constructor
+  · rintro ⟨w,hw,rfl⟩
+    exact ⟨w.val,hw,congrArg (fun t : ℝ => (t:EReal)) (atomic_form w)⟩
+  · rintro ⟨w,hw,rfl⟩
+    exact ⟨⟨w,oneElectron_antisymmetric w⟩,hw,
+      congrArg (fun t : ℝ => (t:EReal)) (atomic_form ⟨w,oneElectron_antisymmetric w⟩).symm⟩
+
+def atomicOutput (yes : Bool) : UnitCoulomb where
+  nuclei := [⟨BinaryRational.ofRat 0,BinaryRational.ofRat 0,BinaryRational.ofRat 0⟩]
+  electrons := 1
+  lower := BinaryRational.ofRat (if yes then 0 else -2)
+  upper := BinaryRational.ofRat (if yes then 1 else -1)
+
+theorem atomicOutput_valid (yes : Bool) : (atomicOutput yes).Valid := by
+  refine ⟨by change 0<1; decide,by change 0<1; decide,?_,?_,?_,?_,?_⟩
+  · intro i
+    change Fin 1 at i
+    fin_cases i
+    change (0:ℕ)<1 ∧ (0:ℕ)<1 ∧ (0:ℕ)<1
+    decide
+  · intro i j _
+    apply Fin.ext
+    have hi : i.val<1 := i.isLt
+    have hj : j.val<1 := j.isLt
+    omega
+  · cases yes <;> decide
+  · cases yes <;> decide
+  · cases yes <;> norm_num [atomicOutput]
+
+theorem atomicOutput_data (yes : Bool) (h : (atomicOutput yes).Valid) :
+    (atomicOutput yes).toData h = atomicData := by
+  cases yes <;> unfold UnitCoulomb.toData atomicOutput atomicData <;>
+    congr 1 <;> funext i <;> fin_cases i <;>
+    ext j <;> fin_cases j <;> norm_num [atomicOutput,UnitCoulomb.toData,atomicData,BinaryPosition.value]
+
+theorem atomicOutput_yes (hh : PublishedHydrogenBottom) : atomicOutput true ∈ unitCoulombPromise.yes := by
+  refine ⟨atomicOutput_valid true,?_⟩
+  rw [atomicOutput_data,atomic_ground,hh]
+  simp only [atomicOutput,BinaryRational.value_ofRat,ite_true,Rat.cast_zero]
+  change ((-1/2:ℝ):EReal) ≤ ((0:ℝ):EReal)
+  exact EReal.coe_le_coe (by norm_num)
+
+theorem atomicOutput_no (hh : PublishedHydrogenBottom) : atomicOutput false ∈ unitCoulombPromise.no := by
+  refine ⟨atomicOutput_valid false,?_⟩
+  rw [atomicOutput_data,atomic_ground,hh]
+  simp only [atomicOutput,BinaryRational.value_ofRat,Bool.false_eq_true,ite_false,Rat.cast_neg,Rat.cast_one]
+  change ((-1:ℝ):EReal) ≤ ((-1/2:ℝ):EReal)
+  exact EReal.coe_le_coe (by norm_num)
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/BoundedFormCross.lean

@@ -0,0 +1,101 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.BoundedPotentialOperator
+
+namespace OAI
+
+/-! Polarization of the actual bounded-potential quadratic form on the
+full weak-H1 graph. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators
+namespace ContinuumCoulomb
+
+theorem h1Coordinates_add {n : ℕ} (u v : Coulomb.H1Vector n) :
+    h1Coordinates (u.add v) = h1Coordinates u+h1Coordinates v := by
+  funext a
+  apply Lp.ext
+  filter_upwards [(h1Coordinate_memLp (u.add v) a).coeFn_toLp,
+    (h1Coordinate_memLp u a).coeFn_toLp, (h1Coordinate_memLp v a).coeFn_toLp,
+    Lp.coeFn_add (h1Coordinates u a) (h1Coordinates v a)] with x huv hu hv ha
+  change h1Coordinates (u.add v) a x = _ at huv
+  change h1Coordinates u a x = _ at hu
+  change h1Coordinates v a x = _ at hv
+  change h1Coordinates (u.add v) a x = (h1Coordinates u a+h1Coordinates v a) x
+  rw [ha]
+  simp only [Pi.add_apply]
+  rw [hu,hv,huv]
+  cases a <;> rfl
+
+def graphBoundedCross {n : ℕ}
+    (A : Lp ℂ 2 (volume : Measure (Configuration n)) →L[ℝ]
+      Lp ℂ 2 (volume : Measure (Configuration n))) (f g : H1Coordinates n) : ℝ :=
+  (1/2:ℝ)*(∑ s, ∑ a, inner ℝ (f (Sum.inr (s,a))) (g (Sum.inr (s,a))))+
+    ∑ s, inner ℝ (f (Sum.inl s)) (A (g (Sum.inl s)))
+
+theorem graphBoundedForm_add {n : ℕ}
+    (A : Lp ℂ 2 (volume : Measure (Configuration n)) →L[ℝ]
+      Lp ℂ 2 (volume : Measure (Configuration n)))
+    (hA : ∀ x y, inner ℝ x (A y) = inner ℝ y (A x)) (f g : H1Coordinates n) :
+    graphBoundedForm A (f+g) = graphBoundedForm A f+graphBoundedForm A g+2*graphBoundedCross A f g := by
+  have hx (s : SpinConfiguration n) :
+      inner ℝ (g (Sum.inl s)) (A (f (Sum.inl s))) =
+        inner ℝ (f (Sum.inl s)) (A (g (Sum.inl s))) := hA _ _
+  simp only [graphBoundedForm,graphKinetic,graphBoundedCross,Pi.add_apply,
+    norm_add_sq_real,map_add,inner_add_left,inner_add_right,hx,
+    Finset.sum_add_distrib,← Finset.mul_sum]
+  ring
+
+theorem boundedPotential_operator_symmetric {n : ℕ} (V : Configuration n → ℝ)
+    (hV : Continuous V) (B : ℝ) (hB : ∀ x, |V x| ≤ B)
+    (f g : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    inner ℝ f (BoundedPotential.operator V hV B hB g) =
+      inner ℝ g (BoundedPotential.operator V hV B hB f) := by
+  rw [L2.inner_def,L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [BoundedPotential.operator_ae V hV B hB f,
+    BoundedPotential.operator_ae V hV B hB g] with x hf hg
+  rw [hf,hg,← Complex.real_smul,← Complex.real_smul,
+    real_inner_smul_right,real_inner_smul_right,real_inner_comm]
+
+theorem boundedPotentialForm_add {n : ℕ} (V : Configuration n → ℝ)
+    (hV : Continuous V) (B : ℝ) (hB : ∀ x, |V x| ≤ B) (u v : Coulomb.H1Vector n) :
+    boundedPotentialForm V (u.add v) = boundedPotentialForm V u+boundedPotentialForm V v+
+      2*graphBoundedCross (BoundedPotential.operator V hV B hB) (h1Coordinates u) (h1Coordinates v) := by
+  simp only [boundedPotentialForm_eq_graph V hV B hB,h1Coordinates_add]
+  exact graphBoundedForm_add _ (boundedPotential_operator_symmetric V hV B hB) _ _
+
+
+theorem Lp_real_inner_eq_re {n : ℕ}
+    (f g : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    inner ℝ f g = (inner ℂ f g).re := by
+  rw [L2.inner_def,L2.inner_def]
+  have hr := integral_re (L2.integrable_inner (𝕜 := ℂ) f g)
+  change (∫ x, (inner ℂ (f x) (g x)).re) = (∫ x, inner ℂ (f x) (g x)).re at hr
+  rw [← hr]
+  apply integral_congr_ae
+  filter_upwards [] with x
+  exact real_inner_eq_re_inner ℂ (f x) (g x)
+
+def graphComplexCross {n : ℕ}
+    (A : Lp ℂ 2 (volume : Measure (Configuration n)) →L[ℝ]
+      Lp ℂ 2 (volume : Measure (Configuration n))) (f g : H1Coordinates n) : ℂ :=
+  (1/2:ℂ)*(∑ s, ∑ a, inner ℂ (f (Sum.inr (s,a))) (g (Sum.inr (s,a))))+
+    ∑ s, inner ℂ (f (Sum.inl s)) (A (g (Sum.inl s)))
+
+private theorem re_finite_sum {ι : Type*} [Fintype ι] (z : ι → ℂ) :
+    (∑ i, z i).re = ∑ i, (z i).re :=
+  map_sum Complex.reLm z Finset.univ
+
+theorem graphBoundedCross_eq_re {n : ℕ}
+    (A : Lp ℂ 2 (volume : Measure (Configuration n)) →L[ℝ]
+      Lp ℂ 2 (volume : Measure (Configuration n))) (f g : H1Coordinates n) :
+    graphBoundedCross A f g = (graphComplexCross A f g).re := by
+  simp only [graphBoundedCross,graphComplexCross,Lp_real_inner_eq_re,Complex.add_re,
+    Complex.mul_re,re_finite_sum]
+  norm_num
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/BoundedPotentialOperator.lean

@@ -0,0 +1,109 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.H1BoundedForm
+
+namespace OAI
+
+/-! Actual bounded real multiplication potentials on the weak-H1 graph. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators
+namespace ContinuumCoulomb
+namespace BoundedPotential
+
+variable {n : ℕ} (V : Configuration n → ℝ) (hV : Continuous V)
+  (B : ℝ) (hB : ∀ x, |V x| ≤ B)
+
+include hV hB in
+theorem product_memLp (u : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    MemLp (fun x => (V x : ℂ) * u x) 2 := by
+  apply (Lp.memLp u).of_le_mul (c := B)
+    ((Complex.continuous_ofReal.comp hV).aestronglyMeasurable.mul (Lp.aestronglyMeasurable u))
+  filter_upwards [] with x
+  change ‖(V x : ℂ) * u x‖ ≤ B * ‖u x‖
+  rw [norm_mul, Complex.norm_real, Real.norm_eq_abs]
+  exact mul_le_mul_of_nonneg_right (hB x) (norm_nonneg _)
+
+def value (u : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    Lp ℂ 2 (volume : Measure (Configuration n)) :=
+  (product_memLp V hV B hB u).toLp (fun x => (V x : ℂ)*u x)
+
+theorem value_ae (u : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    value V hV B hB u =ᵐ[volume] fun x => (V x : ℂ)*u x :=
+  (product_memLp V hV B hB u).coeFn_toLp
+
+private def linear : Lp ℂ 2 (volume : Measure (Configuration n)) →ₗ[ℂ]
+    Lp ℂ 2 (volume : Measure (Configuration n)) where
+  toFun := value V hV B hB
+  map_add' u v := by
+    apply Lp.ext
+    filter_upwards [value_ae V hV B hB (u+v), value_ae V hV B hB u,
+      value_ae V hV B hB v, Lp.coeFn_add u v,
+      Lp.coeFn_add (value V hV B hB u) (value V hV B hB v)] with x he hu hv hs ht
+    simp only [he, hs, ht, hu, hv, Pi.add_apply]
+    ring
+  map_smul' c u := by
+    change value V hV B hB (c • u) = c • value V hV B hB u
+    apply Lp.ext
+    filter_upwards [value_ae V hV B hB (c • u), value_ae V hV B hB u,
+      Lp.coeFn_smul c u, Lp.coeFn_smul c (value V hV B hB u)] with x he hu hs ht
+    simp only [he, hs, ht, hu, Pi.smul_apply, smul_eq_mul]
+    ring
+
+def operator : Lp ℂ 2 (volume : Measure (Configuration n)) →L[ℝ]
+    Lp ℂ 2 (volume : Measure (Configuration n)) :=
+  ((linear V hV B hB).mkContinuous B (fun u =>
+    Lp.norm_le_mul_norm_of_ae_le_mul (by
+      filter_upwards [value_ae V hV B hB u] with x hx
+      change ‖value V hV B hB u x‖ ≤ B * ‖u x‖
+      rw [hx, norm_mul, Complex.norm_real, Real.norm_eq_abs]
+      exact mul_le_mul_of_nonneg_right (hB x) (norm_nonneg _)))).restrictScalars ℝ
+
+theorem operator_ae (u : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    operator V hV B hB u =ᵐ[volume] fun x => (V x : ℂ)*u x := value_ae V hV B hB u
+
+theorem operator_pairing (u : Lp ℂ 2 (volume : Measure (Configuration n))) :
+    inner ℝ u (operator V hV B hB u) = ∫ x, V x * ‖u x‖^2 := by
+  rw [L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [operator_ae V hV B hB u] with x hx
+  rw [hx, ← Complex.real_smul, real_inner_smul_right, real_inner_self_eq_norm_sq]
+
+end BoundedPotential
+def boundedPotentialForm {n : ℕ} (V : Configuration n → ℝ) (u : Coulomb.H1Vector n) : ℝ :=
+  Coulomb.kinetic u + ∑ s, ∫ x, V x * ‖u.value s x‖^2
+
+theorem boundedPotentialForm_eq_graph {n : ℕ} (V : Configuration n → ℝ)
+    (hV : Continuous V) (B : ℝ) (hB : ∀ x, |V x| ≤ B) (u : Coulomb.H1Vector n) :
+    boundedPotentialForm V u =
+      graphBoundedForm (BoundedPotential.operator V hV B hB) (h1Coordinates u) := by
+  unfold boundedPotentialForm graphBoundedForm
+  rw [kinetic_eq_graphKinetic]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro s _
+  rw [BoundedPotential.operator_pairing]
+  apply integral_congr_ae
+  filter_upwards [(h1Coordinate_memLp u (Sum.inl s)).coeFn_toLp] with x hx
+  change h1Coordinates u (Sum.inl s) x = u.value s x at hx
+  rw [hx]
+
+theorem boundedPotential_lower_of_compact (hpublished : PublishedSobolevSmoothDensity)
+    {n : ℕ} (V : Configuration n → ℝ) (hV : Continuous V) (B : ℝ)
+    (hB : ∀ x, |V x| ≤ B) (E : ℝ)
+    (hcompact : ∀ v : Coulomb.H1Vector n,
+      (∀ s, ContDiff ℝ 1 (v.value s) ∧ HasCompactSupport (v.value s)) →
+      (∀ s a x, v.gradient s a x =
+        fderiv ℝ (v.value s) x (EuclideanSpace.single a 1)) →
+      E*Coulomb.mass v ≤ boundedPotentialForm V v)
+    (u : Coulomb.H1Vector n) : E*Coulomb.mass u ≤ boundedPotentialForm V u := by
+  rw [boundedPotentialForm_eq_graph V hV B hB]
+  apply boundedForm_lower_of_compact hpublished _ E
+  intro v hv hd
+  rw [← boundedPotentialForm_eq_graph V hV B hB]
+  exact hcompact v hv hd
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedBisection.lean

@@ -0,0 +1,96 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationComponents
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombTargetLipschitz
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.BisectionProgram
+
+namespace OAI
+
+/-! Deterministic bisection with the concrete hopping/Coulomb evaluator.
+The premises are endpoint signs and the already proved separated-site gap;
+there is no numeric evaluator assumption. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+open ExactQuantumFactoring.BitStackProgram
+
+abbrev BisectionInput := ℕ × (Environment × (ℚ × ℚ))
+
+def bisectionInputCode : BisectionInput → List Bool :=
+  prodCode unaryCode (prodCode environmentCode (prodCode ratCode ratCode))
+
+def tolerance (e : Environment) : ℚ := 1 / ((e.1.2 : ℚ) + 1)
+
+def bisectionArgument (x : BisectionInput) : BisectionProgram.Input Environment :=
+  (x.1, (x.2.1, (tolerance x.2.1, x.2.2)))
+
+def bisect (rho : ℕ) (x : BisectionInput) : ℚ :=
+  BisectionProgram.approximate (value rho) (bisectionArgument x)
+
+noncomputable opaque bisectionArgumentProgram : Procedure bisectionInputCode
+    (BisectionProgram.inputCode environmentCode) bisectionArgument := by
+  let n := Procedure.first unaryCode (prodCode environmentCode (prodCode ratCode ratCode))
+  let tail := Procedure.second unaryCode (prodCode environmentCode (prodCode ratCode ratCode))
+  let env := (Procedure.first environmentCode (prodCode ratCode ratCode)).comp tail
+  let ends := (Procedure.second environmentCode (prodCode ratCode ratCode)).comp tail
+  let np := (Procedure.first (prodCode unaryCode unaryCode)
+    (prodCode unaryCode (prodCode ratCode ratCode))).comp env
+  let p := (Procedure.second unaryCode unaryCode).comp np
+  let p1 := Procedure.natToRat.comp (Procedure.unaryToBits.comp
+    (Procedure.unarySuccessor.comp p))
+  let delta := Procedure.ratInv.comp p1
+  exact (n.pair (env.pair (delta.pair ends))).congrFun (by
+    intro x
+    simp only [Function.comp_apply, id_eq, Nat.succ_eq_add_one, bisectionArgument,
+      tolerance, one_div, Nat.cast_add, Nat.cast_one]
+    )
+
+def residual (rho : ℕ) (e : Environment) (d : ℝ) : ℝ :=
+  (e.2.1 : ℝ) * planarHopping d -
+    coulombHoppingTarget (GaussianFrequency.frequency rho) e.2.2.1 e.2.2.2 d
+
+def residualLipschitz (rho : ℕ) (e : Environment) : ℝ :=
+  (e.2.1 : ℝ) * planarHoppingLipschitzConstant +
+    coulombTargetLipschitzConstant (GaussianFrequency.frequency rho) e.2.2.1 e.2.2.2
+
+theorem bisect_residual (rho : ℕ) (hrho : 0 < rho) (e : Environment) (a b : ℚ)
+    (hK : 0 ≤ e.2.2.2) (hKN : (e.2.2.2 : ℝ) ≤ e.1.1)
+    (hτ : 0 ≤ e.2.2.1) (hτ1 : e.2.2.1 ≤ 1) (hab : a ≤ b)
+    (haN : -(e.1.1 : ℝ) ≤ a) (hbN : (b : ℝ) ≤ e.1.1)
+    (ha : 0 ≤ residual rho e a) (hb : residual rho e b ≤ 0)
+    (hgap : ∀ r ∈ Set.Icc (a : ℝ) b,
+      localizedGramConstant (GaussianFrequency.frequency rho) ≤
+        localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+          localizedCoulombProfile (GaussianFrequency.frequency rho) r) (n : ℕ) :
+    |residual rho e (bisect rho (n, (e, (a, b))))| ≤
+      2 * ((e.1.2 : ℝ) + 1)⁻¹ +
+        residualLipschitz rho e * (((b : ℝ) - a) / 2 ^ n) := by
+  have hf : 0 < GaussianFrequency.frequency rho := Real.sqrt_pos.mpr (by
+    change 0 < 4 * Real.pi * (rho : ℝ)
+    positivity)
+  have hKr : (0 : ℝ) ≤ e.2.2.2 := by exact_mod_cast hK
+  have hτr : (0 : ℝ) ≤ e.2.2.1 := by exact_mod_cast hτ
+  have hLip0 : 0 ≤ residualLipschitz rho e := add_nonneg
+    (mul_nonneg (Nat.cast_nonneg _) (by positivity))
+    (coulombTargetLipschitzConstant_nonnegative _ _ hτr)
+  have heval (q : ℚ) (hq : q ∈ Set.Icc a b) :
+      |(value rho e q : ℝ) - residual rho e q| ≤ (tolerance e : ℝ) := by
+    have hqa : (a : ℝ) ≤ q := by exact_mod_cast hq.1
+    have hqb : (q : ℝ) ≤ b := by exact_mod_cast hq.2
+    have hqN : |(q : ℝ)| ≤ e.1.1 := abs_le.mpr ⟨haN.trans hqa, hqb.trans hbN⟩
+    have hg := (localizedGramConstant_positive hf).le.trans (hgap q ⟨hqa, hqb⟩)
+    have he := approximation_error rho hrho e q hK hKN hτ hτ1 hqN hg
+    simpa only [residual, coulombHoppingTarget, tolerance, Rat.cast_div,
+      Rat.cast_one, Rat.cast_add, Rat.cast_natCast, one_div, Rat.cast_inv] using he
+  have hLip (r : ℝ) (hr : r ∈ Set.Icc (a : ℝ) b)
+      (s : ℝ) (hs : s ∈ Set.Icc (a : ℝ) b) :
+      |residual rho e r - residual rho e s| ≤ residualLipschitz rho e * |r - s| :=
+    calibratedResidual_abs_sub hf hτr hKr (Nat.cast_nonneg _) r s (hgap r hr) (hgap s hs)
+  have ht : 0 ≤ tolerance e := by unfold tolerance; positivity
+  have h := BisectionProgram.residual (value rho) e ht hab ha hb hLip0 heval hLip n
+  simpa only [bisect, bisectionArgument, tolerance, Rat.cast_div, Rat.cast_one,
+    Rat.cast_add, Rat.cast_natCast, one_div, Rat.cast_inv] using h
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedBisectionLocation.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisectionSchedule
+
+namespace OAI
+
+/-! Every returned rational remains in its original search interval. This
+geometric invariant does not need an accuracy or residual-sign hypothesis. -/
+
+namespace ContinuumCoulomb
+
+private theorem bisection_step_nested (δ : ℚ) (evaluate : ℚ → ℚ)
+    {a b : ℚ} (s : ApproximateBisection.Interval)
+    (hs : a ≤ s.lo ∧ s.lo ≤ s.hi ∧ s.hi ≤ b) :
+    a ≤ (ApproximateBisection.step δ evaluate s).lo ∧
+      (ApproximateBisection.step δ evaluate s).lo ≤ (ApproximateBisection.step δ evaluate s).hi ∧
+      (ApproximateBisection.step δ evaluate s).hi ≤ b := by
+  have hm := ApproximateBisection.midpoint_mem s hs.2.1
+  unfold ApproximateBisection.step
+  split_ifs
+  · exact hs
+  · exact ⟨hs.1.trans hm.1, hm.2, hs.2.2⟩
+  · exact ⟨hs.1, hm.1, hm.2.trans hs.2.2⟩
+  · exact ⟨hs.1.trans hm.1, le_rfl, hm.2.trans hs.2.2⟩
+
+theorem bisection_run_nested (δ : ℚ) (evaluate : ℚ → ℚ) (a b : ℚ)
+    (hab : a ≤ b) (n : ℕ) :
+    a ≤ (ApproximateBisection.run δ evaluate a b n).lo ∧
+      (ApproximateBisection.run δ evaluate a b n).lo ≤
+        (ApproximateBisection.run δ evaluate a b n).hi ∧
+      (ApproximateBisection.run δ evaluate a b n).hi ≤ b := by
+  induction n with
+  | zero => exact ⟨le_rfl, hab, le_rfl⟩
+  | succ n ih =>
+    simpa only [ApproximateBisection.run, Function.iterate_succ_apply'] using
+      bisection_step_nested δ evaluate (ApproximateBisection.run δ evaluate a b n) ih
+
+theorem bisection_value_mem {E : Type} (evaluate : E → ℚ → ℚ) (e : E)
+    (δ a b : ℚ) (hab : a ≤ b) (n : ℕ) :
+    BisectionProgram.approximate evaluate (n, (e, (δ, (a, b)))) ∈ Set.Icc a b := by
+  obtain ⟨hp, hi⟩ := BisectionRegisters.iterate_interval δ (evaluate e)
+    (BisectionRegisters.initial a b) (BisectionRegisters.initial_den_pos a b) n
+  unfold BisectionProgram.approximate
+  rw [BisectionRegisters.middle_eq _ hp, hi, BisectionRegisters.initial_interval]
+  have hs := bisection_run_nested δ (evaluate e) a b hab n
+  have hm := ApproximateBisection.midpoint_mem (ApproximateBisection.run δ (evaluate e) a b n) hs.2.1
+  exact ⟨hs.1.trans hm.1, hm.2.trans hs.2.2⟩
+
+namespace CalibratedEvaluation
+
+theorem bisect_mem (rho : ℕ) (e : Environment) (a b : ℚ) (hab : a ≤ b) (n : ℕ) :
+    bisect rho (n, (e, (a, b))) ∈ Set.Icc a b :=
+  bisection_value_mem (value rho) e (tolerance e) a b hab n
+
+theorem scheduledValue_mem (rho : ℕ) (e : Environment) (a b : ℚ) (hab : a ≤ b) :
+    scheduledValue rho e a b ∈ Set.Icc a b :=
+  bisect_mem rho (refinedEnvironment e) a b hab (iterations rho e)
+
+end CalibratedEvaluation
+end ContinuumCoulomb
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedBisectionMachine.lean

@@ -0,0 +1,25 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CalibratedEvaluationProgram
+
+namespace OAI
+
+/-! Literal bisection with the certified calibrated-residual machine. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+open ExactQuantumFactoring.BitStackProgram
+
+noncomputable opaque bisectionProgram (rho : ℕ) : Procedure bisectionInputCode ratCode (bisect rho) :=
+  ((BisectionProgram.program (program rho)).comp bisectionArgumentProgram).congrFun
+    (by intro x; rfl)
+
+noncomputable def bisectionCertificate (rho : ℕ) :
+    Turing.TM2ComputableInPolyTime bisectionInputCode ratCode (bisect rho) :=
+  (bisectionProgram rho).toTM2
+
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedBisectionSchedule.lean

@@ -0,0 +1,95 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedLipschitzBound
+
+namespace OAI
+
+/-! Polynomial unary iteration and evaluation-precision choices for the
+actual calibrated bisection. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+
+def refinedEnvironment (e : Environment) : Environment :=
+  ((e.1.1, 8 * (e.1.2 + 1)), e.2)
+
+def iterations (rho : ℕ) (e : Environment) : ℕ :=
+  16 * lipschitzGuard rho * (e.2.1 + e.1.1 + 1) * (e.1.1 + 1) * (e.1.2 + 1)
+
+def scheduledValue (rho : ℕ) (e : Environment) (a b : ℚ) : ℚ :=
+  bisect rho (iterations rho e, (refinedEnvironment e, (a, b)))
+
+theorem bisection_scalar_budget {C A N S : ℝ} {n : ℕ}
+    (hC : 0 < C) (hA : 0 < A) (hN : 0 ≤ N) (hS : 0 < S)
+    (hn : (n : ℝ) = 16 * C * A * (N + 1) * S) :
+    2 * (8 * S + 1)⁻¹ + C * A * (2 * N) / 2 ^ n ≤ S⁻¹ := by
+  have hn0 : (0 : ℝ) < n := by rw [hn]; positivity
+  have hfirst : 2 * (8 * S + 1)⁻¹ ≤ (4 * S)⁻¹ := by
+    apply (mul_inv_le_iff₀ (by positivity)).mpr
+    apply (le_inv_mul_iff₀ (by positivity : (0 : ℝ) < 4 * S)).mpr
+    linarith
+  have hsecond : C * A * (2 * N) / 2 ^ n ≤ (8 * S)⁻¹ := by
+    calc
+      _ = C * A * (2 * N) * (2 : ℝ)⁻¹ ^ n := by rw [div_eq_mul_inv, inv_pow]
+      _ ≤ C * A * (2 * N) * ((n : ℝ) + 1)⁻¹ :=
+        mul_le_mul_of_nonneg_left (CoulombQuadratureSchedule.dyadic_le_inverse n) (by positivity)
+      _ ≤ C * A * (2 * (N + 1)) * (n : ℝ)⁻¹ := by
+        apply mul_le_mul
+        · gcongr
+          linarith
+        · exact inv_anti₀ hn0 (by linarith)
+        · positivity
+        · positivity
+      _ = (8 * S)⁻¹ := by
+        rw [hn]
+        field_simp [hC.ne', hA.ne', hS.ne', ne_of_gt (show 0 < N + 1 by linarith)]
+        ring
+  have hs := add_le_add hfirst hsecond
+  apply hs.trans
+  simp only [mul_inv_rev]
+  norm_num
+  nlinarith [inv_pos.mpr hS]
+
+theorem scheduled_residual (rho : ℕ) (hrho : 0 < rho) (e : Environment) (a b : ℚ)
+    (hK : (0 : ℚ) ≤ e.2.2.2) (hKN : (e.2.2.2 : ℝ) ≤ e.1.1)
+    (hτ : (0 : ℚ) ≤ e.2.2.1) (hτ1 : e.2.2.1 ≤ 1) (hab : a ≤ b)
+    (haN : -(e.1.1 : ℝ) ≤ a) (hbN : (b : ℝ) ≤ e.1.1)
+    (ha : 0 ≤ residual rho e a) (hb : residual rho e b ≤ 0)
+    (hgap : ∀ r ∈ Set.Icc (a : ℝ) b,
+      localizedGramConstant (GaussianFrequency.frequency rho) ≤
+        localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+          localizedCoulombProfile (GaussianFrequency.frequency rho) r) :
+    |residual rho e (scheduledValue rho e a b)| ≤ ((e.1.2 : ℝ) + 1)⁻¹ := by
+  have hK' : (0 : ℝ) ≤ e.2.2.2 := by exact_mod_cast hK
+  have hτ1' : (e.2.2.1 : ℝ) ≤ 1 := by exact_mod_cast hτ1
+  have he := bisect_residual rho hrho (refinedEnvironment e) a b
+    hK hKN hτ hτ1 hab haN hbN ha hb hgap (iterations rho e)
+  have hL := residualLipschitz_bound rho e hK' hKN hτ1'
+  have hwidth : (0 : ℝ) ≤ b - a := by exact_mod_cast sub_nonneg.mpr hab
+  have hwidth' : (b : ℝ) - a ≤ 2 * (e.1.1 : ℝ) := by linarith
+  have hcount : (iterations rho e : ℝ) =
+      16 * (lipschitzGuard rho : ℝ) * ((e.2.1 : ℝ) + e.1.1 + 1) *
+        ((e.1.1 : ℝ) + 1) * ((e.1.2 : ℝ) + 1) := by
+    simp only [iterations, Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add, Nat.cast_one]
+  have hC : (0 : ℝ) < lipschitzGuard rho := by exact_mod_cast lipschitzGuard_positive rho
+  have hA : (0 : ℝ) < (e.2.1 : ℝ) + e.1.1 + 1 := by positivity
+  have hbnd := bisection_scalar_budget hC hA (Nat.cast_nonneg e.1.1)
+    (show (0 : ℝ) < e.1.2 + 1 by positivity) hcount
+  have hterm : residualLipschitz rho e * (((b : ℝ) - a) / 2 ^ iterations rho e) ≤
+      (lipschitzGuard rho : ℝ) * ((e.2.1 : ℝ) + e.1.1 + 1) * (2 * (e.1.1 : ℝ)) /
+        2 ^ iterations rho e := by
+    calc
+      _ ≤ ((lipschitzGuard rho : ℝ) * ((e.2.1 : ℝ) + e.1.1 + 1)) *
+          (((b : ℝ) - a) / 2 ^ iterations rho e) :=
+        mul_le_mul_of_nonneg_right hL (div_nonneg hwidth (by positivity))
+      _ ≤ _ := by rw [mul_div_assoc]; gcongr
+  have he' : |residual rho e (scheduledValue rho e a b)| ≤
+      2 * (8 * ((e.1.2 : ℝ) + 1) + 1)⁻¹ +
+        residualLipschitz rho e * (((b : ℝ) - a) / 2 ^ iterations rho e) := by
+    simpa only [refinedEnvironment, Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add,
+      Nat.cast_one, scheduledValue, residual, residualLipschitz] using he
+  exact (he'.trans (add_le_add (le_refl _) hterm)).trans hbnd
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedContactCorrectness.lean

@@ -0,0 +1,82 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CalibratedContactProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactPositionArray
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCalibratedGeometry
+
+namespace OAI
+
+/-! The composed numerical program outputs the actual rational geometric
+realization of the final mediator graph, in its original vertex order. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedContactProgram
+open ContactMediator
+
+def graphInput (d : SquareLatticeHeisenberg) (N P H : ℕ)
+    (K : GlobalEdge d → ℚ) : Input :=
+  (H, ((N, P), (List.ofFn d.coordinate, (d.bonds.toList, List.ofFn K))))
+
+def graphLengths (rho : ℕ) (ε c : ℚ) (k A B N P : ℕ)
+    (d : SquareLatticeHeisenberg) (K : GlobalEdge d → ℚ) : GlobalEdge d → ℚ :=
+  fun a => AutomaticCalibration.normalizedValue rho ε c k A B (N, (P, K a))
+
+theorem raw_graphInput (rho : ℕ) (ε c : ℚ) (k A B N P H : ℕ)
+    (d : SquareLatticeHeisenberg) (K : GlobalEdge d → ℚ) :
+    rawInput rho ε c k A B (graphInput d N P H K) =
+      ContactSourceInputProgram.literalInput d H (graphLengths rho ε c k A B N P d K) := by
+  simp only [rawInput, graphInput, AutomaticCalibrationList.value, List.map_ofFn,
+    ContactSourceInputProgram.literalInput, Function.comp_def]
+  rfl
+
+theorem value_graphInput (rho : ℕ) (ε c : ℚ) (k A B N P H : ℕ)
+    (d : SquareLatticeHeisenberg) (K : GlobalEdge d → ℚ) :
+    value rho ε c k A B (graphInput d N P H K) =
+      List.ofFn (fun x => ContactCalibratedGeometry.position d H
+        (AutomaticCalibration.spacing c k N) (graphLengths rho ε c k A B N P d K) x) := by
+  unfold value
+  rw [raw_graphInput]
+  exact ContactSourceInputProgram.scaled_literal_array d H
+    (AutomaticCalibration.spacing c k N) (graphLengths rho ε c k A B N P d K)
+
+theorem graphLengths_scale (rho : ℕ) (ε : ℚ) {c : ℚ} (hc : 0 < c)
+    (k A B N P : ℕ) (hN : 0 < N) (d : SquareLatticeHeisenberg)
+    (K : GlobalEdge d → ℚ) (a : GlobalEdge d) :
+    (AutomaticCalibration.spacing c k N : ℝ) * graphLengths rho ε c k A B N P d K a =
+      (AutomaticCalibration.value rho ε c k A B (N, (P, K a)) : ℝ) := by
+  have hq := AutomaticCalibration.spacing_positive hc k N hN
+  have heq : AutomaticCalibration.spacing c k N *
+      graphLengths rho ε c k A B N P d K a =
+        AutomaticCalibration.value rho ε c k A B (N, (P, K a)) := by
+    unfold graphLengths AutomaticCalibration.normalizedValue
+    field_simp [hq.ne']
+  exact_mod_cast heq
+
+theorem graphLengths_near_one (rho : ℕ) {ε c : ℚ} (hε : 0 ≤ ε) (hc : 0 < c)
+    (hεtol : (ε : ℝ) / 2 ≤ contactLengthTolerance) (k A B N P : ℕ)
+    (hN : 0 < N) (d : SquareLatticeHeisenberg) (K : GlobalEdge d → ℚ) (a : GlobalEdge d) :
+    (graphLengths rho ε c k A B N P d K a : ℝ) ∈
+      Set.Icc (1 - contactLengthTolerance) (1 + contactLengthTolerance) := by
+  obtain ⟨hl, hu⟩ := AutomaticCalibration.normalizedValue_mem rho hε hc k A B
+    (N, (P, K a)) hN
+  have hl' : (1 : ℝ) - (ε : ℝ) / 2 ≤ graphLengths rho ε c k A B N P d K a := by
+    exact_mod_cast hl
+  have hu' : (graphLengths rho ε c k A B N P d K a : ℝ) ≤ 1 + (ε : ℝ) / 2 := by
+    exact_mod_cast hu
+  constructor <;> linarith
+
+theorem graph_separation (rho : ℕ) {ε c : ℚ} (hε : 0 ≤ ε) (hc : 0 < c)
+    (hεtol : (ε : ℝ) / 2 ≤ contactLengthTolerance) (k A B N P H W G : ℕ)
+    (hN : 0 < N) (hH : 7200 ≤ H) (d : SquareLatticeHeisenberg) (K : GlobalEdge d → ℚ)
+    (x y : GlobalSite d) (hxy : x ≠ y) :
+    (9 / 10 : ℝ) * AutomaticCalibration.spacing c k N ≤
+      dist (ContactCalibratedGeometry.point d H (AutomaticCalibration.spacing c k N)
+        (graphLengths rho ε c k A B N P d K) x)
+        (ContactCalibratedGeometry.point d H (AutomaticCalibration.spacing c k N)
+          (graphLengths rho ε c k A B N P d K) y) :=
+  ContactCalibratedGeometry.separation d W G H (AutomaticCalibration.spacing_positive hc k N hN)
+    _ hH (graphLengths_near_one rho hε hc hεtol k A B N P hN d K) x y hxy
+
+end ContinuumCoulomb.CalibratedContactProgram
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedEvaluationBudget.lean

@@ -0,0 +1,56 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationParameters
+
+namespace OAI
+
+/-! A fixed polynomial accuracy schedule for the calibrated hopping
+residual. The square-root input uses quadratic precision in the requested
+inverse error, rather than assuming a spectral gap for numerical samples. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+
+theorem hopping_budget (scale P : ℕ) :
+    (scale : ℝ) * ((hoppingPrecision scale P : ℝ) + 1)⁻¹ ≤
+      (4 * ((P : ℝ) + 1))⁻¹ := by
+  have hP : 0 < (P : ℝ) + 1 := by positivity
+  have hprec : (hoppingPrecision scale P : ℝ) =
+      4 * ((scale : ℝ) + 1) * ((P : ℝ) + 1) := by
+    simp only [hoppingPrecision, Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add, Nat.cast_one]
+  rw [hprec]
+  apply (mul_inv_le_iff₀ (by positivity)).mpr
+  apply (le_inv_mul_iff₀ (by positivity : (0 : ℝ) < 4 * (P + 1))).mpr
+  nlinarith
+
+theorem root_budget (P : ℕ) :
+    (2 : ℝ)⁻¹ ^ rootPrecision P ≤ (4 * ((P : ℝ) + 1))⁻¹ := by
+  apply (CoulombQuadratureSchedule.dyadic_le_inverse _).trans
+  apply inv_anti₀ (by positivity)
+  simp only [rootPrecision, Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add, Nat.cast_one]
+  linarith [show (0 : ℝ) ≤ P from Nat.cast_nonneg _]
+
+theorem coulomb_root_budget (N P : ℕ) {K : ℝ} (hKN : K ≤ N) :
+    Real.sqrt (2 * K * ((coulombPrecision N P : ℝ) + 1)⁻¹) ≤
+      (4 * ((P : ℝ) + 1))⁻¹ := by
+  let S := (P : ℝ) + 1
+  have hS : 0 < S := by dsimp only [S]; positivity
+  have hN : (0 : ℝ) ≤ N := Nat.cast_nonneg _
+  have hprec : (coulombPrecision N P : ℝ) = 64 * ((N : ℝ) + 1) * S ^ 2 := by
+    simp only [coulombPrecision, Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add, Nat.cast_one,
+      Nat.cast_pow, S]
+  have hsmall : 2 * K * ((coulombPrecision N P : ℝ) + 1)⁻¹ ≤ ((4 * S)⁻¹) ^ 2 := by
+    rw [hprec]
+    apply (mul_inv_le_iff₀ (by positivity)).mpr
+    have he : ((4 * S)⁻¹) ^ 2 * (64 * ((N : ℝ) + 1) * S ^ 2 + 1) =
+        4 * ((N : ℝ) + 1) + ((4 * S)⁻¹) ^ 2 := by
+      field_simp [hS.ne']
+      ring
+    rw [he]
+    nlinarith [sq_nonneg ((4 * S)⁻¹)]
+  exact (Real.sqrt_le_sqrt hsmall).trans_eq (by
+    rw [Real.sqrt_sq_eq_abs, abs_of_pos (inv_pos.mpr (mul_pos (by norm_num) hS))])
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedEvaluationComponents.lean

@@ -0,0 +1,126 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationError
+
+namespace OAI
+
+/-! An actual polynomial TM2 evaluator for the Coulomb-calibrated residual.
+This is the numeric callback used by deterministic bisection. -/
+
+namespace ContinuumCoulomb.CalibratedEvaluation
+open ExactQuantumFactoring.BitStackProgram
+
+attribute [local irreducible] CoulombEvaluation.approximate
+
+def environmentCode : Environment → List Bool :=
+  prodCode (prodCode unaryCode unaryCode) (prodCode unaryCode (prodCode ratCode ratCode))
+
+def inputCode : (Environment × ℚ) → List Bool := prodCode environmentCode ratCode
+
+noncomputable opaque coulombPrecisionProgram :
+    Procedure (prodCode unaryCode unaryCode) unaryCode (fun x => coulombPrecision x.1 x.2) := by
+  let n := Procedure.unarySuccessor.comp (Procedure.first unaryCode unaryCode)
+  let p := ResolventSchedule.squareProgram.comp
+    (Procedure.unarySuccessor.comp (Procedure.second unaryCode unaryCode))
+  let prod := ResolventSchedule.mulProgram.comp (n.pair p)
+  exact ((CoulombEvaluation.scaleProgram 64).comp prod).congrFun (by
+    intro x
+    simp only [Function.comp_apply, Nat.succ_eq_add_one, coulombPrecision]
+    ring)
+
+noncomputable opaque hoppingPrecisionProgram :
+    Procedure (prodCode unaryCode unaryCode) unaryCode (fun x => hoppingPrecision x.1 x.2) := by
+  let s := Procedure.unarySuccessor.comp (Procedure.first unaryCode unaryCode)
+  let p := Procedure.unarySuccessor.comp (Procedure.second unaryCode unaryCode)
+  let prod := ResolventSchedule.mulProgram.comp (s.pair p)
+  exact ((CoulombEvaluation.scaleProgram 4).comp prod).congrFun (by
+    intro x
+    simp only [Function.comp_apply, Nat.succ_eq_add_one, hoppingPrecision]
+    ring)
+
+noncomputable opaque rootPrecisionProgram : Procedure unaryCode unaryCode rootPrecision :=
+  ((CoulombEvaluation.scaleProgram 8).comp Procedure.unarySuccessor).congrFun (by intro x; rfl)
+
+noncomputable opaque environmentProgram : Procedure inputCode environmentCode Prod.fst :=
+  Procedure.first environmentCode ratCode
+noncomputable opaque distanceProgram : Procedure inputCode ratCode Prod.snd :=
+  Procedure.second environmentCode ratCode
+noncomputable opaque metadataProgram : Procedure inputCode (prodCode unaryCode unaryCode)
+    (fun x => x.1.1) :=
+  (Procedure.first (prodCode unaryCode unaryCode)
+    (prodCode unaryCode (prodCode ratCode ratCode))).comp environmentProgram
+noncomputable opaque boundProgram : Procedure inputCode unaryCode (fun x => x.1.1.1) :=
+  (Procedure.first unaryCode unaryCode).comp metadataProgram
+noncomputable opaque precisionProgram : Procedure inputCode unaryCode (fun x => x.1.1.2) :=
+  (Procedure.second unaryCode unaryCode).comp metadataProgram
+noncomputable opaque parametersProgram : Procedure inputCode
+    (prodCode unaryCode (prodCode ratCode ratCode)) (fun x => x.1.2) :=
+  (Procedure.second (prodCode unaryCode unaryCode)
+    (prodCode unaryCode (prodCode ratCode ratCode))).comp environmentProgram
+noncomputable opaque scaleProgram : Procedure inputCode unaryCode (fun x => x.1.2.1) :=
+  (Procedure.first unaryCode (prodCode ratCode ratCode)).comp parametersProgram
+noncomputable opaque scalarParametersProgram : Procedure inputCode (prodCode ratCode ratCode)
+    (fun x => x.1.2.2) :=
+  (Procedure.second unaryCode (prodCode ratCode ratCode)).comp parametersProgram
+noncomputable opaque tauProgram : Procedure inputCode ratCode (fun x => x.1.2.2.1) :=
+  (Procedure.first ratCode ratCode).comp scalarParametersProgram
+noncomputable opaque weightProgram : Procedure inputCode ratCode (fun x => x.1.2.2.2) :=
+  (Procedure.second ratCode ratCode).comp scalarParametersProgram
+noncomputable opaque coulombAccuracyProgram : Procedure inputCode unaryCode
+    (fun x => coulombPrecision x.1.1.1 x.1.1.2) :=
+  coulombPrecisionProgram.comp metadataProgram
+noncomputable def onsiteArgument (x : Environment × ℚ) : CoulombEvaluation.Input :=
+  (coulombPrecision x.1.1.1 x.1.1.2, 0)
+noncomputable def separatedArgument (x : Environment × ℚ) : CoulombEvaluation.Input :=
+  (coulombPrecision x.1.1.1 x.1.1.2, x.2)
+
+noncomputable opaque onsiteArgumentProgram :
+    Procedure inputCode CoulombEvaluation.inputCode onsiteArgument :=
+  coulombAccuracyProgram.pair (Procedure.constant inputCode ratCode 0)
+noncomputable opaque separatedArgumentProgram :
+    Procedure inputCode CoulombEvaluation.inputCode separatedArgument :=
+  coulombAccuracyProgram.pair distanceProgram
+
+noncomputable opaque onsiteRawProgram (rho : ℕ) : Procedure inputCode ratCode
+    ((fun q : CoulombEvaluation.Input => CoulombEvaluation.approximate rho q.1 q.2) ∘ onsiteArgument) :=
+  (CoulombEvaluation.program rho).comp onsiteArgumentProgram
+noncomputable opaque separatedRawProgram (rho : ℕ) : Procedure inputCode ratCode
+    ((fun q : CoulombEvaluation.Input => CoulombEvaluation.approximate rho q.1 q.2) ∘ separatedArgument) :=
+  (CoulombEvaluation.program rho).comp separatedArgumentProgram
+
+noncomputable opaque onsiteProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => CoulombEvaluation.approximate rho (coulombPrecision x.1.1.1 x.1.1.2) 0) :=
+  (onsiteRawProgram rho).congrFun (by intro x; simp only [Function.comp_apply, onsiteArgument])
+noncomputable opaque separatedProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => CoulombEvaluation.approximate rho (coulombPrecision x.1.1.1 x.1.1.2) x.2) :=
+  (separatedRawProgram rho).congrFun (by intro x; simp only [Function.comp_apply, separatedArgument])
+
+noncomputable opaque gapProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => gap rho x.1.1.1 x.1.1.2 x.2) :=
+  (CappedKernelProgram.maximumProgram.comp ((Procedure.constant inputCode ratCode 0).pair
+    (Procedure.ratSub.comp ((onsiteProgram rho).pair (separatedProgram rho))))).congrFun
+      (by intro x; rfl)
+noncomputable opaque radicandProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => x.1.2.2.2 * gap rho x.1.1.1 x.1.1.2 x.2) :=
+  Procedure.ratMul.comp (weightProgram.pair (gapProgram rho))
+noncomputable opaque rootProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => root rho x.1.1.1 x.1.1.2 x.1.2.2.2 x.2) :=
+  (RationalSquareRoot.program.comp
+    ((rootPrecisionProgram.comp precisionProgram).pair (radicandProgram rho))).congrFun
+      (by intro x; rfl)
+noncomputable opaque hoppingAccuracyProgram : Procedure inputCode unaryCode
+    (fun x => hoppingPrecision x.1.2.1 x.1.1.2) :=
+  hoppingPrecisionProgram.comp (scaleProgram.pair precisionProgram)
+noncomputable opaque hoppingProgram : Procedure inputCode ratCode
+    (fun x => ComputableHopping.approximate ((x.1.1.1, hoppingPrecision x.1.2.1 x.1.1.2), x.2)) :=
+  ComputableHopping.program.comp ((boundProgram.pair hoppingAccuracyProgram).pair distanceProgram)
+noncomputable opaque scaledHoppingProgram : Procedure inputCode ratCode
+    (fun x => (x.1.2.1 : ℚ) *
+      ComputableHopping.approximate ((x.1.1.1, hoppingPrecision x.1.2.1 x.1.1.2), x.2)) :=
+  Procedure.ratMul.comp ((Procedure.natToRat.comp
+    (Procedure.unaryToBits.comp scaleProgram)).pair hoppingProgram)
+noncomputable opaque targetProgram (rho : ℕ) : Procedure inputCode ratCode
+    (fun x => x.1.2.2.1 * root rho x.1.1.1 x.1.1.2 x.1.2.2.2 x.2) :=
+  Procedure.ratMul.comp (tauProgram.pair (rootProgram rho))
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedEvaluationError.lean

@@ -0,0 +1,69 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedEvaluationBudget
+
+namespace OAI
+
+/-! Certified evaluation of the actual calibrated hopping residual,
+uniformly on rational points in a bounded interval. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+
+theorem approximation_error (rho : ℕ) (hrho : 0 < rho) (e : Environment) (d : ℚ)
+    (hK : (0 : ℚ) ≤ e.2.2.2) (hKN : (e.2.2.2 : ℝ) ≤ e.1.1)
+    (hτ : (0 : ℚ) ≤ e.2.2.1) (hτ1 : e.2.2.1 ≤ 1)
+    (hd : |(d : ℝ)| ≤ (e.1.1 : ℝ))
+    (hgap : 0 ≤ localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+      localizedCoulombProfile (GaussianFrequency.frequency rho) (d : ℝ)) :
+    |(value rho e d : ℝ) -
+      ((e.2.1 : ℝ) * planarHopping (d : ℝ) - (e.2.2.1 : ℝ) *
+        Real.sqrt ((e.2.2.2 : ℝ) *
+          (localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+            localizedCoulombProfile (GaussianFrequency.frequency rho) (d : ℝ))))| ≤
+      ((e.1.2 : ℝ) + 1)⁻¹ := by
+  have hKr : (0 : ℝ) ≤ e.2.2.2 := by exact_mod_cast hK
+  have hτr : (0 : ℝ) ≤ e.2.2.1 := by exact_mod_cast hτ
+  have hτ1r : (e.2.2.1 : ℝ) ≤ 1 := by exact_mod_cast hτ1
+  have hu := CoulombEvaluation.approximation_error rho (coulombPrecision e.1.1 e.1.2) hrho 0
+  have hv := CoulombEvaluation.approximation_error rho (coulombPrecision e.1.1 e.1.2) hrho d
+  simp only [Rat.cast_zero] at hu
+  have ht := ComputableHopping.approximation_error
+    ((e.1.1, hoppingPrecision e.2.1 e.1.2), d) hd
+  have hq : (0 : ℚ) ≤ e.2.2.2 * gap rho e.1.1 e.1.2 d :=
+    mul_nonneg hK (le_max_left _ _)
+  have hr := RationalSquareRoot.value_error (rootPrecision e.1.2) hq
+  have hr' : |(root rho e.1.1 e.1.2 e.2.2.2 d : ℝ) -
+      Real.sqrt ((e.2.2.2 : ℝ) * max 0
+        ((CoulombEvaluation.approximate rho (coulombPrecision e.1.1 e.1.2) 0 : ℝ) -
+          CoulombEvaluation.approximate rho (coulombPrecision e.1.1 e.1.2) d))| ≤
+      (2 : ℝ)⁻¹ ^ rootPrecision e.1.2 := by
+    simpa only [root, gap, Rat.cast_mul, Rat.cast_max, Rat.cast_zero, Rat.cast_sub] using hr
+  have he := calibrated_residual_error (Nat.cast_nonneg e.2.1) hτr hKr hgap ht hu hv hr'
+  have hhop := hopping_budget e.2.1 e.1.2
+  have hroot := root_budget e.1.2
+  have hcoulomb := coulomb_root_budget e.1.1 e.1.2 hKN
+  have hnonneg : 0 ≤ (2 : ℝ)⁻¹ ^ rootPrecision e.1.2 +
+      Real.sqrt (2 * (e.2.2.2 : ℝ) * ((coulombPrecision e.1.1 e.1.2 : ℝ) + 1)⁻¹) := by
+    positivity
+  have htarget := mul_le_mul_of_nonneg_right hτ1r hnonneg
+  have hfinal := he.trans (add_le_add hhop
+    (htarget.trans (by simpa only [one_mul] using add_le_add hroot hcoulomb)))
+  have hsum : (4 * ((e.1.2 : ℝ) + 1))⁻¹ +
+      ((4 * ((e.1.2 : ℝ) + 1))⁻¹ + (4 * ((e.1.2 : ℝ) + 1))⁻¹) =
+      3 * (4 * ((e.1.2 : ℝ) + 1))⁻¹ := by ring
+  have hout : |(value rho e d : ℝ) -
+      ((e.2.1 : ℝ) * planarHopping (d : ℝ) - (e.2.2.1 : ℝ) *
+        Real.sqrt ((e.2.2.2 : ℝ) *
+          (localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+            localizedCoulombProfile (GaussianFrequency.frequency rho) (d : ℝ))))| ≤
+      3 * (4 * ((e.1.2 : ℝ) + 1))⁻¹ := by
+    simpa only [value, Rat.cast_sub, Rat.cast_mul, Rat.cast_natCast, hsum] using hfinal
+  apply hout.trans
+  rw [mul_inv]
+  norm_num
+  nlinarith [inv_pos.mpr (show (0 : ℝ) < e.1.2 + 1 by positivity)]
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedEvaluationParameters.lean

@@ -0,0 +1,33 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CoulombEvaluationProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Reduction.ComputableHopping
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationSquareError
+
+namespace OAI
+
+/-! The literal scalar function supplied to calibrated-distance bisection.
+The displacement/weight bound, amplification and requested accuracy are unary;
+the positive target parameters and the queried distance are rational. -/
+
+namespace ContinuumCoulomb.CalibratedEvaluation
+
+abbrev Environment := (ℕ × ℕ) × (ℕ × (ℚ × ℚ))
+
+noncomputable def coulombPrecision (N P : ℕ) : ℕ := 64 * (N + 1) * (P + 1) ^ 2
+noncomputable def hoppingPrecision (scale P : ℕ) : ℕ := 4 * (scale + 1) * (P + 1)
+noncomputable def rootPrecision (P : ℕ) : ℕ := 8 * (P + 1)
+
+noncomputable def gap (rho N P : ℕ) (d : ℚ) : ℚ :=
+  max 0 (CoulombEvaluation.approximate rho (coulombPrecision N P) 0 -
+    CoulombEvaluation.approximate rho (coulombPrecision N P) d)
+
+noncomputable def root (rho N P : ℕ) (K d : ℚ) : ℚ :=
+  RationalSquareRoot.value (rootPrecision P, K * gap rho N P d)
+
+noncomputable def value (rho : ℕ) (e : Environment) (d : ℚ) : ℚ :=
+  (e.2.1 : ℚ) * ComputableHopping.approximate
+      ((e.1.1, hoppingPrecision e.2.1 e.1.2), d) -
+    e.2.2.1 * root rho e.1.1 e.1.2 e.2.2.2 d
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedGraphError.lean

@@ -0,0 +1,80 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationGraphBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisectionLocation
+
+namespace OAI
+
+/-! The actual scheduled rational distances produce a finite Hubbard
+superexchange graph whose ground energy is close to the requested spin graph.
+Only the analytic endpoint signs and separated-site gap are hypotheses. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+open scoped BigOperators
+
+def edgeEnvironment (N P scale : ℕ) (τ K : ℚ) : Environment := ((N, P), (scale, (τ, K)))
+
+def scheduledDistance (rho N P scale : ℕ) (τ K a b : ℚ) : ℚ :=
+  scheduledValue rho (edgeEnvironment N P scale τ K) a b
+
+def scheduledCoefficient (rho N P scale : ℕ) (τ K a b : ℚ) : ℝ :=
+  ((scale : ℝ) * planarHopping (scheduledDistance rho N P scale τ K a b)) ^ 2 /
+    (localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+      localizedCoulombProfile (GaussianFrequency.frequency rho)
+        (scheduledDistance rho N P scale τ K a b))
+
+theorem scheduled_graphSourceBottom_error {Edge : Type*} [Fintype Edge]
+    (rho : ℕ) (hrho : 0 < rho) (m : ℕ) (left right : Edge → Fin (m + 1))
+    (N P scale : ℕ) (τ : ℚ) (K a b : Edge → ℚ)
+    (hK : ∀ e, 0 ≤ K e) (hKN : ∀ e, (K e : ℝ) ≤ N)
+    (hτ : 0 ≤ τ) (hτ1 : τ ≤ 1) (hab : ∀ e, a e ≤ b e)
+    (haN : ∀ e, -(N : ℝ) ≤ a e) (hbN : ∀ e, (b e : ℝ) ≤ N)
+    (ha : ∀ e, 0 ≤ residual rho (edgeEnvironment N P scale τ (K e)) (a e))
+    (hb : ∀ e, residual rho (edgeEnvironment N P scale τ (K e)) (b e) ≤ 0)
+    (hgap : ∀ e r, r ∈ Set.Icc (a e : ℝ) (b e) →
+      localizedGramConstant (GaussianFrequency.frequency rho) ≤
+        localizedCoulombProfile (GaussianFrequency.frequency rho) 0 -
+          localizedCoulombProfile (GaussianFrequency.frequency rho) r) :
+    |HubbardGlobal.graphSourceBottom m left right
+        (fun e => scheduledCoefficient rho N P scale τ (K e) (a e) (b e)) -
+      HubbardGlobal.graphSourceBottom m left right (fun e => (τ : ℝ) ^ 2 * K e)| ≤
+      4 * Fintype.card Edge *
+        (((P : ℝ) + 1)⁻¹ *
+          (2 * Real.sqrt ((N : ℝ) * localizedCoulombProfile (GaussianFrequency.frequency rho) 0) +
+            ((P : ℝ) + 1)⁻¹) / localizedGramConstant (GaussianFrequency.frequency rho)) := by
+  let freq := GaussianFrequency.frequency rho
+  let d : Edge → ℚ := fun e => scheduledDistance rho N P scale τ (K e) (a e) (b e)
+  let t : Edge → ℝ := fun e => (scale : ℝ) * planarHopping (d e)
+  let gap : Edge → ℝ := fun e => localizedCoulombProfile freq 0 - localizedCoulombProfile freq (d e)
+  have hfreq : 0 < freq := Real.sqrt_pos.mpr (by
+    change 0 < 4 * Real.pi * (rho : ℝ)
+    positivity)
+  have hmem (e : Edge) : (d e : ℝ) ∈ Set.Icc (a e : ℝ) (b e) := by
+    have hm := scheduledValue_mem rho (edgeEnvironment N P scale τ (K e)) (a e) (b e) (hab e)
+    exact ⟨by exact_mod_cast hm.1, by exact_mod_cast hm.2⟩
+  have hgap' (e : Edge) : localizedGramConstant freq ≤ gap e := hgap e (d e) (hmem e)
+  have hU (e : Edge) : gap e ≤ localizedCoulombProfile freq 0 := by
+    have hp : 0 ≤ localizedCoulombProfile freq (d e) := by
+      unfold localizedCoulombProfile
+      rw [localizedCoulombProfileAt_eq]
+      exact localizedCoulombCoeff_nonnegative _ _ _
+    dsimp only [gap]
+    linarith
+  have hres (e : Edge) :
+      |t e - (τ : ℝ) * Real.sqrt ((K e : ℝ) * gap e)| ≤ ((P : ℝ) + 1)⁻¹ := by
+    have hs := scheduled_residual rho hrho (edgeEnvironment N P scale τ (K e))
+      (a e) (b e) (hK e) (hKN e) hτ hτ1 (hab e) (haN e) (hbN e) (ha e) (hb e) (hgap e)
+    simpa only [residual, coulombHoppingTarget, edgeEnvironment, d, t, gap, freq,
+      scheduledDistance] using hs
+  have hKr (e : Edge) : (0 : ℝ) ≤ K e := by exact_mod_cast hK e
+  have hτr : (0 : ℝ) ≤ τ := by exact_mod_cast hτ
+  have hτr1 : (τ : ℝ) ≤ 1 := by exact_mod_cast hτ1
+  have h := HubbardGlobal.calibrated_graphSourceBottom_uniform_error m left right
+    t (fun e => (K e : ℝ)) gap hKr hKN (localizedGramConstant_positive hfreq)
+    hgap' hU hτr hτr1 hres
+  simpa only [scheduledCoefficient, scheduledDistance, t, gap, d, freq] using h
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedHoppingBound.lean

@@ -0,0 +1,58 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedHubbard
+
+namespace OAI
+
+/-! Explicit total hopping bounds for actual Coulomb-calibrated contacts. -/
+
+noncomputable section
+open scoped BigOperators
+namespace ContinuumCoulomb
+
+theorem calibrated_hopping_sum_bound {Edge : Type*} [Fintype Edge]
+    (freq scale τ B : ℝ) (hτ : 0 ≤ τ) (distance K : Edge → ℝ)
+    (hK : ∀ e, 0 ≤ K e) (hB : ∀ e, K e ≤ B)
+    (hcal : ∀ e, scale * planarHopping (distance e) = coulombHoppingTarget freq τ (K e) (distance e)) :
+    4 * ∑ e, |scale * planarHopping (distance e)| ≤
+      4 * (Fintype.card Edge : ℝ) * (τ * Real.sqrt (B * localizedCoulombProfile freq 0)) := by
+  have hpoint (e : Edge) : |scale * planarHopping (distance e)| ≤
+      τ * Real.sqrt (B * localizedCoulombProfile freq 0) := by
+    rw [hcal e, coulombHoppingTarget, abs_of_nonneg (mul_nonneg hτ (Real.sqrt_nonneg _))]
+    apply mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt ?_) hτ
+    calc
+      _ ≤ K e * localizedCoulombProfile freq 0 := mul_le_mul_of_nonneg_left
+        (sub_le_self _ (localizedCoulombProfile_nonnegative freq (distance e))) (hK e)
+      _ ≤ _ := mul_le_mul_of_nonneg_right (hB e) (localizedCoulombProfile_nonnegative freq 0)
+  have h := mul_le_mul_of_nonneg_left
+    (Finset.sum_le_sum (s := Finset.univ) (fun e _ => hpoint e)) (by norm_num : (0 : ℝ) ≤ 4)
+  simpa only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, mul_assoc] using h
+
+def calibratedTau (freq ε B : ℝ) (r : ℕ) : ℝ :=
+  ε * localizedGramConstant freq /
+    (4 * ((r : ℝ) + 1) * (Real.sqrt (B * localizedCoulombProfile freq 0) + 1))
+
+theorem calibratedTau_nonnegative {freq ε B : ℝ} (hfreq : 0 < freq) (hε : 0 ≤ ε) (r : ℕ) :
+    0 ≤ calibratedTau freq ε B r := by
+  unfold calibratedTau
+  exact div_nonneg (mul_nonneg hε (localizedGramConstant_positive hfreq).le) (by positivity)
+
+theorem calibratedTau_budget {freq ε B : ℝ} (hfreq : 0 < freq) (hε : 0 ≤ ε) (r : ℕ) :
+    4 * (r : ℝ) * (calibratedTau freq ε B r * Real.sqrt (B * localizedCoulombProfile freq 0)) ≤
+      ε * localizedGramConstant freq := by
+  let q := Real.sqrt (B * localizedCoulombProfile freq 0)
+  have hq : 0 ≤ q := Real.sqrt_nonneg _
+  have hd : 0 < 4 * ((r : ℝ) + 1) * (q + 1) := by positivity
+  have hεc : 0 ≤ ε * localizedGramConstant freq :=
+    mul_nonneg hε (localizedGramConstant_positive hfreq).le
+  have hratio : 4 * (r : ℝ) * q ≤ 4 * ((r : ℝ) + 1) * (q + 1) := by
+    nlinarith [Nat.cast_nonneg (α := ℝ) r]
+  unfold calibratedTau
+  change 4 * (r : ℝ) * (ε * localizedGramConstant freq / (4 * ((r : ℝ) + 1) * (q + 1)) * q) ≤ _
+  rw [show 4 * (r : ℝ) * (ε * localizedGramConstant freq / (4 * ((r : ℝ) + 1) * (q + 1)) * q) =
+    (ε * localizedGramConstant freq) * (4 * (r : ℝ) * q) / (4 * ((r : ℝ) + 1) * (q + 1)) by ring]
+  exact (div_le_iff₀ hd).mpr (mul_le_mul_of_nonneg_left hratio hεc)
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedLipschitzBound.lean

@@ -0,0 +1,66 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibratedBisection
+
+namespace OAI
+
+/-! A fixed unary guard bounds the actual residual modulus by a polynomial
+in the displacement/weight bound and the amplification. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibratedEvaluation
+
+def targetModulusBase (rho : ℕ) : ℝ :=
+  localizedCoulombLipschitzConstant (GaussianFrequency.frequency rho) /
+    (2 * Real.sqrt (localizedGramConstant (GaussianFrequency.frequency rho)))
+
+def lipschitzGuard (rho : ℕ) : ℕ :=
+  ⌈(planarHoppingLipschitzConstant : ℝ) + targetModulusBase rho⌉₊ + 1
+
+theorem targetModulusBase_nonnegative (rho : ℕ) : 0 ≤ targetModulusBase rho :=
+  div_nonneg (localizedCoulombLipschitzConstant_nonnegative _)
+    (mul_nonneg (by norm_num) (Real.sqrt_nonneg _))
+
+theorem lipschitzGuard_bound (rho : ℕ) :
+    (planarHoppingLipschitzConstant : ℝ) + targetModulusBase rho ≤ lipschitzGuard rho := by
+  have h := Nat.le_ceil ((planarHoppingLipschitzConstant : ℝ) + targetModulusBase rho)
+  simp only [lipschitzGuard, Nat.cast_add, Nat.cast_one]
+  linarith
+
+theorem lipschitzGuard_positive (rho : ℕ) : 0 < lipschitzGuard rho := by
+  unfold lipschitzGuard
+  omega
+
+theorem residualLipschitz_bound (rho : ℕ) (e : Environment)
+    (hK : (0 : ℝ) ≤ e.2.2.2) (hKN : (e.2.2.2 : ℝ) ≤ e.1.1)
+    (hτ1 : (e.2.2.1 : ℝ) ≤ 1) :
+    residualLipschitz rho e ≤
+      (lipschitzGuard rho : ℝ) * ((e.2.1 : ℝ) + e.1.1 + 1) := by
+  have hH : 0 ≤ (planarHoppingLipschitzConstant : ℝ) := NNReal.coe_nonneg _
+  have hA := targetModulusBase_nonnegative rho
+  have hN : (0 : ℝ) ≤ e.1.1 := Nat.cast_nonneg _
+  have hS : (0 : ℝ) ≤ e.2.1 := Nat.cast_nonneg _
+  have hroot : Real.sqrt (e.2.2.2 : ℝ) ≤ (e.1.1 : ℝ) + 1 := by
+    have hs := Real.sqrt_nonneg (e.2.2.2 : ℝ)
+    have he := Real.sq_sqrt hK
+    nlinarith [sq_nonneg (Real.sqrt (e.2.2.2 : ℝ) - 1)]
+  have hprod : (e.2.2.1 : ℝ) * Real.sqrt (e.2.2.2 : ℝ) ≤ (e.1.1 : ℝ) + 1 :=
+    (mul_le_mul_of_nonneg_right hτ1 (Real.sqrt_nonneg _)).trans
+      (by simpa only [one_mul] using hroot)
+  have htarget : coulombTargetLipschitzConstant (GaussianFrequency.frequency rho)
+      e.2.2.1 e.2.2.2 =
+      ((e.2.2.1 : ℝ) * Real.sqrt (e.2.2.2 : ℝ)) * targetModulusBase rho := by
+    unfold coulombTargetLipschitzConstant targetModulusBase
+    ring
+  have htargetBound := mul_le_mul_of_nonneg_right hprod hA
+  have hguard := mul_le_mul_of_nonneg_right (lipschitzGuard_bound rho)
+    (show (0 : ℝ) ≤ (e.2.1 : ℝ) + e.1.1 + 1 by positivity)
+  unfold residualLipschitz
+  rw [htarget]
+  have hcross : 0 ≤ (planarHoppingLipschitzConstant : ℝ) * ((e.1.1 : ℝ) + 1) +
+      targetModulusBase rho * (e.2.1 : ℝ) := by positivity
+  nlinarith
+
+end ContinuumCoulomb.CalibratedEvaluation
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibratedMatrixError.lean

@@ -0,0 +1,69 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.ManyBody.FockGraphEntries
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.ContactCalibratedGeometry
+
+namespace OAI
+
+/-! The approximate edge calibrations control the entire hopping matrix.
+Simplicity prevents an edge error from acquiring a graph-size factor. -/
+
+noncomputable section
+namespace ContinuumCoulomb.HubbardGlobal
+variable {Edge : Type*} [Fintype Edge]
+
+theorem graphHoppingMatrix_stability (m : ℕ) (left right : Edge → Fin (m+1))
+    (hloop : ∀ e, left e ≠ right e)
+    (hsimple : ∀ e f, e ≠ f →
+      ¬(left e=left f ∧ right e=right f) ∧ ¬(left e=right f ∧ right e=left f))
+    (t s : Edge → ℂ) {ε : ℝ} (hε : 0 ≤ ε)
+    (hedge : ∀ e, ‖t e-s e‖ ≤ ε) (i j : Fin (m+1)) :
+    ‖graphHoppingMatrix m left right t i j-graphHoppingMatrix m left right s i j‖ ≤ ε := by
+  classical
+  by_cases hij : i=j
+  · subst j
+    rw [graphHoppingMatrix_diagonal m left right t hloop,
+      graphHoppingMatrix_diagonal m left right s hloop,sub_self,norm_zero]
+    exact hε
+  by_cases he : ∃ e, (i=left e ∧ j=right e) ∨ (i=right e ∧ j=left e)
+  · obtain ⟨e,he|he⟩ := he
+    · rcases he with ⟨rfl,rfl⟩
+      simpa only [graphHoppingMatrix_edge m left right _ hloop hsimple] using hedge e
+    · rcases he with ⟨rfl,rfl⟩
+      rw [graphHoppingMatrix_symmetric m left right t,
+        graphHoppingMatrix_symmetric m left right s]
+      simpa only [graphHoppingMatrix_edge m left right _ hloop hsimple] using hedge e
+  · have hn : ∀ e, ¬(i=left e ∧ j=right e) ∧ ¬(i=right e ∧ j=left e) := by
+      intro e
+      exact ⟨fun h => he ⟨e,Or.inl h⟩,fun h => he ⟨e,Or.inr h⟩⟩
+    rw [graphHoppingMatrix_nonedge m left right t i j hn,
+      graphHoppingMatrix_nonedge m left right s i j hn,sub_self,norm_zero]
+    exact hε
+
+theorem planarHoppingMatrix_calibrated_error (m : ℕ)
+    (left right : Edge → Fin (m+1)) (u : Fin (m+1) → PlanarPosition)
+    (hloop : ∀ e, left e ≠ right e)
+    (hsimple : ∀ e f, e ≠ f →
+      ¬(left e=left f ∧ right e=right f) ∧ ¬(left e=right f ∧ right e=left f))
+    {scale D L ε : ℝ} (hscale : 0 ≤ scale) (hD : 2 ≤ D) (hε : 0 ≤ ε)
+    (hL : ∀ i j, ‖u i-u j‖ ≤ L)
+    (hsep : ∀ i j, i ≠ j →
+      (∀ e, ¬(i=left e ∧ j=right e) ∧ ¬(i=right e ∧ j=left e)) → D ≤ ‖u i-u j‖)
+    (target : Edge → ℝ)
+    (hres : ∀ e, |scale*planarHopping ‖u (left e)-u (right e)‖-target e| ≤ ε)
+    (i j : Fin (m+1)) :
+    ‖((scale*planarHoppingMatrix u i j:ℝ):ℂ)-
+      graphHoppingMatrix m left right (fun e => (-(target e):ℝ)) i j‖ ≤
+        scale*planarHoppingUpperConstant*(L+1)*Real.exp (-D)+ε := by
+  let actual : Edge → ℂ := fun e => (-(scale*planarHopping ‖u (left e)-u (right e)‖):ℝ)
+  have hc := graphHoppingMatrix_stability m left right hloop hsimple actual
+    (fun e => (-(target e):ℝ)) hε (fun e => ?_) i j
+  · exact (norm_sub_le_norm_sub_add_norm_sub _ (graphHoppingMatrix m left right actual i j) _).trans
+      (add_le_add (planarHoppingMatrix_graph_error m left right u hloop hsimple
+        hscale hD hL hsep i j) hc)
+  · simpa only [actual,← Complex.ofReal_sub,Complex.norm_real,Real.norm_eq_abs,
+      neg_sub_neg,abs_sub_comm] using hres e
+
+end ContinuumCoulomb.HubbardGlobal
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationCoefficientError.lean

@@ -0,0 +1,44 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationSquareError
+
+namespace OAI
+
+/-! A numerical calibration residual controls the actual superexchange
+coefficient directly. No inverse-function or derivative lower bound is used. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+
+theorem calibrated_coefficient_error {a K gap τ ε : ℝ}
+    (hK : 0 ≤ K) (hgap : 0 < gap) (hτ : 0 ≤ τ)
+    (hres : |a - τ * Real.sqrt (K * gap)| ≤ ε) :
+    |a ^ 2 / gap - τ ^ 2 * K| ≤
+      ε * (2 * τ * Real.sqrt (K * gap) + ε) / gap := by
+  let b := τ * Real.sqrt (K * gap)
+  have hb : 0 ≤ b := mul_nonneg hτ (Real.sqrt_nonneg _)
+  have he : 0 ≤ ε := (abs_nonneg _).trans hres
+  have hb2 : b ^ 2 = τ ^ 2 * K * gap := by
+    dsimp only [b]
+    rw [mul_pow, Real.sq_sqrt (mul_nonneg hK hgap.le)]
+    ring
+  have ha : |a| ≤ b + ε := by
+    calc
+      _ = |(a - b) + b| := by congr 1; ring
+      _ ≤ |a - b| + |b| := abs_add_le _ _
+      _ ≤ ε + b := add_le_add hres (le_of_eq (abs_of_nonneg hb))
+      _ = _ := by ring
+  have hsum : |a + b| ≤ 2 * b + ε :=
+    (abs_add_le _ _).trans (by rw [abs_of_nonneg hb]; linarith)
+  have hsq : |a ^ 2 - b ^ 2| ≤ ε * (2 * b + ε) := by
+    rw [show a ^ 2 - b ^ 2 = (a - b) * (a + b) by ring, abs_mul]
+    exact mul_le_mul hres hsum (abs_nonneg _) he
+  have hid : a ^ 2 / gap - τ ^ 2 * K = (a ^ 2 - b ^ 2) / gap := by
+    rw [hb2]
+    field_simp [hgap.ne']
+  rw [hid, abs_div, abs_of_pos hgap]
+  simpa only [b, mul_assoc] using div_le_div_of_nonneg_right hsq hgap.le
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationCoulombBrackets.lean

@@ -0,0 +1,76 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationEndpointSigns
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CoulombTargetRange
+
+namespace OAI
+
+/-! Explicit rational search intervals for the actual Coulomb-calibrated
+hopping target. The fixed exponent simultaneously enforces the separated
+two-site denominator and both endpoint signs. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibrationRationalBracket
+
+theorem exists_coulomb_brackets {freq : ℝ} (hfreq : 0 < freq)
+    (ε : ℚ) (hε : 0 < ε) (hε1 : ε < 1) (A B : ℕ) (kmin : ℝ) :
+    ∃ (c : ℚ) (k : ℕ), 0 < c ∧ 0 < k ∧ kmin ≤ (k : ℝ) ∧
+      ∀ N : ℕ, 2 ≤ N →
+        let D := (k : ℝ) * Real.log (N : ℝ)
+        let p := endpoints ε (RationalLogScale.value c k N)
+        (1 - (ε : ℝ)) * D ≤ p.1 ∧ p.2 ≤ (1 + (ε : ℝ)) * D ∧
+          5 ≤ (1 - (ε : ℝ)) * D ∧
+          (∀ r : ℝ, (p.1 : ℝ) ≤ r → localizedGramConstant freq ≤
+            localizedCoulombProfile freq 0 - localizedCoulombProfile freq r) ∧
+          (∀ K : ℚ, ((N : ℝ) ^ A)⁻¹ ≤ K → (K : ℝ) ≤ (N : ℝ) ^ A →
+            0 ≤ (N : ℝ) ^ k * planarHopping p.1 -
+              coulombHoppingTarget freq ((N : ℝ) ^ B)⁻¹ K p.1 ∧
+            (N : ℝ) ^ k * planarHopping p.2 -
+              coulombHoppingTarget freq ((N : ℝ) ^ B)⁻¹ K p.2 ≤ 0) := by
+  have hεR : (0 : ℝ) < ε := by exact_mod_cast hε
+  have hεR1 : (ε : ℝ) < 1 := by exact_mod_cast hε1
+  obtain ⟨L, _, hrange⟩ := exists_coulomb_target_polynomial_bounds hfreq A B
+  obtain ⟨k₀, _, hspacing⟩ := exists_localizedGram_spacing hfreq 1
+  obtain ⟨c, k, hc, hk, hkmin, hbracket⟩ := exists_rational_hopping_brackets
+    ε hε hε1 (B + A + L) (max kmin ((k₀ : ℝ) / (1 - (ε : ℝ))))
+  have hkmin' : kmin ≤ (k : ℝ) := (le_max_left _ _).trans hkmin
+  have hkspacing : (k₀ : ℝ) / (1 - (ε : ℝ)) ≤ k := (le_max_right _ _).trans hkmin
+  refine ⟨c, k, hc, hk, hkmin', fun N hN => ?_⟩
+  have hNR : (2 : ℝ) ≤ N := by exact_mod_cast hN
+  have hNp : (0 : ℝ) < N := by linarith
+  have hlogN : 0 ≤ Real.log (N : ℝ) := Real.log_nonneg (by linarith)
+  let D : ℝ := (k : ℝ) * Real.log (N : ℝ)
+  let p := endpoints ε (RationalLogScale.value c k N)
+  obtain ⟨ha0, ha1, hb0, hb1, haHop, hbHop⟩ := hbracket N hN
+  have hlength : (k₀ : ℝ) * Real.log (N : ℝ) ≤ (1 - (ε : ℝ)) * D := by
+    have hm := mul_le_mul_of_nonneg_right
+      ((div_le_iff₀ (sub_pos.mpr hεR1)).mp hkspacing) hlogN
+    nlinarith only [hm]
+  obtain ⟨hfive, hleak⟩ := hspacing N hNR
+  have hleak₂ : 2 * localLeakageBound freq ((k₀ : ℝ) * Real.log (N : ℝ)) ≤
+      localDualMass freq / 2 := by
+    have hm := mul_le_mul_of_nonneg_right hNR
+      (localLeakageBound_nonnegative freq ((k₀ : ℝ) * Real.log (N : ℝ)))
+    exact hm.trans (by simpa only [pow_one] using hleak)
+  have hsepA : (k₀ : ℝ) * Real.log (N : ℝ) ≤ (p.1 : ℝ) := hlength.trans ha0
+  have hD0 : 0 ≤ D := mul_nonneg (Nat.cast_nonneg _) hlogN
+  have hab : (p.1 : ℝ) ≤ p.2 := by
+    have horder : (1 - (ε : ℝ) / 4) * D ≤ (1 + (ε : ℝ) / 4) * D := by
+      nlinarith [mul_nonneg hεR.le hD0]
+    exact ha1.trans (horder.trans hb0)
+  change (1 - (ε : ℝ)) * D ≤ (p.1 : ℝ) ∧ _
+  refine ⟨ha0, hb1, hfive.trans hlength, ?_, ?_⟩
+  · intro r hr
+    exact localizedCoulombProfile_gap hfreq hfive hleak₂ (hsepA.trans hr)
+  · intro K hKlo hKhi
+    have hK : (0 : ℝ) ≤ K := (inv_nonneg.mpr (pow_nonneg hNp.le A)).trans hKlo
+    have hτ : 0 ≤ ((N : ℝ) ^ B)⁻¹ := inv_nonneg.mpr (pow_nonneg hNp.le B)
+    obtain ⟨htlo, hthi⟩ := hrange N hNR K hKlo hKhi
+    have htargetA := coulombHoppingTarget_bounds hfreq hfive hleak₂ hsepA hτ hK
+    have htargetB := coulombHoppingTarget_bounds hfreq hfive hleak₂ (hsepA.trans hab) hτ hK
+    exact ⟨sub_nonneg.mpr ((htargetA.2.trans hthi).trans haHop),
+      sub_nonpos.mpr (hbHop.trans (htlo.trans htargetB.1))⟩
+
+end ContinuumCoulomb.CalibrationRationalBracket
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationEndpointSigns.lean

@@ -0,0 +1,108 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CalibrationRationalBracket
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.PlanarScaleChoice
+
+namespace OAI
+
+/-! The rational endpoints retain the analytic polynomial hopping brackets.
+This uses the proved exponential envelopes and does not require monotonicity
+of the hopping function. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibrationRationalBracket
+
+theorem brackets_of_larger_tolerance {A k : ℕ} {ε η N : ℝ}
+    (hε : 0 ≤ ε) (hεη : ε ≤ η) (hη1 : η ≤ 1) (hN : 2 ≤ N)
+    (hd : 2 ≤ (1 - η) * ((k : ℝ) * Real.log N))
+    (hγ : 0 ≤ (k : ℝ) * ε - ((A : ℝ) + 1))
+    (hlo : (k : ℝ) + 3 ≤ planarHoppingLowerConstant *
+      (2 : ℝ) ^ ((k : ℝ) * ε - ((A : ℝ) + 1)))
+    (hhi : planarHoppingUpperConstant * (2 * (k : ℝ) + 1) ≤
+      (2 : ℝ) ^ ((k : ℝ) * ε - ((A : ℝ) + 1))) :
+    N ^ A ≤ N ^ k * planarHopping ((1 - η) * ((k : ℝ) * Real.log N)) ∧
+      N ^ k * planarHopping ((1 + η) * ((k : ℝ) * Real.log N)) ≤ (N ^ A)⁻¹ := by
+  have he : (k : ℝ) * ε - ((A : ℝ) + 1) ≤ (k : ℝ) * η - ((A : ℝ) + 1) :=
+    sub_le_sub_right (mul_le_mul_of_nonneg_left hεη (Nat.cast_nonneg _)) _
+  have hp := Real.rpow_le_rpow_of_exponent_le (by norm_num : (1 : ℝ) ≤ 2) he
+  have h := planar_polynomial_brackets (hε.trans hεη) hη1 hN hd (hγ.trans he)
+    (hlo.trans (mul_le_mul_of_nonneg_left hp planarHoppingLowerConstant_positive.le))
+    (hhi.trans hp)
+  have heq : Real.exp ((k : ℝ) * Real.log N) = N ^ k := by
+    rw [Real.exp_nat_mul, Real.exp_log (by linarith)]
+  simpa only [heq] using h
+
+theorem exists_rational_hopping_brackets (ε : ℚ) (hε : 0 < ε) (hε1 : ε < 1)
+    (A : ℕ) (kmin : ℝ) :
+    ∃ (c : ℚ) (k : ℕ), 0 < c ∧ 0 < k ∧ kmin ≤ (k : ℝ) ∧
+      ∀ N : ℕ, 2 ≤ N →
+        let D := (k : ℝ) * Real.log (N : ℝ)
+        let p := endpoints ε (RationalLogScale.value c k N)
+        (1 - (ε : ℝ)) * D ≤ p.1 ∧ p.1 ≤ (1 - (ε : ℝ) / 4) * D ∧
+          (1 + (ε : ℝ) / 4) * D ≤ p.2 ∧ p.2 ≤ (1 + (ε : ℝ)) * D ∧
+          (N : ℝ) ^ A ≤ (N : ℝ) ^ k * planarHopping p.1 ∧
+          (N : ℝ) ^ k * planarHopping p.2 ≤ ((N : ℝ) ^ A)⁻¹ := by
+  have hεR : (0 : ℝ) < ε := by exact_mod_cast hε
+  have hεR1 : (ε : ℝ) < 1 := by exact_mod_cast hε1
+  have hlog : 0 < Real.log 2 := Real.log_pos (by norm_num)
+  obtain ⟨c, hcpos, hc⟩ := RationalLogScale.exists_logTwo_approximation
+    (show (0 : ℝ) < (ε : ℝ) / 16 by positivity)
+    (show (ε : ℝ) / 16 ≤ 1 by linarith)
+  have hc' : |(c : ℝ) - Real.log 2| ≤ (ε : ℝ) / 64 * Real.log 2 := by
+    convert hc using 1; ring
+  let B : ℝ := max kmin (max (128 / (ε : ℝ)) (2 / ((1 - (ε : ℝ)) * Real.log 2)))
+  obtain ⟨k, hkpos, hkB, hγ, _hd, hlo, hhi⟩ := exists_planar_scale_conditions_above
+    B A (show (0 : ℝ) < (ε : ℝ) / 4 by positivity)
+    (show (ε : ℝ) / 4 < 1 by linarith)
+  have hkmin : kmin ≤ (k : ℝ) := (le_max_left _ _).trans hkB
+  have hkcount : 128 ≤ (ε : ℝ) * (k : ℝ) := by
+    have hb : 128 / (ε : ℝ) ≤ (k : ℝ) :=
+      (le_max_left _ _).trans ((le_max_right _ _).trans hkB)
+    nlinarith [(div_le_iff₀ hεR).mp hb]
+  have hkfloor : 2 ≤ (1 - (ε : ℝ)) * ((k : ℝ) * Real.log 2) := by
+    have hb : 2 / ((1 - (ε : ℝ)) * Real.log 2) ≤ (k : ℝ) :=
+      (le_max_right _ _).trans ((le_max_right _ _).trans hkB)
+    have hm := (div_le_iff₀ (mul_pos (sub_pos.mpr hεR1) hlog)).mp hb
+    nlinarith
+  refine ⟨c, k, hcpos, hkpos, hkmin, fun N hN => ?_⟩
+  have hNR : (2 : ℝ) ≤ N := by exact_mod_cast hN
+  have hlogN : Real.log 2 ≤ Real.log (N : ℝ) := Real.log_le_log (by norm_num) hNR
+  let D : ℝ := (k : ℝ) * Real.log (N : ℝ)
+  let p := endpoints ε (RationalLogScale.value c k N)
+  have hD : 0 < D := mul_pos (by exact_mod_cast hkpos) (hlog.trans_le hlogN)
+  have hfloor : 2 ≤ (1 - (ε : ℝ)) * D := by
+    have hm := mul_le_mul_of_nonneg_left hlogN (Nat.cast_nonneg k : (0 : ℝ) ≤ k)
+    exact hkfloor.trans (mul_le_mul_of_nonneg_left hm (sub_pos.mpr hεR1).le)
+  obtain ⟨ha0, ha1, hb0, hb1⟩ := rational_endpoint_bounds ε c hε hε1.le hc' k N hN hkcount
+  have har0 : 1 - (ε : ℝ) ≤ (p.1 : ℝ) / D := (le_div_iff₀ hD).mpr ha0
+  have har1 : (p.1 : ℝ) / D ≤ 1 - (ε : ℝ) / 4 := (div_le_iff₀ hD).mpr ha1
+  have hbr0 : 1 + (ε : ℝ) / 4 ≤ (p.2 : ℝ) / D := (le_div_iff₀ hD).mpr hb0
+  have hbr1 : (p.2 : ℝ) / D ≤ 1 + (ε : ℝ) := (div_le_iff₀ hD).mpr hb1
+  let ηa : ℝ := 1 - (p.1 : ℝ) / D
+  let ηb : ℝ := (p.2 : ℝ) / D - 1
+  have hηa : (ε : ℝ) / 4 ≤ ηa ∧ ηa ≤ (ε : ℝ) := by dsimp only [ηa]; constructor <;> linarith
+  have hηb : (ε : ℝ) / 4 ≤ ηb ∧ ηb ≤ (ε : ℝ) := by dsimp only [ηb]; constructor <;> linarith
+  have haeq : (1 - ηa) * D = (p.1 : ℝ) := by
+    dsimp only [ηa]
+    field_simp [hD.ne']; ring
+  have hbeq : (1 + ηb) * D = (p.2 : ℝ) := by
+    dsimp only [ηb]
+    field_simp [hD.ne']; ring
+  have hshort := brackets_of_larger_tolerance (show (0 : ℝ) ≤ (ε : ℝ) / 4 by positivity)
+    hηa.1 (hηa.2.trans hεR1.le) hNR
+    (hfloor.trans (mul_le_mul_of_nonneg_right (by linarith : 1 - (ε : ℝ) ≤ 1 - ηa) hD.le))
+    hγ hlo hhi
+  have hlong := brackets_of_larger_tolerance (show (0 : ℝ) ≤ (ε : ℝ) / 4 by positivity)
+    hηb.1 (hηb.2.trans hεR1.le) hNR
+    (hfloor.trans (mul_le_mul_of_nonneg_right (by linarith : 1 - (ε : ℝ) ≤ 1 - ηb) hD.le))
+    hγ hlo hhi
+  change (1 - (ε : ℝ)) * D ≤ (p.1 : ℝ) ∧ _
+  refine ⟨ha0, ha1, hb0, hb1, ?_, ?_⟩
+  · have hs : (N : ℝ) ^ A ≤ (N : ℝ) ^ k * planarHopping ((1 - ηa) * D) := hshort.1
+    rwa [haeq] at hs
+  · have hl : (N : ℝ) ^ k * planarHopping ((1 + ηb) * D) ≤ ((N : ℝ) ^ A)⁻¹ := hlong.2
+    rwa [hbeq] at hl
+
+end ContinuumCoulomb.CalibrationRationalBracket
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationGraphBudget.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.GraphCoefficientStability
+
+namespace OAI
+
+/-! A uniform coefficient budget for the actual calibrated Hubbard graph.
+The residual is measured against the analytic hopping target, while the
+conclusion concerns the finite-spin variational bottom. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped BigOperators
+
+theorem calibrated_coefficient_uniform_error {a K gap τ ε g N U : ℝ}
+    (hK : 0 ≤ K) (hKN : K ≤ N) (hg : 0 < g) (hgap : g ≤ gap) (hU : gap ≤ U)
+    (hτ : 0 ≤ τ) (hτ1 : τ ≤ 1)
+    (hres : |a - τ * Real.sqrt (K * gap)| ≤ ε) :
+    |a ^ 2 / gap - τ ^ 2 * K| ≤ ε * (2 * Real.sqrt (N * U) + ε) / g := by
+  have hgapp : 0 < gap := hg.trans_le hgap
+  have hε : 0 ≤ ε := (abs_nonneg _).trans hres
+  have hN : 0 ≤ N := hK.trans hKN
+  have hroot : Real.sqrt (K * gap) ≤ Real.sqrt (N * U) :=
+    Real.sqrt_le_sqrt (mul_le_mul hKN hU hgapp.le hN)
+  have htarget : τ * Real.sqrt (K * gap) ≤ Real.sqrt (N * U) :=
+    (mul_le_mul_of_nonneg_right hτ1 (Real.sqrt_nonneg _)).trans (by simpa using hroot)
+  have hnum : ε * (2 * τ * Real.sqrt (K * gap) + ε) ≤
+      ε * (2 * Real.sqrt (N * U) + ε) := by
+    apply mul_le_mul_of_nonneg_left _ hε
+    linarith
+  exact (calibrated_coefficient_error hK hgapp hτ hres).trans
+    ((div_le_div_of_nonneg_right hnum hgapp.le).trans
+      (div_le_div_of_nonneg_left (by positivity) hg hgap))
+
+namespace HubbardGlobal
+variable {Edge : Type*} [Fintype Edge]
+
+theorem calibrated_graphSourceBottom_uniform_error
+    (m : ℕ) (left right : Edge → Fin (m + 1))
+    (t K gap : Edge → ℝ) {τ ε g N U : ℝ}
+    (hK : ∀ e, 0 ≤ K e) (hKN : ∀ e, K e ≤ N)
+    (hg : 0 < g) (hgap : ∀ e, g ≤ gap e) (hU : ∀ e, gap e ≤ U)
+    (hτ : 0 ≤ τ) (hτ1 : τ ≤ 1)
+    (hres : ∀ e, |t e - τ * Real.sqrt (K e * gap e)| ≤ ε) :
+    |graphSourceBottom m left right (fun e => t e ^ 2 / gap e) -
+      graphSourceBottom m left right (fun e => τ ^ 2 * K e)| ≤
+        4 * Fintype.card Edge * (ε * (2 * Real.sqrt (N * U) + ε) / g) := by
+  apply (graphSourceBottom_stability m left right _ _).trans
+  calc
+    4 * ∑ e, |t e ^ 2 / gap e - τ ^ 2 * K e| ≤
+        4 * ∑ _e : Edge, ε * (2 * Real.sqrt (N * U) + ε) / g := by
+      apply mul_le_mul_of_nonneg_left _ (by norm_num)
+      exact Finset.sum_le_sum (fun e _ => calibrated_coefficient_uniform_error
+        (hK e) (hKN e) hg (hgap e) (hU e) hτ hτ1 (hres e))
+    _ = _ := by simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]; ring
+
+end HubbardGlobal
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationMesh.lean

@@ -0,0 +1,62 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.PhysicalNuclearProgram
+
+namespace OAI
+
+/-! Exact compatibility between polynomial hopping amplification and the
+equal masses of the unit-nucleus Gauss mesh. -/
+
+namespace ContinuumCoulomb.CalibrationMesh
+
+def base (n : ℕ) : ℕ := n^30
+def radius (n k : ℕ) : ℕ := n^k
+def mesh (n k : ℕ) : ℕ := n^(10*k)
+def width (n k : ℕ) : ℕ := n^(5*k)
+def horizontal (n k : ℕ) : ℕ := width n k ^ 10
+def prefactor (rho : ℕ) : ℚ := 8/(rho:ℚ)
+def amplification (rho n k : ℕ) : ℚ := prefactor rho * (base n:ℚ)^k
+
+theorem prefactor_positive {rho : ℕ} (hrho : 0 < rho) : 0 < prefactor rho := by
+  unfold prefactor
+  positivity
+
+theorem base_ge_two {n : ℕ} (hn : 2 ≤ n) : 2 ≤ base n := by
+  exact (by norm_num : 2 ≤ 2^30).trans (Nat.pow_le_pow_left hn 30)
+
+theorem mesh_positive {n : ℕ} (hn : 0 < n) (k : ℕ) : 0 < mesh n k := pow_pos hn _
+
+theorem base_power_eq_mesh_cube (n k : ℕ) : base n ^ k = mesh n k ^ 3 := by
+  simp only [base,mesh,← pow_mul]
+  congr 1
+  omega
+
+theorem amplification_eq_mesh (rho n k : ℕ) :
+    amplification rho n k = 8*(mesh n k:ℚ)^3/(rho:ℚ) := by
+  have he : (base n:ℚ)^k = (mesh n k:ℚ)^3 := by
+    exact_mod_cast base_power_eq_mesh_cube n k
+  rw [amplification,he,prefactor]
+  ring
+
+theorem physical_factor_eq (rho n k : ℕ) :
+    PhysicalNuclearProgram.factor rho (mesh n k) = (amplification rho n k)⁻¹ := by
+  rw [amplification_eq_mesh,PhysicalNuclearProgram.factor]
+  exact (inv_div _ _).symm
+
+theorem amplification_positive {rho n : ℕ} (hrho : 0 < rho) (hn : 0 < n) (k : ℕ) :
+    0 < amplification rho n k := by
+  rw [amplification_eq_mesh]
+  have hm := mesh_positive hn k
+  positivity
+
+theorem mesh_eq_radius (n k : ℕ) : mesh n k = radius n k ^ 10 := by
+  simp only [mesh,radius,← pow_mul]
+  congr 1
+  omega
+
+theorem width_eq_radius (n k : ℕ) : width n k = radius n k ^ 5 := by
+  simp only [width,radius,← pow_mul]
+  congr 1
+  omega
+
+end ContinuumCoulomb.CalibrationMesh
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationRationalBracket.lean

@@ -0,0 +1,60 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalLogScale
+
+namespace OAI
+
+/-! Rational endpoints lie inside the permitted contact interval and outside
+the smaller interval used for the analytic sign estimates. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CalibrationRationalBracket
+
+def endpoints (ε q : ℚ) : ℚ × ℚ := ((1 - ε / 2) * q, (1 + ε / 2) * q)
+
+theorem endpoint_bounds {ε D q : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) (hD : 0 ≤ D)
+    (hqlo : (1 - ε / 16) * D ≤ q) (hqhi : q ≤ (1 + ε / 16) * D) :
+    (1 - ε) * D ≤ (1 - ε / 2) * q ∧
+      (1 - ε / 2) * q ≤ (1 - ε / 4) * D ∧
+      (1 + ε / 4) * D ≤ (1 + ε / 2) * q ∧
+      (1 + ε / 2) * q ≤ (1 + ε) * D := by
+  have hc0 : 0 ≤ 1 - ε / 2 := by linarith
+  have hc1 : 0 ≤ 1 + ε / 2 := by linarith
+  have hsq : ε ^ 2 ≤ ε := by nlinarith
+  have ha0 : 1 - ε ≤ (1 - ε / 2) * (1 - ε / 16) := by nlinarith [sq_nonneg ε]
+  have ha1 : (1 - ε / 2) * (1 + ε / 16) ≤ 1 - ε / 4 := by nlinarith [sq_nonneg ε]
+  have hb0 : 1 + ε / 4 ≤ (1 + ε / 2) * (1 - ε / 16) := by nlinarith
+  have hb1 : (1 + ε / 2) * (1 + ε / 16) ≤ 1 + ε := by nlinarith
+  refine ⟨?_, ?_, ?_, ?_⟩
+  · exact (mul_le_mul_of_nonneg_right ha0 hD).trans
+      (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_left hqlo hc0)
+  · exact (mul_le_mul_of_nonneg_left hqhi hc0).trans
+      (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_right ha1 hD)
+  · exact (mul_le_mul_of_nonneg_right hb0 hD).trans
+      (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_left hqlo hc1)
+  · exact (mul_le_mul_of_nonneg_left hqhi hc1).trans
+      (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_right hb1 hD)
+
+theorem rational_endpoint_bounds (ε c : ℚ) (hε : 0 < ε) (hε1 : ε ≤ 1)
+    (hc : |(c : ℝ) - Real.log 2| ≤ (ε : ℝ) / 64 * Real.log 2)
+    (k N : ℕ) (hN : 2 ≤ N) (hk : 128 ≤ (ε : ℝ) * (k : ℝ)) :
+    let D := (k : ℝ) * Real.log (N : ℝ)
+    let p := endpoints ε (RationalLogScale.value c k N)
+    (1 - (ε : ℝ)) * D ≤ p.1 ∧ p.1 ≤ (1 - (ε : ℝ) / 4) * D ∧
+      (1 + (ε : ℝ) / 4) * D ≤ p.2 ∧ p.2 ≤ (1 + (ε : ℝ)) * D := by
+  have hεR : (0 : ℝ) < ε := by exact_mod_cast hε
+  have hεR1 : (ε : ℝ) ≤ 1 := by exact_mod_cast hε1
+  have hc' : |(c : ℝ) - Real.log 2| ≤ ((ε : ℝ) / 16) / 4 * Real.log 2 := by
+    convert hc using 1; ring
+  have hk' : 8 ≤ ((ε : ℝ) / 16) * (k : ℝ) := by nlinarith
+  obtain ⟨hlo, hhi⟩ := RationalLogScale.relative_bounds c
+    (show 0 < (ε : ℝ) / 16 by positivity) (show (ε : ℝ) / 16 ≤ 1 by linarith)
+    hc' k N hN hk'
+  have hD : 0 ≤ (k : ℝ) * Real.log (N : ℝ) :=
+    mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by exact_mod_cast (show 1 ≤ N by omega)))
+  simpa only [endpoints, Rat.cast_mul, Rat.cast_sub, Rat.cast_add, Rat.cast_div,
+    Rat.cast_one, Rat.cast_ofNat] using endpoint_bounds hεR hεR1 hD hlo hhi
+
+end ContinuumCoulomb.CalibrationRationalBracket
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CalibrationSquareError.lean

@@ -0,0 +1,54 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.RationalSquareRoot
+
+namespace OAI
+
+/-! Scalar error propagation for the square root appearing in the
+calibrated hopping target. Negative numerical gaps are clipped at zero. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+
+theorem clipped_difference_error {u v u' v' ε : ℝ} (hgap : 0 ≤ u - v)
+    (hu : |u' - u| ≤ ε) (hv : |v' - v| ≤ ε) :
+    |max 0 (u' - v') - (u - v)| ≤ 2 * ε := by
+  have hm := abs_max_sub_max_le_abs (u' - v') (u - v) (0 : ℝ)
+  rw [max_eq_left hgap] at hm
+  rw [max_comm 0 (u' - v')]
+  apply hm.trans
+  have he : (u' - v') - (u - v) = (u' - u) - (v' - v) := by ring
+  rw [he]
+  exact (abs_sub _ _).trans ((add_le_add hu hv).trans_eq (by ring))
+
+theorem clipped_sqrt_difference_error {u v u' v' K ε : ℝ}
+    (hK : 0 ≤ K) (hgap : 0 ≤ u - v)
+    (hu : |u' - u| ≤ ε) (hv : |v' - v| ≤ ε) :
+    |Real.sqrt (K * max 0 (u' - v')) - Real.sqrt (K * (u - v))| ≤
+      Real.sqrt (2 * K * ε) := by
+  have hs := RationalSquareRoot.sqrt_perturbation
+    (mul_nonneg hK (le_max_left 0 (u' - v'))) (mul_nonneg hK hgap)
+  have he : |K * max 0 (u' - v') - K * (u - v)| ≤ 2 * K * ε := by
+    rw [← mul_sub, abs_mul, abs_of_nonneg hK]
+    exact (mul_le_mul_of_nonneg_left (clipped_difference_error hgap hu hv) hK).trans_eq (by ring)
+  exact hs.trans (Real.sqrt_le_sqrt he)
+
+theorem calibrated_residual_error {scale τ K T T' u v u' v' r' εT εC εR : ℝ}
+    (hscale : 0 ≤ scale) (hτ : 0 ≤ τ) (hK : 0 ≤ K) (hgap : 0 ≤ u - v)
+    (hT : |T' - T| ≤ εT) (hu : |u' - u| ≤ εC) (hv : |v' - v| ≤ εC)
+    (hr : |r' - Real.sqrt (K * max 0 (u' - v'))| ≤ εR) :
+    |(scale * T' - τ * r') - (scale * T - τ * Real.sqrt (K * (u - v)))| ≤
+      scale * εT + τ * (εR + Real.sqrt (2 * K * εC)) := by
+  have hs := clipped_sqrt_difference_error hK hgap hu hv
+  have ht := (abs_sub_le r' (Real.sqrt (K * max 0 (u' - v')))
+    (Real.sqrt (K * (u - v)))).trans (add_le_add hr hs)
+  have he : (scale * T' - τ * r') - (scale * T - τ * Real.sqrt (K * (u - v))) =
+      scale * (T' - T) - τ * (r' - Real.sqrt (K * (u - v))) := by ring
+  rw [he]
+  apply (abs_sub _ _).trans
+  rw [abs_mul, abs_mul, abs_of_nonneg hscale, abs_of_nonneg hτ]
+  exact add_le_add (mul_le_mul_of_nonneg_left hT hscale) (mul_le_mul_of_nonneg_left ht hτ)
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CappedCoulombKernel.lean

@@ -0,0 +1,160 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.LocalizedCoulomb
+
+namespace OAI
+
+/-! A bounded Lipschitz kernel for literal Coulomb quadrature. The original
+singular potential differs only inside the cap radius; the next theorem
+controls that error by the actual Coulomb mass of the small ball. -/
+
+noncomputable section
+open MeasureTheory
+namespace ContinuumCoulomb
+
+def cappedCoulombKernel (ε : ℝ) (x : Position) : ℝ := (max ε ‖x‖)⁻¹
+
+theorem cappedCoulombKernel_nonnegative {ε : ℝ} (hε : 0 < ε) (x : Position) :
+    0 ≤ cappedCoulombKernel ε x := by
+  unfold cappedCoulombKernel
+  exact inv_nonneg.mpr (hε.le.trans (le_max_left _ _))
+
+theorem cappedCoulombKernel_le {ε : ℝ} (hε : 0 < ε) (x : Position) :
+    cappedCoulombKernel ε x ≤ ε⁻¹ :=
+  inv_anti₀ hε (le_max_left _ _)
+
+theorem cappedCoulombKernel_continuous {ε : ℝ} (hε : 0 < ε) :
+    Continuous (cappedCoulombKernel ε) := by
+  apply (continuous_const.max continuous_norm).inv₀
+  intro x
+  exact (hε.trans_le (le_max_left _ _)).ne'
+
+theorem cappedCoulombKernel_norm_sub {ε : ℝ} (hε : 0 < ε) (x y : Position) :
+    |cappedCoulombKernel ε x - cappedCoulombKernel ε y| ≤ ε⁻¹ ^ 2 * ‖x - y‖ := by
+  let a := max ε ‖x‖
+  let b := max ε ‖y‖
+  have ha : 0 < a := hε.trans_le (le_max_left _ _)
+  have hb : 0 < b := hε.trans_le (le_max_left _ _)
+  have hia : a⁻¹ ≤ ε⁻¹ := inv_anti₀ hε (le_max_left _ _)
+  have hib : b⁻¹ ≤ ε⁻¹ := inv_anti₀ hε (le_max_left _ _)
+  have hdiff : |a - b| ≤ ‖x - y‖ := by
+    have hm := abs_max_sub_max_le_abs ‖x‖ ‖y‖ ε
+    rw [max_comm ‖x‖ ε, max_comm ‖y‖ ε] at hm
+    exact hm.trans (abs_norm_sub_norm_le x y)
+  have he : cappedCoulombKernel ε x - cappedCoulombKernel ε y =
+      (b - a) * a⁻¹ * b⁻¹ := by
+    change a⁻¹ - b⁻¹ = _
+    field_simp [ha.ne', hb.ne']
+  rw [he, abs_mul, abs_mul, abs_of_pos (inv_pos.mpr ha),
+    abs_of_pos (inv_pos.mpr hb), abs_sub_comm b a]
+  calc
+    _ ≤ ‖x - y‖ * ε⁻¹ * ε⁻¹ := by gcongr
+    _ = _ := by ring
+
+theorem cappedCoulombKernel_difference {ε : ℝ} (hε : 0 < ε)
+    (x : Position) (hx : x ≠ 0) :
+    |NeutralAtom.coulombKernel x - cappedCoulombKernel ε x| ≤
+      (Metric.ball (0 : Position) ε).indicator NeutralAtom.coulombKernel x := by
+  have hn : 0 < ‖x‖ := norm_pos_iff.mpr hx
+  by_cases he : ‖x‖ < ε
+  · rw [Set.indicator_of_mem (by simpa only [Metric.mem_ball, dist_zero_right] using he)]
+    have hc : cappedCoulombKernel ε x = ε⁻¹ := by
+      unfold cappedCoulombKernel
+      rw [max_eq_left he.le]
+    rw [NeutralAtom.coulombKernel, hc, abs_of_nonneg (sub_nonneg.mpr (inv_anti₀ hn he.le))]
+    have hi := inv_nonneg.mpr hε.le
+    linarith
+  · rw [Set.indicator_of_notMem (by simpa only [Metric.mem_ball, dist_zero_right] using he)]
+    simp only [NeutralAtom.coulombKernel, cappedCoulombKernel, max_eq_right (le_of_not_gt he),
+      sub_self, abs_zero, le_refl]
+
+def cappedCoulombPotential (ε : ℝ) (ρ : Position → ℝ) (x : Position) : ℝ :=
+  ∫ y, cappedCoulombKernel ε (x - y) * ρ y
+
+theorem cappedCoulombPotential_integrable {ε : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (x : Position) :
+    Integrable (fun y => cappedCoulombKernel ε (x - y) * ρ y) := by
+  apply hρ.bdd_mul (c := ε⁻¹)
+    ((cappedCoulombKernel_continuous hε).comp (continuous_const.sub continuous_id)).aestronglyMeasurable
+  exact Filter.Eventually.of_forall (fun y => by
+    change ‖cappedCoulombKernel ε (x - y)‖ ≤ ε⁻¹
+    rw [Real.norm_of_nonneg (cappedCoulombKernel_nonnegative hε _)]
+    exact cappedCoulombKernel_le hε _)
+
+theorem cappedCoulombPotential_nonnegative {ε : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hpos : ∀ x, 0 ≤ ρ x) (x : Position) :
+    0 ≤ cappedCoulombPotential ε ρ x :=
+  integral_nonneg (fun y => mul_nonneg (cappedCoulombKernel_nonnegative hε _) (hpos y))
+
+theorem cappedCoulombPotential_le {ε : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (hpos : ∀ x, 0 ≤ ρ x) (x : Position) :
+    cappedCoulombPotential ε ρ x ≤ ε⁻¹ * ∫ y, ρ y := by
+  have h := integral_mono (cappedCoulombPotential_integrable hε hρ x)
+    (hρ.const_mul ε⁻¹) (fun y =>
+      mul_le_mul_of_nonneg_right (cappedCoulombKernel_le hε _) (hpos y))
+  simpa only [cappedCoulombPotential, integral_const_mul] using h
+
+theorem cappedCoulombPotential_norm_sub {ε : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (hpos : ∀ x, 0 ≤ ρ x) (x x' : Position) :
+    ‖cappedCoulombPotential ε ρ x - cappedCoulombPotential ε ρ x'‖ ≤
+      (ε⁻¹ ^ 2 * ∫ y, ρ y) * ‖x - x'‖ := by
+  unfold cappedCoulombPotential
+  rw [← integral_sub (cappedCoulombPotential_integrable hε hρ x)
+    (cappedCoulombPotential_integrable hε hρ x')]
+  have h := norm_integral_le_of_norm_le
+    (f := fun y => cappedCoulombKernel ε (x - y) * ρ y -
+      cappedCoulombKernel ε (x' - y) * ρ y)
+    (hρ.const_mul (ε⁻¹ ^ 2 * ‖x - x'‖))
+    (Filter.Eventually.of_forall (fun y => by
+      rw [← sub_mul, norm_mul, Real.norm_of_nonneg (hpos y), Real.norm_eq_abs]
+      apply mul_le_mul_of_nonneg_right _ (hpos y)
+      simpa only [sub_sub_sub_cancel_right] using
+        cappedCoulombKernel_norm_sub hε (x - y) (x' - y)))
+  rw [integral_const_mul] at h
+  convert h using 1
+  ring
+
+theorem cappedCoulombPotential_continuous {ε : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (hpos : ∀ x, 0 ≤ ρ x) :
+    Continuous (cappedCoulombPotential ε ρ) := by
+  have hc : 0 ≤ ε⁻¹ ^ 2 * ∫ y, ρ y :=
+    mul_nonneg (sq_nonneg _) (integral_nonneg hpos)
+  exact (show LipschitzWith ⟨ε⁻¹ ^ 2 * ∫ y, ρ y, hc⟩ (cappedCoulombPotential ε ρ) from
+    lipschitzWith_iff_norm_sub_le.mpr (cappedCoulombPotential_norm_sub hε hρ hpos)).continuous
+
+theorem cappedCoulombPotential_error {ε B : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (hpos : ∀ x, 0 ≤ ρ x)
+    (hbound : ∀ x, ρ x ≤ B) (x : Position) :
+    |NeutralAtom.potentialOf ρ x - cappedCoulombPotential ε ρ x| ≤
+      B * NeutralAtom.kernelBallMass ε := by
+  have hi := (NeutralAtom.bounded_density_convolution NeutralAtom.measurable_coulombKernel
+    NeutralAtom.coulombKernel_nonneg (NeutralAtom.coulombKernel_integrableOn_ball 1)
+    (fun _ => NeutralAtom.coulombKernel_le_one) hρ hpos hbound x).1
+  rw [NeutralAtom.potentialOf, cappedCoulombPotential,
+    ← integral_sub hi (cappedCoulombPotential_integrable hε hρ x)]
+  have hd := norm_integral_le_of_norm_le
+    (f := fun y => NeutralAtom.coulombKernel (x - y) * ρ y -
+      cappedCoulombKernel ε (x - y) * ρ y)
+    ((NeutralAtom.translated_kernel_indicator_integrable x ε).const_mul B)
+    (by
+      filter_upwards [volume.ae_ne x] with y hy
+      rw [← sub_mul, norm_mul, Real.norm_of_nonneg (hpos y), Real.norm_eq_abs]
+      have hc := cappedCoulombKernel_difference hε (x - y) (sub_ne_zero.mpr hy.symm)
+      have hs : (Metric.ball (0 : Position) ε).indicator NeutralAtom.coulombKernel (x - y) =
+          (Metric.ball x ε).indicator (fun z => NeutralAtom.coulombKernel (x - z)) y := by
+        rw [NeutralAtom.translated_kernel_indicator_eq]
+      rw [hs] at hc
+      have hp : 0 ≤ (Metric.ball x ε).indicator
+          (fun z => NeutralAtom.coulombKernel (x - z)) y :=
+        Set.indicator_nonneg (fun z _ => NeutralAtom.coulombKernel_nonneg (x - z)) y
+      calc
+        _ ≤ (Metric.ball x ε).indicator
+            (fun z => NeutralAtom.coulombKernel (x - z)) y * B :=
+          mul_le_mul hc (hbound y) (hpos y) hp
+        _ = _ := mul_comm _ _)
+  simpa only [Real.norm_eq_abs, integral_const_mul,
+    NeutralAtom.translated_kernel_indicator_integral] using hd
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CappedCoulombMass.lean

@@ -0,0 +1,62 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedCoulombKernel
+
+namespace OAI
+
+/-! The exact three-dimensional near-pole mass makes the cap error
+quadratic in its rational radius. -/
+
+noncomputable section
+open MeasureTheory
+namespace ContinuumCoulomb
+
+theorem coulomb_kernelBallMass {ε : ℝ} (hε : 0 ≤ ε) :
+    NeutralAtom.kernelBallMass ε = 2 * Real.pi * ε ^ 2 := by
+  unfold NeutralAtom.kernelBallMass
+  rw [← integral_indicator measurableSet_ball]
+  have he : (Metric.ball (0 : Position) ε).indicator NeutralAtom.coulombKernel =
+      (fun x : Position => (Set.Iio ε).indicator (fun r : ℝ => r⁻¹) ‖x‖) := by
+    funext x
+    by_cases hx : ‖x‖ < ε
+    · simp [NeutralAtom.coulombKernel, Metric.mem_ball, dist_zero_right, hx]
+    · simp [Metric.mem_ball, dist_zero_right, hx]
+  rw [he, integral_fun_norm_addHaar volume]
+  have hi : (∫ r in Set.Ioi (0 : ℝ), r ^ (Module.finrank ℝ Position - 1) •
+      (Set.Iio ε).indicator (fun t : ℝ => t⁻¹) r) = ε ^ 2 / 2 := by
+    simp only [finrank_euclideanSpace_fin, smul_eq_mul]
+    norm_num
+    have hm : (fun r : ℝ => r ^ 2 * (Set.Iio ε).indicator (fun t : ℝ => t⁻¹) r) =
+        (Set.Iio ε).indicator (fun r : ℝ => r) := by
+      funext r
+      by_cases hr : r < ε
+      · simp only [Set.indicator_apply, Set.mem_Iio, hr, ite_true]
+        by_cases hzero : r = 0
+        · simp [hzero]
+        · field_simp [hzero]
+      · simp [hr]
+    rw [hm, setIntegral_indicator measurableSet_Iio]
+    have hinter : Set.Ioi (0 : ℝ) ∩ Set.Iio ε = Set.Ioo 0 ε := by ext r; rfl
+    rw [hinter, ← integral_Ioc_eq_integral_Ioo,
+      ← intervalIntegral.integral_of_le hε, integral_id]
+    ring
+  rw [hi]
+  simp only [Measure.real, EuclideanSpace.volume_ball_fin_three, ENNReal.ofReal_one, one_pow,
+    one_mul, ENNReal.toReal_ofReal (by positivity : 0 ≤ Real.pi * 4 / 3), smul_eq_mul,
+    nsmul_eq_mul]
+  norm_num [Position, finrank_euclideanSpace_fin]
+  ring
+
+theorem cappedCoulombPotential_error_explicit {ε B : ℝ} (hε : 0 < ε)
+    {ρ : Position → ℝ} (hρ : Integrable ρ) (hpos : ∀ x, 0 ≤ ρ x)
+    (hbound : ∀ x, ρ x ≤ B) (x : Position) :
+    |NeutralAtom.potentialOf ρ x - cappedCoulombPotential ε ρ x| ≤
+      2 * Real.pi * B * ε ^ 2 := by
+  have h := cappedCoulombPotential_error hε hρ hpos hbound x
+  rw [coulomb_kernelBallMass hε.le] at h
+  convert h using 1
+  ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CappedCoulombTruncation.lean

@@ -0,0 +1,95 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CappedCoulombKernel
+
+namespace OAI
+
+/-! Finite-box truncation of the bounded Coulomb integral. The bound is
+uniform in the displacement and uses only the discarded density masses. -/
+
+noncomputable section
+open MeasureTheory
+namespace ContinuumCoulomb
+
+def cappedPairIntegrand (ε : ℝ) (shift : Position) (f g : Position → ℝ)
+    (p : Position × Position) : ℝ :=
+  f p.1 * g p.2 * cappedCoulombKernel ε (p.1 - p.2 - shift)
+
+theorem cappedPairIntegrand_integrable {ε : ℝ} (hε : 0 < ε) (shift : Position)
+    {f g : Position → ℝ} (hf : Integrable f) (hg : Integrable g) :
+    Integrable (cappedPairIntegrand ε shift f g) := by
+  have hp : Integrable (fun p : Position × Position => f p.1 * g p.2) := by
+    simpa only [Measure.volume_eq_prod] using hf.mul_prod hg
+  unfold cappedPairIntegrand
+  apply hp.mul_bdd (c := ε⁻¹)
+    (((cappedCoulombKernel_continuous hε).comp
+      ((continuous_fst.sub continuous_snd).sub continuous_const)).aestronglyMeasurable)
+  exact Filter.Eventually.of_forall (fun p => by
+    change ‖cappedCoulombKernel ε (p.1 - p.2 - shift)‖ ≤ ε⁻¹
+    rw [Real.norm_of_nonneg (cappedCoulombKernel_nonnegative hε _)]
+    exact cappedCoulombKernel_le hε _)
+
+theorem cappedPair_truncation_error {ε : ℝ} (hε : 0 < ε) (shift : Position)
+    {f g : Position → ℝ} (hf : Integrable f) (hg : Integrable g)
+    (hf0 : ∀ x, 0 ≤ f x) (hg0 : ∀ y, 0 ≤ g y)
+    {S T : Set Position} (hS : MeasurableSet S) (hT : MeasurableSet T) :
+    |(∫ p, cappedPairIntegrand ε shift f g p) -
+      ∫ p in S ×ˢ T, cappedPairIntegrand ε shift f g p| ≤
+      ε⁻¹ * ((∫ x in Sᶜ, f x) * (∫ y, g y) +
+        (∫ x, f x) * (∫ y in Tᶜ, g y)) := by
+  let F := cappedPairIntegrand ε shift f g
+  let M : Position × Position → ℝ := fun p => ε⁻¹ *
+    (Sᶜ.indicator f p.1 * g p.2 + f p.1 * Tᶜ.indicator g p.2)
+  have hFi : Integrable F := cappedPairIntegrand_integrable hε shift hf hg
+  have hSi := hf.indicator hS.compl
+  have hTi := hg.indicator hT.compl
+  have hfirst : Integrable (fun p : Position × Position => Sᶜ.indicator f p.1 * g p.2) := by
+    simpa only [Measure.volume_eq_prod] using hSi.mul_prod hg
+  have hsecond : Integrable (fun p : Position × Position => f p.1 * Tᶜ.indicator g p.2) := by
+    simpa only [Measure.volume_eq_prod] using hf.mul_prod hTi
+  have hMi : Integrable M := by
+    simpa only [M, Pi.add_apply] using (hfirst.add hsecond).const_mul ε⁻¹
+  have hpt (p : Position × Position) :
+      ‖F p - (S ×ˢ T).indicator F p‖ ≤ M p := by
+    have hF0 : 0 ≤ F p := mul_nonneg (mul_nonneg (hf0 _) (hg0 _))
+      (cappedCoulombKernel_nonnegative hε _)
+    have hFbound : F p ≤ ε⁻¹ * (f p.1 * g p.2) := by
+      unfold F cappedPairIntegrand
+      calc
+        _ ≤ f p.1 * g p.2 * ε⁻¹ := mul_le_mul_of_nonneg_left
+          (cappedCoulombKernel_le hε _) (mul_nonneg (hf0 _) (hg0 _))
+        _ = _ := by ring
+    have hM0 : 0 ≤ M p := mul_nonneg (inv_nonneg.mpr hε.le)
+      (add_nonneg
+        (mul_nonneg (Set.indicator_nonneg (fun x _ => hf0 x) _) (hg0 _))
+        (mul_nonneg (hf0 _) (Set.indicator_nonneg (fun y _ => hg0 y) _)))
+    by_cases hs : p.1 ∈ S <;> by_cases ht : p.2 ∈ T
+    · rw [Set.indicator_of_mem (show p ∈ S ×ˢ T from ⟨hs, ht⟩), sub_self, norm_zero]
+      exact hM0
+    · have hp : p ∉ S ×ˢ T := by simp [ht]
+      rw [Set.indicator_of_notMem hp, sub_zero, Real.norm_of_nonneg hF0]
+      simpa only [M, Set.indicator_of_notMem (show p.1 ∉ Sᶜ by simpa using hs),
+        Set.indicator_of_mem (show p.2 ∈ Tᶜ from ht), zero_mul, zero_add] using hFbound
+    · have hp : p ∉ S ×ˢ T := by simp [hs]
+      rw [Set.indicator_of_notMem hp, sub_zero, Real.norm_of_nonneg hF0]
+      simpa only [M, Set.indicator_of_mem (show p.1 ∈ Sᶜ from hs),
+        Set.indicator_of_notMem (show p.2 ∉ Tᶜ by simpa using ht), mul_zero, add_zero] using hFbound
+    · have hp : p ∉ S ×ˢ T := by simp [hs]
+      rw [Set.indicator_of_notMem hp, sub_zero, Real.norm_of_nonneg hF0]
+      dsimp only [M]
+      rw [Set.indicator_of_mem (show p.1 ∈ Sᶜ from hs),
+        Set.indicator_of_mem (show p.2 ∈ Tᶜ from ht)]
+      have hz := mul_nonneg (inv_nonneg.mpr hε.le) (mul_nonneg (hf0 p.1) (hg0 p.2))
+      linarith
+  rw [← integral_indicator (hS.prod hT), ← integral_sub hFi (hFi.indicator (hS.prod hT))]
+  have h := norm_integral_le_of_norm_le
+    (f := fun p => F p - (S ×ˢ T).indicator F p) hMi (Filter.Eventually.of_forall hpt)
+  rw [Real.norm_eq_abs] at h
+  apply h.trans_eq
+  simp only [M, integral_const_mul]
+  rw [integral_add hfirst hsecond, Measure.volume_eq_prod, integral_prod_mul, integral_prod_mul,
+    integral_indicator hS.compl, integral_indicator hT.compl]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CappedRawModulus.lean

@@ -0,0 +1,74 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.RawDensityModulus
+
+namespace OAI
+
+/-! A polynomial modulus for the actual six-coordinate capped density
+integrand. Relative displacement has no effect on this modulus. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+
+theorem bounded_product_sub {a b c d : ℝ}
+    (ha0 : 0 ≤ a) (ha1 : a ≤ 1) (hd0 : 0 ≤ d) (hd1 : d ≤ 1) :
+    |a * b - c * d| ≤ |a - c| + |b - d| := by
+  have he : a * b - c * d = a * (b - d) + (a - c) * d := by ring
+  rw [he]
+  apply (abs_add_le _ _).trans
+  rw [abs_mul, abs_mul, abs_of_nonneg ha0, abs_of_nonneg hd0]
+  have h1 := mul_le_of_le_one_left (abs_nonneg (b - d)) ha1
+  have h2 := mul_le_of_le_one_right (abs_nonneg (a - c)) hd1
+  linarith
+
+theorem cappedRawPair_modulus {freq ε L : ℝ} (hf : 0 ≤ freq) (hε : 0 < ε)
+    (shift : Position) (x y x' y' : Position)
+    (hx : |(positionSplitCoordinates x).2| ≤ L)
+    (hy : |(positionSplitCoordinates y).2| ≤ L)
+    (hx' : |(positionSplitCoordinates x').2| ≤ L)
+    (hy' : |(positionSplitCoordinates y').2| ≤ L) :
+    |cappedPairIntegrand ε shift (localizedRawDensity freq) (localizedRawDensity freq) (x, y) -
+      cappedPairIntegrand ε shift (localizedRawDensity freq) (localizedRawDensity freq) (x', y')| ≤
+      ((64 + 2 * freq * L) * ε⁻¹ + ε⁻¹ ^ 2) * (‖x - x'‖ + ‖y - y'‖) := by
+  let a := localizedRawDensity freq x * localizedRawDensity freq y
+  let b := localizedRawDensity freq x' * localizedRawDensity freq y'
+  let k := cappedCoulombKernel ε (x - y - shift)
+  let k' := cappedCoulombKernel ε (x' - y' - shift)
+  have hb0 : 0 ≤ b := mul_nonneg (localizedRawDensity_nonnegative _ _) (localizedRawDensity_nonnegative _ _)
+  have hb1 : b ≤ 1 := (mul_le_mul (localizedRawDensity_le_one hf _)
+    (localizedRawDensity_le_one hf _) (localizedRawDensity_nonnegative _ _) zero_le_one).trans_eq (one_mul 1)
+  have hk0 : 0 ≤ k := cappedCoulombKernel_nonnegative hε _
+  have hk1 : k ≤ ε⁻¹ := cappedCoulombKernel_le hε _
+  have hab : |a - b| ≤ (64 + 2 * freq * L) * (‖x - x'‖ + ‖y - y'‖) := by
+    have h := bounded_product_sub (a := localizedRawDensity freq x)
+      (b := localizedRawDensity freq y) (c := localizedRawDensity freq x')
+      (d := localizedRawDensity freq y') (localizedRawDensity_nonnegative freq x)
+      (localizedRawDensity_le_one hf x) (localizedRawDensity_nonnegative freq y')
+      (localizedRawDensity_le_one hf y')
+    apply h.trans
+    have h1 := localizedRawDensity_box_modulus hf x x' hx hx'
+    have h2 := localizedRawDensity_box_modulus hf y y' hy hy'
+    linarith
+  have hkk : |k - k'| ≤ ε⁻¹ ^ 2 * (‖x - x'‖ + ‖y - y'‖) := by
+    have h := cappedCoulombKernel_norm_sub hε (x - y - shift) (x' - y' - shift)
+    have hn : ‖x - y - shift - (x' - y' - shift)‖ ≤ ‖x - x'‖ + ‖y - y'‖ := by
+      rw [show x - y - shift - (x' - y' - shift) = (x - x') - (y - y') by abel]
+      exact norm_sub_le _ _
+    exact h.trans (mul_le_mul_of_nonneg_left hn (sq_nonneg _))
+  have he : cappedPairIntegrand ε shift (localizedRawDensity freq) (localizedRawDensity freq) (x, y) -
+      cappedPairIntegrand ε shift (localizedRawDensity freq) (localizedRawDensity freq) (x', y') =
+      (a - b) * k + b * (k - k') := by
+    dsimp only [cappedPairIntegrand, a, b, k, k']
+    ring
+  rw [he]
+  apply (abs_add_le _ _).trans
+  rw [abs_mul, abs_mul, abs_of_nonneg hk0, abs_of_nonneg hb0]
+  have h1 := mul_le_mul hab hk1 hk0 (by
+    have hL : 0 ≤ L := (abs_nonneg _).trans hx
+    positivity)
+  have h2 := (mul_le_of_le_one_left (abs_nonneg (k - k')) hb1).trans hkk
+  nlinarith
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CappedWells.lean

@@ -0,0 +1,159 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Reduction.Model
+
+namespace OAI
+
+/-!
+# The explicit cap in the isolated-well construction
+
+The quintic transition is the normalized integral of a positive multiple
+of `s²(1-s)²`. Capping removes a whole neighbourhood of both nuclear poles.
+The resulting pointwise bound is uniform in the secondary displacements,
+as required before any energy tuning is carried out.
+-/
+
+noncomputable section
+open scoped BigOperators
+namespace ContinuumCoulomb
+
+def wellTransition (s : ℝ) : ℝ := 6 * s ^ 5 - 15 * s ^ 4 + 10 * s ^ 3
+
+theorem wellTransition_bounds {s : ℝ} (hs0 : 0 ≤ s) (hs1 : s ≤ 1) :
+    0 ≤ wellTransition s ∧ wellTransition s ≤ 1 := by
+  have hleft : wellTransition s =
+      s ^ 3 * (1 + 3 * (1 - s) + 6 * (1 - s) ^ 2) := by
+    unfold wellTransition
+    ring
+  have hright : 1 - wellTransition s = (1 - s) ^ 3 * (1 + 3 * s + 6 * s ^ 2) := by
+    unfold wellTransition
+    ring
+  have h0 : 0 ≤ wellTransition s := by rw [hleft]; positivity
+  have h1 : 0 ≤ 1 - wellTransition s := by rw [hright]; positivity
+  exact ⟨h0, by linarith⟩
+
+def wellCap (t : ℝ) : ℝ :=
+  if t ≤ 1 / 16 then 0 else if 1 / 8 ≤ t then 1 else wellTransition (16 * t - 1)
+
+theorem wellCap_eq_zero {t : ℝ} (ht : t ≤ 1 / 16) : wellCap t = 0 := by
+  simp only [wellCap, ite_eq_left ht]
+
+theorem wellCap_eq_one {t : ℝ} (ht : 1 / 8 ≤ t) : wellCap t = 1 := by
+  have hn : ¬ t ≤ 1 / 16 := by linarith
+  simp only [wellCap, ite_eq_right hn, ite_eq_left ht]
+
+theorem wellCap_bounds (t : ℝ) : 0 ≤ wellCap t ∧ wellCap t ≤ 1 := by
+  unfold wellCap
+  split_ifs with h0 h1
+  · norm_num
+  · norm_num
+  · exact wellTransition_bounds (by linarith) (by linarith)
+
+theorem wellCap_nonzero_radius {D r : ℝ} (hD : 0 < D)
+    (hcap : wellCap (r / D) ≠ 0) : D / 16 < r := by
+  have h : ¬ r / D ≤ 1 / 16 := fun hr => hcap (wellCap_eq_zero hr)
+  have hr := (lt_div_iff₀ hD).mp (lt_of_not_ge h)
+  linarith
+
+def sitePotential (q q' : ℝ) (center displacement x : Position) : ℝ :=
+  q * Coulomb.coulombKernel (x - center) +
+    q' * Coulomb.coulombKernel (x - center - displacement)
+
+def cappedSitePotential (D q q' : ℝ) (center displacement x : Position) : ℝ :=
+  wellCap (‖x - center‖ / D) * sitePotential q q' center displacement x
+
+theorem sitePotential_nonneg {q q' : ℝ} (hq : 0 ≤ q) (hq' : 0 ≤ q')
+    (center displacement x : Position) : 0 ≤ sitePotential q q' center displacement x := by
+  unfold sitePotential Coulomb.coulombKernel
+  positivity
+
+theorem cappedSitePotential_nonneg {D q q' : ℝ} (hq : 0 ≤ q) (hq' : 0 ≤ q')
+    (center displacement x : Position) :
+    0 ≤ cappedSitePotential D q q' center displacement x :=
+  mul_nonneg (wellCap_bounds _).1 (sitePotential_nonneg hq hq' _ _ _)
+
+theorem cappedSitePotential_zero_near_primary {D q q' : ℝ} (hD : 0 < D)
+    (center displacement x : Position) (hx : ‖x - center‖ ≤ D / 16) :
+    cappedSitePotential D q q' center displacement x = 0 := by
+  unfold cappedSitePotential
+  rw [wellCap_eq_zero ((div_le_iff₀ hD).mpr (by linarith)), zero_mul]
+
+/-- The cap removes the secondary pole together with an explicit surrounding
+ball; the cancellation is not merely a convention for the value at the pole. -/
+theorem cappedSitePotential_zero_near_secondary {D q q' : ℝ}
+    (hD : 128 ≤ D) (center displacement x : Position)
+    (hdisp : ‖displacement‖ ≤ 4)
+    (hx : ‖x - center - displacement‖ ≤ D / 32) :
+    cappedSitePotential D q q' center displacement x = 0 := by
+  have hD0 : 0 < D := by linarith
+  have hnorm : ‖x - center‖ ≤ D / 16 := by
+    calc
+      ‖x - center‖ = ‖(x - center - displacement) + displacement‖ := by congr 1; abel
+      _ ≤ ‖x - center - displacement‖ + ‖displacement‖ := norm_add_le _ _
+      _ ≤ D / 16 := by linarith
+  unfold cappedSitePotential
+  rw [wellCap_eq_zero ((div_le_iff₀ hD0).mpr (by linarith)), zero_mul]
+
+theorem cappedSitePotential_bound {D q q' : ℝ} (hD : 128 ≤ D)
+    (hq : 0 ≤ q) (hq' : 0 ≤ q') (center displacement x : Position)
+    (hdisp : ‖displacement‖ ≤ 4) :
+    cappedSitePotential D q q' center displacement x ≤ (16 * q + 32 * q') / D := by
+  have hD0 : 0 < D := by linarith
+  by_cases hc : wellCap (‖x - center‖ / D) = 0
+  · simp only [cappedSitePotential, hc, zero_mul]
+    positivity
+  · have hr := wellCap_nonzero_radius hD0 hc
+    have hs : D / 32 ≤ ‖x - center - displacement‖ := by
+      have ht : ‖x - center‖ ≤ ‖x - center - displacement‖ + ‖displacement‖ := by
+        calc
+          _ = ‖(x - center - displacement) + displacement‖ := by congr 1; abel
+          _ ≤ _ := norm_add_le _ _
+      linarith
+    have hprimary : Coulomb.coulombKernel (x - center) ≤ 16 / D := by
+      unfold Coulomb.coulombKernel
+      calc
+        _ ≤ (D / 16)⁻¹ := inv_anti₀ (by positivity) hr.le
+        _ = _ := by ring
+    have hsecondary : Coulomb.coulombKernel (x - center - displacement) ≤ 32 / D := by
+      unfold Coulomb.coulombKernel
+      calc
+        _ ≤ (D / 32)⁻¹ := inv_anti₀ (by positivity) hs
+        _ = _ := by ring
+    calc
+      cappedSitePotential D q q' center displacement x ≤ sitePotential q q' center displacement x :=
+        mul_le_of_le_one_left (sitePotential_nonneg hq hq' _ _ _) (wellCap_bounds _).2
+      _ ≤ q * (16 / D) + q' * (32 / D) :=
+        add_le_add (mul_le_mul_of_nonneg_left hprimary hq)
+          (mul_le_mul_of_nonneg_left hsecondary hq')
+      _ = _ := by ring
+
+def backgroundPotential {m : ℕ} (D q q' : ℝ) (center displacement : Fin m → Position)
+    (site : Fin m) (x : Position) : ℝ :=
+  ∑ j, if j = site then 0 else cappedSitePotential D q q' (center j) (displacement j) x
+
+theorem backgroundPotential_bounds {m : ℕ} {D q q' : ℝ} (hD : 128 ≤ D)
+    (hq : 0 ≤ q) (hq1 : q ≤ 1) (hq' : 0 ≤ q') (hq'1 : q' ≤ 1)
+    (center displacement : Fin m → Position) (hdisp : ∀ j, ‖displacement j‖ ≤ 4)
+    (site : Fin m) (x : Position) :
+    0 ≤ backgroundPotential D q q' center displacement site x ∧
+      backgroundPotential D q q' center displacement site x ≤ 48 * m / D := by
+  have hD0 : 0 < D := by linarith
+  constructor
+  · exact Finset.sum_nonneg fun j _ => by
+      split_ifs
+      · exact le_rfl
+      · exact cappedSitePotential_nonneg hq hq' _ _ _
+  · calc
+      _ ≤ ∑ _j : Fin m, (48 / D : ℝ) := by
+        apply Finset.sum_le_sum
+        intro j _
+        split_ifs
+        · positivity
+        · apply (cappedSitePotential_bound hD hq hq' _ _ _ (hdisp j)).trans
+          apply (div_le_div_iff_of_pos_right hD0).mpr
+          linarith
+      _ = _ := by simp; ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CenteredGaussEquiv.lean

@@ -0,0 +1,74 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.CenteredGaussProgram
+
+namespace OAI
+
+/-! The emitted centered label list is exactly the finite cell-by-eight-node
+grid used by the Coulomb quadrature theorems. -/
+
+noncomputable section
+open scoped BigOperators
+namespace ContinuumCoulomb.CenteredGaussLabels
+
+def decode (i : GaussLatticeIndex) : TransformedGauss.Label :=
+  ((i.1 0,(i.1 1,i.1 2)),(decide (i.2 0=1),(decide (i.2 1=1),decide (i.2 2=1))))
+
+private theorem bit_value (v : Fin 2) : (if decide (v=1) then (1:Fin 2) else 0) = v := by
+  fin_cases v <;> decide
+
+@[simp] theorem index_decode (i : GaussLatticeIndex) :
+    RationalGaussNodes.index (decode i).1 (decode i).2 = i := by
+  apply Prod.ext
+  · funext a
+    fin_cases a <;> rfl
+  · funext a
+    fin_cases a <;> exact bit_value _
+
+@[simp] theorem decode_index (l : TransformedGauss.Label) :
+    decode (RationalGaussNodes.index l.1 l.2) = l := by
+  apply TransformedGauss.index_injective
+  exact index_decode _
+
+def indexEquiv : TransformedGauss.Label ≃ GaussLatticeIndex where
+  toFun l := RationalGaussNodes.index l.1 l.2
+  invFun := decode
+  left_inv := decode_index
+  right_inv := index_decode
+
+abbrev Grid (r : Radii) :=
+  {k // k ∈ centeredGridIndices (radiiVector r)} × (Fin 3 → Fin 2)
+
+def restrictedEquiv (r : Radii) : {l // l ∈ labels r} ≃ Grid r where
+  toFun l := (⟨(indexEquiv l.val).1,(mem_labels r l.val).mp l.property⟩,(indexEquiv l.val).2)
+  invFun kv := ⟨decode (kv.1.val,kv.2),(mem_labels r _).mpr (by
+    rw [index_decode]
+    exact kv.1.property)⟩
+  left_inv l := Subtype.ext (decode_index l.val)
+  right_inv kv := by
+    have he := index_decode (kv.1.val,kv.2)
+    have h1 : (indexEquiv (decode (kv.1.val,kv.2))).1 = kv.1.val :=
+      congrArg (fun p : GaussLatticeIndex => p.1) he
+    have h2 : (indexEquiv (decode (kv.1.val,kv.2))).2 = kv.2 :=
+      congrArg (fun p : GaussLatticeIndex => p.2) he
+    exact Prod.ext (Subtype.ext h1) h2
+
+def enumerationEquiv (r : Radii) : Fin (labels r).length ≃ Grid r :=
+  (List.Nodup.getEquiv (labels r) (labels_nodup r)).trans (restrictedEquiv r)
+
+@[simp] theorem enumeration_first (r : Radii) (a : Fin (labels r).length) :
+    (enumerationEquiv r a).1.val = (RationalGaussNodes.index ((labels r).get a).1 ((labels r).get a).2).1 := rfl
+
+@[simp] theorem enumeration_second (r : Radii) (a : Fin (labels r).length) :
+    (enumerationEquiv r a).2 = (RationalGaussNodes.index ((labels r).get a).1 ((labels r).get a).2).2 := rfl
+
+theorem sum_enumeration {A : Type*} [AddCommMonoid A] (r : Radii) (f : GaussLatticeIndex → A) :
+    (∑ a : Fin (labels r).length,
+      f (RationalGaussNodes.index ((labels r).get a).1 ((labels r).get a).2)) =
+    ∑ k : {k // k ∈ centeredGridIndices (radiiVector r)}, ∑ v : Fin 3 → Fin 2, f (k.val,v) := by
+  have he := (enumerationEquiv r).sum_comp (fun kv : Grid r => f (kv.1.val,kv.2))
+  simpa only [Fintype.sum_prod_type,enumeration_first,enumeration_second] using he
+
+end ContinuumCoulomb.CenteredGaussLabels
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CenteredGaussLabels.lean

@@ -0,0 +1,73 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.TransformedGaussSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CenteredGrid
+
+namespace OAI
+
+/-! A concrete duplicate-free list of all eight Gauss labels in each cell
+of the centered rectangular grid, with the exact polynomial count. -/
+
+namespace ContinuumCoulomb.CenteredGaussLabels
+open EulerRegisters (Registers)
+open RationalGaussNodes (Signs)
+
+abbrev Radii := ℕ×(ℕ×ℕ)
+
+def integers (R : ℕ) : List ℤ :=
+  (List.range (2*R+1)).map (fun j : ℕ => (j:ℤ)-(R:ℤ))
+def signs : List Signs :=
+  [false,true] ×ˢ ([false,true] ×ˢ [false,true])
+def cells (r : Radii) : List Registers :=
+  integers r.1 ×ˢ (integers r.2.1 ×ˢ integers r.2.2)
+def labels (r : Radii) : List (Registers×Signs) := cells r ×ˢ signs
+def radiiVector (r : Radii) : Fin 3 → ℕ := ![r.1,r.2.1,r.2.2]
+
+theorem mem_integers (R : ℕ) (j : ℤ) : j ∈ integers R ↔ -(R:ℤ) ≤ j ∧ j ≤ R := by
+  constructor
+  · intro h
+    obtain ⟨i,hi,rfl⟩ := List.mem_map.mp h
+    have hi' := List.mem_range.mp hi
+    omega
+  · rintro ⟨hl,hu⟩
+    refine List.mem_map.mpr ⟨(j+(R:ℤ)).toNat,List.mem_range.mpr ?_,?_⟩ <;> omega
+
+theorem integers_nodup (R : ℕ) : (integers R).Nodup :=
+  (List.nodup_range).map (by
+    intro a b h
+    have he : (a:ℤ)-(R:ℤ) = (b:ℤ)-(R:ℤ) := h
+    omega)
+
+theorem signs_mem (s : Signs) : s ∈ signs := by
+  rcases s with ⟨a,b,c⟩
+  cases a <;> cases b <;> cases c <;> simp [signs]
+
+theorem labels_nodup (r : Radii) : (labels r).Nodup := by
+  apply List.Nodup.product
+  · exact (integers_nodup r.1).product ((integers_nodup r.2.1).product (integers_nodup r.2.2))
+  · decide
+
+theorem labels_length (r : Radii) :
+    (labels r).length = 8*((2*r.1+1)*(2*r.2.1+1)*(2*r.2.2+1)) := by
+  simp only [labels,cells,signs,integers,List.length_product,List.length_map,List.length_range]
+  simp only [List.length_cons,List.length_nil]
+  ring
+
+theorem mem_labels (r : Radii) (l : Registers×Signs) :
+    l ∈ labels r ↔ (RationalGaussNodes.index l.1 l.2).1 ∈ centeredGridIndices (radiiVector r) := by
+  rcases l with ⟨⟨a,b,c⟩,s⟩
+  rw [labels,List.mem_product]
+  simp only [signs_mem,and_true,cells,List.mem_product,mem_integers]
+  rw [mem_centeredGridIndices]
+  constructor
+  · rintro ⟨h0,h1,h2⟩ i
+    fin_cases i
+    · simpa [RationalGaussNodes.index,radiiVector] using h0
+    · simpa [RationalGaussNodes.index,radiiVector] using h1
+    · simpa [RationalGaussNodes.index,radiiVector] using h2
+  · intro h
+    exact ⟨by simpa [RationalGaussNodes.index,radiiVector] using h 0,
+      by simpa [RationalGaussNodes.index,radiiVector] using h 1,
+      by simpa [RationalGaussNodes.index,radiiVector] using h 2⟩
+
+end ContinuumCoulomb.CenteredGaussLabels
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CenteredGrid.lean

@@ -0,0 +1,98 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.CubeIntegral
+
+namespace OAI
+
+/-! A concrete finite family of lattice cubes tiles the enclosing rectangular
+slab, including its boundary. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators Classical
+namespace ContinuumCoulomb
+
+def centeredGridIndices (r : Fin 3 → ℕ) : Finset (Fin 3 → ℤ) :=
+  Fintype.piFinset (fun i => Finset.Icc (-(r i : ℤ)) (r i : ℤ))
+
+theorem mem_centeredGridIndices (r : Fin 3 → ℕ) (k : Fin 3 → ℤ) :
+    k ∈ centeredGridIndices r ↔ ∀ i, -(r i : ℤ) ≤ k i ∧ k i ≤ (r i : ℤ) := by
+  simp only [centeredGridIndices,Fintype.mem_piFinset,Finset.mem_Icc]
+
+theorem exists_centered_grid_integer (N : ℕ) {h x : ℝ} (hh : 0 < h)
+    (hx : |x| ≤ ((N:ℝ)+1/2)*h) :
+    ∃ k : ℤ, -(N:ℤ) ≤ k ∧ k ≤ (N:ℤ) ∧ |x-h*(k:ℝ)| ≤ h/2 := by
+  let j : ℤ := ⌊x/h+1/2⌋
+  have hx' := abs_le.mp hx
+  have he : (x/h)*h = x := div_mul_cancel₀ _ hh.ne'
+  have hjl : (j:ℝ) ≤ x/h+1/2 := Int.floor_le _
+  have hju : x/h+1/2 < (j:ℝ)+1 := Int.lt_floor_add_one _
+  have hjlow : -(N:ℤ) ≤ j := by
+    apply Int.le_floor.mpr
+    push_cast
+    nlinarith
+  by_cases hj : j ≤ (N:ℤ)
+  · refine ⟨j,hjlow,hj,abs_le.mpr ⟨?_,?_⟩⟩
+    · nlinarith [mul_le_mul_of_nonneg_right hjl hh.le]
+    · nlinarith [mul_lt_mul_of_pos_right hju hh]
+  · refine ⟨(N:ℤ),by omega,le_rfl,abs_le.mpr ⟨?_,?_⟩⟩
+    · have hjn : (N:ℝ)+1 ≤ (j:ℝ) := by exact_mod_cast (show (N:ℤ)+1 ≤ j by omega)
+      norm_num only [Int.cast_natCast]
+      nlinarith [mul_le_mul_of_nonneg_right hjn hh.le,mul_le_mul_of_nonneg_right hjl hh.le]
+    · exact_mod_cast (show x-h*(N:ℝ) ≤ h/2 by nlinarith [hx'.2])
+
+theorem centeredGrid_covers (r : Fin 3 → ℕ) {h : ℝ} (hh : 0 < h) :
+    (⋃ k : {k // k ∈ centeredGridIndices r}, positionCube (gaussCellCenter h k.val) h) =
+      {x : Position | ∀ i, |x i| ≤ ((r i:ℝ)+1/2)*h} := by
+  ext x
+  constructor
+  · intro hx
+    obtain ⟨k,hk⟩ := Set.mem_iUnion.mp hx
+    have hki := (mem_centeredGridIndices r k.val).mp k.property
+    intro i
+    have hc := abs_le.mp (mem_positionCube.mp hk i)
+    have hb1 : -(r i:ℝ) ≤ (k.val i:ℝ) := by exact_mod_cast (hki i).1
+    have hb2 : (k.val i:ℝ) ≤ (r i:ℝ) := by exact_mod_cast (hki i).2
+    apply abs_le.mpr
+    change -(h/2) ≤ x i-h*(k.val i:ℝ) ∧ x i-h*(k.val i:ℝ) ≤ h/2 at hc
+    rcases hc with ⟨hcl,hcu⟩
+    constructor <;> nlinarith [mul_le_mul_of_nonneg_left hb1 hh.le,
+      mul_le_mul_of_nonneg_left hb2 hh.le]
+  · intro hx
+    choose k hk1 hk2 hk3 using fun i => exists_centered_grid_integer (r i) hh (hx i)
+    refine Set.mem_iUnion.mpr ⟨⟨k,(mem_centeredGridIndices r k).mpr (fun i => ⟨hk1 i,hk2 i⟩)⟩,?_⟩
+    rw [mem_positionCube]
+    exact hk3
+
+theorem grid_cell_integral_sum_eq {ι : Type*} [Fintype ι]
+    (index : ι → Fin 3 → ℤ) (hindex : Function.Injective index)
+    {h : ℝ} (hh : 0 < h) {B : Set Position}
+    (hcover : (⋃ i, positionCube (gaussCellCenter h (index i)) h) = B)
+    (f : Position → ℝ) (hf : IntegrableOn f B) :
+    (∑ i, ∫ x in positionCube (gaussCellCenter h (index i)) h, f x) = ∫ x in B, f x := by
+  have he (i : ι) := positionOpenCube_ae_eq (gaussCellCenter h (index i)) h
+  have hsets : (⋃ i, positionOpenCube (gaussCellCenter h (index i)) h) =ᵐ[volume]
+      (⋃ i, positionCube (gaussCellCenter h (index i)) h) := by
+    filter_upwards [ae_all_iff.mpr he] with x hx
+    simp only [Set.mem_iUnion]
+    simp_rw [hx]
+  have hi (i : ι) : IntegrableOn f (positionOpenCube (gaussCellCenter h (index i)) h) := by
+    apply hf.mono_set
+    intro x hx
+    rw [← hcover]
+    exact Set.mem_iUnion.mpr ⟨i,positionOpenCube_subset _ _ hx⟩
+  calc
+    _ = ∑ i, ∫ x in positionOpenCube (gaussCellCenter h (index i)) h, f x := by
+      apply Finset.sum_congr rfl
+      intro i _
+      exact (setIntegral_congr_set (he i)).symm
+    _ = ∫ x in ⋃ i, positionOpenCube (gaussCellCenter h (index i)) h, f x :=
+      (integral_iUnion_fintype (fun i => positionOpenCube_measurable _ _)
+        (fun i j hij => grid_openCubes_disjoint hh (fun he => hij (hindex he))) hi).symm
+    _ = ∫ x in ⋃ i, positionCube (gaussCellCenter h (index i)) h, f x :=
+      setIntegral_congr_set hsets
+    _ = _ := by rw [hcover]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/CenteredPhysicalThreshold.lean

@@ -0,0 +1,121 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.SlabBoxProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Reduction.PhysicalThreshold
+import OAI.MathematicalPhysics.ContinuumCoulomb.Programs.GaussianFrequencyProgram
+
+namespace OAI
+
+/-! Physical threshold reference for the exact half-cell boundary of the
+centered grid. The finite threshold is scaled by lambda and the true rational
+slab reference by lambda squared times the electron count. -/
+
+noncomputable section
+namespace ContinuumCoulomb.CenteredPhysicalThreshold
+
+abbrev Geometry := ℕ × (ℕ × ℕ)
+abbrev Input := Geometry × (ℕ × (ℕ × (ℚ × ℚ)))
+
+def amplification (rho mesh : ℕ) : ℚ := 8*(mesh:ℚ)^3/rho
+
+def precision (x : Input) : ℕ :=
+  8*(8*x.1.1^3+1)^2*(x.2.1+1)*(x.2.2.1+1)
+
+def reference (rho : ℕ) (x : Input) : ℚ :=
+  SlabBoxSchedule.value rho (SlabBoxSchedule.centered (precision x) x.1.1 x.1.2.1 x.1.2.2)+
+    (GaussianFrequency.approximate rho (precision x)-1)/2
+
+def offset (rho : ℕ) (x : Input) : ℚ :=
+  amplification rho x.1.1^2*x.2.1*reference rho x
+
+def value (rho : ℕ) (x : Input) : ℚ×ℚ :=
+  (offset rho x+amplification rho x.1.1*x.2.2.2.1,
+   offset rho x+amplification rho x.1.1*x.2.2.2.2)
+
+def actualReference (rho : ℕ) (g : Geometry) : ℝ :=
+  slabPotential (rho:ℝ) (SlabBoxSchedule.centeredWidth g.2.1 g.1:ℝ)
+    (SlabBoxSchedule.centeredWidth g.2.2 g.1:ℝ) 0+(GaussianFrequency.frequency rho-1)/2
+
+def actualOffset (rho : ℕ) (x : Input) : ℝ :=
+  (amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ)*actualReference rho x.1
+
+theorem reference_error (rho : ℕ) (x : Input) (hmesh : 0 < x.1.1) :
+    |(reference rho x:ℝ)-actualReference rho x.1| ≤
+      2/(precision x+1:ℝ) := by
+  have hs := SlabBoxSchedule.centered_error rho (precision x) x.1.1 x.1.2.1 x.1.2.2 hmesh
+  rw [← SlabBoxSchedule.centeredWidth_real,← SlabBoxSchedule.centeredWidth_real] at hs
+  have hf := GaussianFrequency.approximation_error rho (precision x)
+  have he : (reference rho x:ℝ)-actualReference rho x.1 =
+      ((SlabBoxSchedule.value rho (SlabBoxSchedule.centered (precision x) x.1.1 x.1.2.1 x.1.2.2):ℝ)-
+        slabPotential (rho:ℝ) (SlabBoxSchedule.centeredWidth x.1.2.1 x.1.1:ℝ)
+        (SlabBoxSchedule.centeredWidth x.1.2.2 x.1.1:ℝ) 0)+
+      ((GaussianFrequency.approximate rho (precision x):ℝ)-GaussianFrequency.frequency rho)/2 := by
+    simp only [reference,actualReference,Rat.cast_add,Rat.cast_sub,Rat.cast_div,Rat.cast_one,
+      Rat.cast_ofNat]
+    ring
+  rw [he]
+  apply (abs_add_le _ _).trans
+  rw [abs_div,abs_of_pos (by norm_num : (0:ℝ) < 2)]
+  have hn : 0 ≤ ((precision x:ℝ)+1)⁻¹ := by positivity
+  simp only [div_eq_mul_inv] at hs ⊢
+  nlinarith
+
+theorem amplification_bound (rho mesh : ℕ) (hrho : 0 < rho) :
+    0 ≤ (amplification rho mesh:ℝ) ∧ (amplification rho mesh:ℝ) ≤ 8*(mesh:ℝ)^3 := by
+  have hp : 0 < (rho:ℝ) := by exact_mod_cast hrho
+  have h1 : 1 ≤ (rho:ℝ) := by exact_mod_cast (Nat.succ_le_iff.mpr hrho)
+  simp only [amplification,Rat.cast_div,Rat.cast_mul,Rat.cast_ofNat,Rat.cast_pow,Rat.cast_natCast]
+  constructor
+  · positivity
+  · exact div_le_self (by positivity) h1
+
+theorem offset_error (rho : ℕ) (hrho : 0 < rho) (x : Input) (hmesh : 0 < x.1.1) :
+    |(offset rho x:ℝ)-actualOffset rho x| ≤ 1/(x.2.2.1+1:ℝ) := by
+  have he := reference_error rho x hmesh
+  have ha := amplification_bound rho x.1.1 hrho
+  have hsq : (amplification rho x.1.1:ℝ)^2 ≤ (8*(x.1.1:ℝ)^3+1)^2 := by
+    nlinarith
+  have hcoef : (amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ)*2 ≤
+      8*(8*(x.1.1:ℝ)^3+1)^2*((x.2.1:ℝ)+1) := by
+    have ht := mul_le_mul_of_nonneg_right hsq (Nat.cast_nonneg x.2.1)
+    nlinarith [sq_nonneg (8*(x.1.1:ℝ)^3+1)]
+  have hprec : (precision x:ℝ) =
+      8*(8*(x.1.1:ℝ)^3+1)^2*((x.2.1:ℝ)+1)*((x.2.2.1:ℝ)+1) := by
+    simp [precision]
+  have hden : 0 < (precision x:ℝ)+1 := by positivity
+  have hp : 0 < (x.2.2.1:ℝ)+1 := by positivity
+  have hprod : (amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ)*2*((x.2.2.1:ℝ)+1) ≤
+      (precision x:ℝ)+1 := by
+    rw [hprec]
+    nlinarith [mul_le_mul_of_nonneg_right hcoef hp.le]
+  have hid : (offset rho x:ℝ)-actualOffset rho x =
+      (amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ)*
+        ((reference rho x:ℝ)-actualReference rho x.1) := by
+    simp only [offset,actualOffset,Rat.cast_mul,Rat.cast_pow,Rat.cast_natCast]
+    ring
+  rw [hid,abs_mul,abs_of_nonneg (by positivity : 0 ≤ (amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ))]
+  apply (mul_le_mul_of_nonneg_left he (by positivity)).trans
+  apply (le_div_iff₀ hp).mpr
+  calc
+    _ = ((amplification rho x.1.1:ℝ)^2*(x.2.1:ℝ)*2*
+        ((x.2.2.1:ℝ)+1))/((precision x:ℝ)+1) := by ring
+    _ ≤ 1 := (div_le_one hden).mpr hprod
+
+theorem lower_error (rho : ℕ) (hrho : 0 < rho) (x : Input) (hmesh : 0 < x.1.1) :
+    |((value rho x).1:ℝ)-(actualOffset rho x+
+      (amplification rho x.1.1:ℝ)*(x.2.2.2.1:ℝ))| ≤ 1/(x.2.2.1+1:ℝ) := by
+  simpa only [value,Rat.cast_add,Rat.cast_mul,add_sub_add_right_eq_sub] using offset_error rho hrho x hmesh
+
+theorem upper_error (rho : ℕ) (hrho : 0 < rho) (x : Input) (hmesh : 0 < x.1.1) :
+    |((value rho x).2:ℝ)-(actualOffset rho x+
+      (amplification rho x.1.1:ℝ)*(x.2.2.2.2:ℝ))| ≤ 1/(x.2.2.1+1:ℝ) := by
+  simpa only [value,Rat.cast_add,Rat.cast_mul,add_sub_add_right_eq_sub] using offset_error rho hrho x hmesh
+
+theorem gap (rho : ℕ) (x : Input) :
+    (value rho x).2-(value rho x).1 = amplification rho x.1.1*(x.2.2.2.2-x.2.2.2.1) := by
+  unfold value
+  ring
+
+end ContinuumCoulomb.CenteredPhysicalThreshold
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/ClassicalH1.lean

@@ -0,0 +1,51 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Reduction.Model
+import Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts
+
+namespace OAI
+
+/-! C1 functions with square-integrable classical partials belong to the
+actual weak H1 domain. Only the test function needs compact support; this
+allows the decaying manufactured orbitals and their finite Slater sums. -/
+
+noncomputable section
+open MeasureTheory
+namespace ContinuumCoulomb
+
+theorem complex_C1_test_ibp {n : ℕ} (f : Configuration n → ℂ) (hf : ContDiff ℝ 1 f)
+    (φ : Configuration n → ℝ) (hφ : ContDiff ℝ 1 φ) (hc : HasCompactSupport φ) (v : Configuration n) :
+    (∫ x, f x * (fderiv ℝ φ x v : ℂ)) = -(∫ x, fderiv ℝ f x v * (φ x : ℂ)) := by
+  let g : Configuration n → ℂ := fun x => (φ x : ℂ)
+  have hg : ContDiff ℝ 1 g := Complex.ofRealCLM.contDiff.comp hφ
+  have hgc : HasCompactSupport g := hc.comp_left Complex.ofReal_zero
+  have hd (x : Configuration n) : fderiv ℝ g x v = (fderiv ℝ φ x v : ℂ) :=
+    congrArg (fun L : Configuration n →L[ℝ] ℂ => L v)
+      ((Complex.ofRealCLM.hasFDerivAt.comp x (hφ.differentiable (by norm_num) x).hasFDerivAt).fderiv)
+  have hf' : Continuous (fun x => fderiv ℝ f x v) :=
+    (hf.continuous_fderiv (by norm_num)).clm_apply continuous_const
+  have hg' : Continuous (fun x => fderiv ℝ g x v) :=
+    (hg.continuous_fderiv (by norm_num)).clm_apply continuous_const
+  have hi1 : Integrable (fun x => fderiv ℝ f x v * g x) :=
+    (hf'.mul hg.continuous).integrable_of_hasCompactSupport hgc.mul_left
+  have hi2 : Integrable (fun x => f x * fderiv ℝ g x v) :=
+    (hf.continuous.mul hg').integrable_of_hasCompactSupport (hgc.fderiv_apply ℝ v).mul_left
+  have hi3 : Integrable (fun x => f x * g x) :=
+    (hf.continuous.mul hg.continuous).integrable_of_hasCompactSupport hgc.mul_left
+  have h := integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable hi1 hi2 hi3
+    (fun x _ => hf.differentiable (by norm_num) x) (fun x _ => hg.differentiable (by norm_num) x)
+  simpa only [hd] using h
+
+def classicalH1State {n : ℕ} (f : SpinConfiguration n → Configuration n → ℂ)
+    (hf : ∀ s, ContDiff ℝ 1 (f s)) (hL2 : ∀ s, MemLp (f s) 2)
+    (hpartial : ∀ s a, MemLp (fun x => fderiv ℝ (f s) x (EuclideanSpace.single a 1)) 2) :
+    Coulomb.H1Vector n where
+  value := f
+  gradient s a x := fderiv ℝ (f s) x (EuclideanSpace.single a 1)
+  value_L2 := hL2
+  partial_L2 := hpartial
+  weak_partial s a φ hφ hc := complex_C1_test_ibp (f s) (hf s) φ (hφ.of_le (by simp)) hc _
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/OneParticle/ClassicalResidualPairing.lean

@@ -0,0 +1,135 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.WeakComplexLaplacian
+import OAI.MathematicalPhysics.ContinuumCoulomb.OneParticle.BoundedFormCross
+import OAI.MathematicalPhysics.ContinuumCoulomb.ManyBody.TensorTotalReplacement
+
+namespace OAI
+
+/-! An actual differential residual controls the mixed bounded-potential
+form against every weak-H1 state, without restricting its smoothness. -/
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators Classical
+namespace ContinuumCoulomb
+
+theorem h1Coordinates_complex_inner {n : ℕ} (u v : Coulomb.H1Vector n) (a : H1Index n) :
+    inner ℂ (h1Coordinates u a) (h1Coordinates v a) =
+      ∫ x, star (h1CoordinateFunction u a x)*h1CoordinateFunction v a x :=
+  h1_inner_complex_coordinate v a _ (h1Coordinate_memLp u a)
+
+theorem h1Coordinates_complex_mass_inner {n : ℕ} (u v : Coulomb.H1Vector n) :
+    (∑ s, inner ℂ (h1Coordinates u (Sum.inl s)) (h1Coordinates v (Sum.inl s))) =
+      inner ℂ u.toHilbert v.toHilbert := by
+  rw [PiLp.inner_apply]
+  rfl
+
+theorem boundedPotential_complex_pairing {n : ℕ} (u v : Coulomb.H1Vector n)
+    (V : Configuration n → ℝ) (hV : Continuous V) (B : ℝ) (hB : ∀ x, |V x| ≤ B)
+    (s : SpinConfiguration n) :
+    inner ℂ (h1Coordinates u (Sum.inl s))
+      (BoundedPotential.operator V hV B hB (h1Coordinates v (Sum.inl s))) =
+      ∫ x, star (u.value s x)*((V x:ℂ)*v.value s x) := by
+  rw [L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [(h1Coordinate_memLp u (Sum.inl s)).coeFn_toLp,
+    (h1Coordinate_memLp v (Sum.inl s)).coeFn_toLp,
+    BoundedPotential.operator_ae V hV B hB (h1Coordinates v (Sum.inl s))] with x hu hv hA
+  change h1Coordinates u (Sum.inl s) x = u.value s x at hu
+  change h1Coordinates v (Sum.inl s) x = v.value s x at hv
+  rw [hA,hu,hv,RCLike.inner_apply]
+  exact mul_comm _ _
+
+theorem classical_residual_pairing (hdensity : PublishedSobolevSmoothDensity)
+    {n : ℕ} (u v : Coulomb.H1Vector n)
+    (V : Configuration n → ℝ) (hV : Continuous V) (B E : ℝ) (hB : ∀ x, |V x| ≤ B)
+    (R : SpinConfiguration n → Configuration n → ℂ)
+    (hR : ∀ s, MemLp (R s) 2)
+    (hu : ∀ s, ContDiff ℝ 2 (u.value s))
+    (hdu : ∀ s a x, u.gradient s a x = configurationComplexPartial (u.value s) a x)
+    (heq : ∀ s x, R s x = (-1/2:ℂ)*configurationComplexLaplacian (u.value s) x+
+      (V x:ℂ)*u.value s x-(E:ℂ)*u.value s x) :
+    graphComplexCross (BoundedPotential.operator V hV B hB) (h1Coordinates u) (h1Coordinates v)-
+      (E:ℂ)*inner ℂ u.toHilbert v.toHilbert =
+      ∑ s, ∫ x, star (R s x)*v.value s x := by
+  have hm (s : SpinConfiguration n) : MemLp (fun x => (V x:ℂ)*u.value s x) 2 := by
+    apply (u.value_L2 s).of_le_mul (c := B)
+      ((Complex.continuous_ofReal.comp hV).aestronglyMeasurable.mul (u.value_L2 s).aestronglyMeasurable)
+    filter_upwards [] with x
+    change ‖(V x:ℂ)*u.value s x‖ ≤ B*‖u.value s x‖
+    simp only [norm_mul,Complex.norm_real,Real.norm_eq_abs]
+    exact mul_le_mul_of_nonneg_right (hB x) (norm_nonneg _)
+  have hLap (s : SpinConfiguration n) : MemLp (configurationComplexLaplacian (u.value s)) 2 := by
+    have hfun : configurationComplexLaplacian (u.value s) =
+        (fun x => (2:ℂ)*((V x:ℂ)*u.value s x-(E:ℂ)*u.value s x-R s x)) := by
+      funext x
+      linear_combination 2*(heq s x)
+    rw [hfun]
+    exact ((hm s).sub ((u.value_L2 s).const_mul (E:ℂ)) |>.sub (hR s)).const_mul 2
+  have hp (s : SpinConfiguration n) (a : Fin n × Fin 3) :
+      MemLp (configurationComplexPartial (u.value s) a) 2 :=
+    (memLp_congr_ae (Filter.Eventually.of_forall (hdu s a))).mp (u.partial_L2 s a)
+  have hkin (s : SpinConfiguration n) := weakH1_complex_laplacian_pairing hdensity
+    (u.value s) (hu s) (hp s) (hLap s) v s
+  have hpoint (s : SpinConfiguration n) :
+      (1/2:ℂ)*(∑ a, ∫ x, star (u.gradient s a x)*v.gradient s a x)+
+        (∫ x, star (u.value s x)*((V x:ℂ)*v.value s x))-
+        (E:ℂ)*(∫ x, star (u.value s x)*v.value s x) =
+        ∫ x, star (R s x)*v.value s x := by
+    have hLI := (hLap s).star.integrable_mul (v.value_L2 s)
+    have hVI := (hm s).star.integrable_mul (v.value_L2 s)
+    have hUI := (u.value_L2 s).star.integrable_mul (v.value_L2 s)
+    have hhalf : star (-1/2:ℂ) = (-1/2:ℂ) := by
+      change (starRingEnd ℂ) (-1/2) = (-1/2:ℂ)
+      simp only [map_div₀,map_neg,map_one,map_ofNat]
+    have hE : star (E:ℂ) = (E:ℂ) := Complex.conj_ofReal E
+    have hprod (x : Configuration n) : star (R s x)*v.value s x =
+        (-1/2:ℂ)*(star (configurationComplexLaplacian (u.value s) x)*v.value s x)+
+          star ((V x:ℂ)*u.value s x)*v.value s x-
+          (E:ℂ)*(star (u.value s x)*v.value s x) := by
+      rw [heq]
+      simp only [star_sub,star_add,star_mul,hhalf,hE]
+      ring
+    simp_rw [hprod]
+    have hsub := integral_sub ((hLI.const_mul (-1/2:ℂ)).add hVI) (hUI.const_mul (E:ℂ))
+    have hadd := integral_add (hLI.const_mul (-1/2:ℂ)) hVI
+    simp only [Pi.add_apply,Pi.mul_apply,Pi.star_apply] at hsub hadd
+    rw [hsub,hadd,integral_const_mul,integral_const_mul]
+    simp_rw [← hdu] at hkin
+    rw [hkin]
+    have hvprod : (∫ x, star ((V x:ℂ)*u.value s x)*v.value s x) =
+        ∫ x, star (u.value s x)*((V x:ℂ)*v.value s x) := by
+      congr 1
+      funext x
+      simp only [star_mul,Complex.star_def,Complex.conj_ofReal]
+      ring
+    rw [hvprod]
+    ring
+  rw [← h1Coordinates_complex_mass_inner]
+  simp only [graphComplexCross,h1Coordinates_complex_inner,boundedPotential_complex_pairing,
+    h1CoordinateFunction]
+  simp only [Finset.mul_sum,← Finset.sum_add_distrib,← Finset.sum_sub_distrib]
+  exact Finset.sum_congr rfl (fun s _ => by simpa only [Finset.mul_sum] using hpoint s)
+
+theorem residual_integral_square_bound {n : ℕ} (v : Coulomb.H1Vector n)
+    (R : SpinConfiguration n → Configuration n → ℂ) (hR : ∀ s, MemLp (R s) 2) :
+    ‖∑ s, ∫ x, star (R s x)*v.value s x‖^2 ≤
+      (∑ s, ∫ x, ‖R s x‖^2)*Coulomb.mass v := by
+  let r (s : SpinConfiguration n) : Lp ℂ 2 (volume : Measure (Configuration n)) :=
+    (hR s).toLp (R s)
+  have he (s : SpinConfiguration n) : (∫ x, star (R s x)*v.value s x) =
+      inner ℂ (r s) (h1Coordinates v (Sum.inl s)) :=
+    (h1_inner_complex_coordinate v (Sum.inl s) _ (hR s)).symm
+  simp only [he]
+  have ht : ‖∑ s, inner ℂ (r s) (h1Coordinates v (Sum.inl s))‖ ≤
+      ∑ s, ‖r s‖*‖h1Coordinates v (Sum.inl s)‖ :=
+    (norm_sum_le _ _).trans (Finset.sum_le_sum (fun s _ => norm_inner_le_norm _ _))
+  have hb := (pow_le_pow_left₀ (norm_nonneg _) ht 2).trans
+    (Finset.sum_mul_sq_le_sq_mul_sq Finset.univ _ _)
+  simpa only [r,Coulomb.norm_toLp_sq_complex,h1Coordinates_norm_sq,h1CoordinateFunction,
+    Coulomb.mass] using hb
+
+end ContinuumCoulomb
+
+end
+
+end OAI