import Mathlib.Data.Real.Basic import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan import Mathlib.Tactic.NormNum import Mathlib.Tactic.Ring import Mathlib.MeasureTheory.Integral.IntegralEqImproper import Mathlib.Analysis.SpecialFunctions.Integrals.Basic import Mathlib.Analysis.PSeries import Mathlib.NumberTheory.Harmonic.EulerMascheroni import Mathlib.Analysis.SpecialFunctions.ExpDeriv import PhysicsLogic.Framework.EffectiveRangeBoundStateExtraction import PhysicsLogic.Framework.LowEnergyEffectiveRangeReduction import PhysicsLogic.Papers.Bethe1949.BindingSensitivity import PhysicsLogic.Papers.Bethe1949.IntensityExtraction /-! # Formal Logic of Bethe's Effective-Range Paper This module parses H. A. Bethe's *Theory of the Effective Range in Nuclear Scattering*, `Physical Review` 76 (1949), 38-50. The radial Schrodinger calculations, integral evaluations, Coulomb-function analysis, and experimental reductions remain explicit proposition-valued inputs. Lean checks the transitions from exact comparison identities to controlled low-energy laws, empirical parameter extraction, and the qualified charge-dependence conclusion. -/ set_option autoImplicit false namespace PhysicsLogic.Papers.Bethe1949 open PhysicsLogic.Framework universe uChannel uEnergy uWaveFunction uPotential uExperiment uRegime /-- The paper-local derivation whose source is Bethe's exact radial comparison identity followed by the controlled zero-energy interior replacement. -/ inductive BetheEffectiveRangeDerivation where | comparisonIdentityAndInteriorReplacement deriving DecidableEq, Repr /-- Bethe's distinct source route from the comparison identity specialized to the deuteron ground state through the measured triplet-range extraction. -/ inductive BetheBoundStateExtractionDerivation where | comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction deriving DecidableEq, Repr /-- Bethe's comparison-wave-to-deuteron physical joining calculation. -/ inductive BetheEffectiveRangeBoundStateHandoffDerivation where | radialComparisonGroundStateSpecializationControlledRangeAndTripletEvidence deriving DecidableEq, Repr /-! Actual radial comparison and the controlled order-k-squared phase law. Source: original pp. 39-40, equations (5)-(16). Finite-radius Wronskian integration, asymptotic matching, and quantitative replacement control retain their separate analytic obligations. -/ namespace RadialComparison open MeasureTheory Set Filter noncomputable section def radialDerivative (wave : Real -> Real) (radius : Real) : Real := derivWithin wave (Ici 0) radius /-- Integral radial dynamics permit finite potential steps. The derivative is the actual one-sided radial derivative, not an independent readout. -/ def RegularRadialEquationAt (potential : Real -> Real) (waveSquare : Real) (wave : Real -> Real) (origin : Real) : Prop := ∃ slope : Real, ∀ radius : Real, 0 <= radius -> IntegrableOn (fun other => (potential other - waveSquare) * wave other) (Icc 0 radius) ∧ wave radius = origin + slope * radius + ∫ other in (0 : Real)..radius, (radius - other) * (potential other - waveSquare) * wave other ∧ HasDerivWithinAt wave (slope + ∫ other in (0 : Real)..radius, (potential other - waveSquare) * wave other) (Ici 0) radius theorem the_integral_radial_equation_fixes_its_origin_value (potential : Real -> Real) (waveSquare : Real) (wave : Real -> Real) (origin : Real) (equation : RegularRadialEquationAt potential waveSquare wave origin) : wave 0 = origin := by obtain ⟨slope, equation⟩ := equation simpa using (equation 0 le_rfl).2.1 structure Data where potential : Real -> Real waveNumberSquared : Fin 2 -> Real actual : Fin 2 -> Real -> Real comparison : Fin 2 -> Real -> Real namespace Data def waveSquareDifference (data : Data) : Real := data.waveNumberSquared 1 - data.waveNumberSquared 0 def wronskian (waves : Fin 2 -> Real -> Real) (radius : Real) : Real := waves 1 radius * radialDerivative (waves 0) radius - waves 0 radius * radialDerivative (waves 1) radius def boundaryRemainder (data : Data) (radius : Real) : Real := wronskian data.comparison radius - wronskian data.actual radius def phase (data : Data) (index : Fin 2) : Real := radialDerivative (data.comparison index) 0 def overlap (data : Data) (radius : Real) : Real := data.comparison 0 radius * data.comparison 1 radius - data.actual 0 radius * data.actual 1 radius def overlapIntegral (data : Data) : Real := ∫ radius in Ioi (0 : Real), data.overlap radius def SourceEquationsAt (data : Data) : Prop := (∀ index, RegularRadialEquationAt data.potential (data.waveNumberSquared index) (data.actual index) 0) ∧ ∀ index, RegularRadialEquationAt (fun _ => 0) (data.waveNumberSquared index) (data.comparison index) 1 /-- Exact finite-radius integrated identities (6) and (8). Their analytic derivation is an explicit input, before subtraction and the infinite limit. -/ def WronskianIntegralIdentitiesAt (data : Data) : Prop := ∀ radius : Real, 0 <= radius -> IntervalIntegrable (fun other => data.actual 0 other * data.actual 1 other) volume 0 radius ∧ IntervalIntegrable (fun other => data.comparison 0 other * data.comparison 1 other) volume 0 radius ∧ wronskian data.actual radius - wronskian data.actual 0 = data.waveSquareDifference * ∫ other in (0 : Real)..radius, data.actual 0 other * data.actual 1 other ∧ wronskian data.comparison radius - wronskian data.comparison 0 = data.waveSquareDifference * ∫ other in (0 : Real)..radius, data.comparison 0 other * data.comparison 1 other /-- The boundary and integral limits used between (8) and (9). Exact exterior matching with locally integrable overlap is sufficient, but a finite matching radius is not imposed on all short-range potentials. -/ def AsymptoticComparisonAt (data : Data) : Prop := IntegrableOn data.overlap (Ioi 0) ∧ Tendsto data.boundaryRemainder atTop (nhds 0) theorem the_regular_actual_waves_and_normalized_comparison_waves_have_distinct_origins (data : Data) (equations : data.SourceEquationsAt) (index : Fin 2) : data.actual index 0 = 0 ∧ data.comparison index 0 = 1 := ⟨the_integral_radial_equation_fixes_its_origin_value _ _ _ _ (equations.1 index), the_integral_radial_equation_fixes_its_origin_value _ _ _ _ (equations.2 index)⟩ theorem the_finite_radius_comparison_retains_the_boundary_remainder (data : Data) (equations : data.SourceEquationsAt) (identities : data.WronskianIntegralIdentitiesAt) (radius : Real) (future : 0 <= radius) : data.phase 1 - data.phase 0 = data.waveSquareDifference * (∫ other in (0 : Real)..radius, data.overlap other) - data.boundaryRemainder radius := by obtain ⟨actualInt, comparisonInt, actualIdentity, comparisonIdentity⟩ := identities radius future have first := data.the_regular_actual_waves_and_normalized_comparison_waves_have_distinct_origins equations 0 have second := data.the_regular_actual_waves_and_normalized_comparison_waves_have_distinct_origins equations 1 have actualOrigin : wronskian data.actual 0 = 0 := by simp [wronskian, first.1, second.1] have comparisonOrigin : wronskian data.comparison 0 = data.phase 0 - data.phase 1 := by simp [wronskian, phase, first.2, second.2] rw [actualOrigin, sub_zero] at actualIdentity rw [comparisonOrigin] at comparisonIdentity dsimp [overlap, boundaryRemainder] rw [intervalIntegral.integral_sub comparisonInt actualInt] linear_combination comparisonIdentity - actualIdentity theorem the_actual_boundary_limit_yields_bethes_comparison_identity (data : Data) (equations : data.SourceEquationsAt) (identities : data.WronskianIntegralIdentitiesAt) (asymptotic : data.AsymptoticComparisonAt) : data.phase 1 - data.phase 0 = data.waveSquareDifference * data.overlapIntegral := by have integralLimit := intervalIntegral_tendsto_integral_Ioi 0 asymptotic.1 tendsto_id have combined := (integralLimit.const_mul data.waveSquareDifference).sub asymptotic.2 simp only [sub_zero] at combined have equality : (fun radius : Real => data.waveSquareDifference * (∫ other in (0 : Real)..radius, data.overlap other) - data.boundaryRemainder radius) =ᶠ[atTop] fun _ => data.phase 1 - data.phase 0 := by filter_upwards [eventually_ge_atTop (0 : Real)] with radius future exact (data.the_finite_radius_comparison_retains_the_boundary_remainder equations identities radius future).symm exact tendsto_nhds_unique tendsto_const_nhds (combined.congr' equality) def zeroOverlap (data : Data) (radius : Real) : Real := data.comparison 0 radius ^ 2 - data.actual 0 radius ^ 2 def replacementIntegrand (data : Data) (radius : Real) : Real := data.comparison 0 radius * (data.comparison 1 radius - data.comparison 0 radius) - data.actual 0 radius * (data.actual 1 radius - data.actual 0 radius) /-- A sufficient quantitative version of the interior-wave replacement in (14). It controls an actual integral, not a predicate named "small error". -/ def InteriorReplacementAt (data : Data) (tolerance : Real) : Prop := 0 <= tolerance ∧ IntegrableOn data.replacementIntegrand (Ioi 0) ∧ (∫ radius in Ioi (0 : Real), |data.replacementIntegrand radius|) <= tolerance theorem the_replacement_integrand_is_the_actual_overlap_difference (data : Data) (radius : Real) : data.replacementIntegrand radius = data.overlap radius - data.zeroOverlap radius := by dsimp [replacementIntegrand, overlap, zeroOverlap] ring end Data namespace Approximation def twoParameterPhase (inverseLength effectiveRange waveSquare : Real) : Real := -inverseLength + waveSquare * effectiveRange / 2 def ExactComparisonAt (phase inverseLength energyRange waveSquare : Real) : Prop := phase = -inverseLength + waveSquare * energyRange / 2 def RangeReplacementAt (energyRange effectiveRange tolerance : Real) : Prop := 0 <= tolerance ∧ |energyRange / 2 - effectiveRange / 2| <= tolerance def PhaseApproximationAt (phase inverseLength effectiveRange waveSquare tolerance : Real) : Prop := 0 <= tolerance ∧ |phase - twoParameterPhase inverseLength effectiveRange waveSquare| <= |waveSquare| * tolerance theorem the_actual_phase_residual_is_the_range_replacement_error (phase inverseLength energyRange effectiveRange waveSquare : Real) (comparison : ExactComparisonAt phase inverseLength energyRange waveSquare) : phase - twoParameterPhase inverseLength effectiveRange waveSquare = waveSquare * (energyRange / 2 - effectiveRange / 2) := by rw [comparison] dsimp [twoParameterPhase] ring theorem controlled_range_replacement_gives_a_phase_error_bound (phase inverseLength energyRange effectiveRange waveSquare tolerance : Real) (comparison : ExactComparisonAt phase inverseLength energyRange waveSquare) (replacement : RangeReplacementAt energyRange effectiveRange tolerance) : PhaseApproximationAt phase inverseLength effectiveRange waveSquare tolerance := by refine ⟨replacement.1, ?_⟩ rw [the_actual_phase_residual_is_the_range_replacement_error _ _ _ _ _ comparison, abs_mul] exact mul_le_mul_of_nonneg_left replacement.2 (abs_nonneg _) theorem exact_phase_agreement_at_nonzero_energy_requires_exact_range_agreement (phase inverseLength energyRange effectiveRange waveSquare : Real) (nonzero : waveSquare ≠ 0) (comparison : ExactComparisonAt phase inverseLength energyRange waveSquare) : phase = twoParameterPhase inverseLength effectiveRange waveSquare ↔ energyRange = effectiveRange := by rw [← sub_eq_zero, the_actual_phase_residual_is_the_range_replacement_error _ _ _ _ _ comparison, mul_eq_zero, or_iff_right nonzero] constructor <;> intro h <;> linarith theorem the_actual_integral_error_bounds_the_range_replacement (data : Data) (energyRange effectiveRange tolerance : Real) (overlapInt : IntegrableOn data.overlap (Ioi 0)) (zeroInt : IntegrableOn data.zeroOverlap (Ioi 0)) (energyValue : energyRange / 2 = data.overlapIntegral) (zeroValue : effectiveRange / 2 = ∫ radius in Ioi (0 : Real), data.zeroOverlap radius) (control : data.InteriorReplacementAt tolerance) : RangeReplacementAt energyRange effectiveRange tolerance := by refine ⟨control.1, ?_⟩ rw [energyValue, zeroValue] change |(∫ radius in Ioi (0 : Real), data.overlap radius) - (∫ radius in Ioi (0 : Real), data.zeroOverlap radius)| <= tolerance rw [← integral_sub overlapInt zeroInt] have integrands : (fun radius => data.overlap radius - data.zeroOverlap radius) = data.replacementIntegrand := funext (fun radius => (data.the_replacement_integrand_is_the_actual_overlap_difference radius).symm) rw [integrands] exact abs_integral_le_integral_abs.trans control.2.2 theorem a_quadratic_range_error_gives_a_quartic_phase_error (phase inverseLength energyRange effectiveRange momentum coefficient : Real) (comparison : ExactComparisonAt phase inverseLength energyRange (momentum ^ 2)) (replacement : RangeReplacementAt energyRange effectiveRange (coefficient * momentum ^ 2)) : |phase - twoParameterPhase inverseLength effectiveRange (momentum ^ 2)| <= coefficient * momentum ^ 4 := by have bound := (controlled_range_replacement_gives_a_phase_error_bound _ _ _ _ _ _ comparison replacement).2 rw [abs_of_nonneg (sq_nonneg momentum)] at bound convert bound using 1 ring def UniformQuarticPhaseErrorAt (phase : Real -> Real) (inverseLength effectiveRange : Real) : Prop := EffectiveRangeExpansion.HasQuarticError phase (fun momentum => twoParameterPhase inverseLength effectiveRange (momentum ^ 2)) /-- A rate assumption, not just continuity at zero energy. The positive band and a single coefficient retain the uniform quantifiers of an order estimate. -/ def UniformQuadraticRangeControlOn (energyRange : Real -> Real) (effectiveRange radius coefficient : Real) : Prop := 0 < radius ∧ 0 <= coefficient ∧ ∀ momentum, 0 < momentum -> momentum < radius -> RangeReplacementAt (energyRange momentum) effectiveRange (coefficient * momentum ^ 2) theorem uniform_quadratic_range_control_derives_quartic_accuracy (phase energyRange : Real -> Real) (inverseLength effectiveRange radius coefficient : Real) (comparison : ∀ momentum, 0 < momentum -> momentum < radius -> ExactComparisonAt (phase momentum) inverseLength (energyRange momentum) (momentum ^ 2)) (control : UniformQuadraticRangeControlOn energyRange effectiveRange radius coefficient) : UniformQuarticPhaseErrorAt phase inverseLength effectiveRange := by refine ⟨radius, coefficient, control.1, control.2.1, ?_⟩ intro momentum positive small exact a_quadratic_range_error_gives_a_quartic_phase_error _ _ _ _ _ _ (comparison momentum positive small) (control.2.2 momentum positive small) end Approximation /-- One fixed potential and one fixed zero-energy reference underlie the positive-momentum family. The phase readout remains an actual derivative. -/ structure Family where potential : Real -> Real zeroActual : Real -> Real zeroComparison : Real -> Real actual : Real -> Real -> Real comparison : Real -> Real -> Real namespace Family def dataAt (family : Family) (momentum : Real) : Data where potential := family.potential waveNumberSquared := fun index => if index = 0 then 0 else momentum ^ 2 actual := fun index => if index = 0 then family.zeroActual else family.actual momentum comparison := fun index => if index = 0 then family.zeroComparison else family.comparison momentum def phaseFunction (family : Family) (momentum : Real) : Real := (family.dataAt momentum).phase 1 def zeroOverlap (family : Family) (radius : Real) : Real := family.zeroComparison radius ^ 2 - family.zeroActual radius ^ 2 theorem uniform_radial_inputs_realize_shared_effective_range_expansion (family : Family) (inverseLength effectiveRange radius coefficient : Real) (positiveRadius : 0 < radius) (nonnegative : 0 <= coefficient) (source : ∀ momentum, 0 < momentum -> momentum < radius -> (family.dataAt momentum).SourceEquationsAt ∧ (family.dataAt momentum).WronskianIntegralIdentitiesAt ∧ (family.dataAt momentum).AsymptoticComparisonAt) (zeroPhase : radialDerivative family.zeroComparison 0 = -inverseLength) (zeroIntegrable : IntegrableOn family.zeroOverlap (Ioi 0)) (zeroValue : effectiveRange / 2 = ∫ position in Ioi (0 : Real), family.zeroOverlap position) (control : ∀ momentum, 0 < momentum -> momentum < radius -> (family.dataAt momentum).InteriorReplacementAt (coefficient * momentum ^ 2)) : EffectiveRangeExpansion.NonvacuousEffectiveRangeExpansionAt family.phaseFunction inverseLength effectiveRange := by apply EffectiveRangeExpansion.quartic_control_establishes_nonvacuous_effective_range_expansion refine ⟨radius, coefficient, positiveRadius, nonnegative, ?_⟩ intro momentum positive small obtain ⟨equations, identities, asymptotic⟩ := source momentum positive small have identity := (family.dataAt momentum).the_actual_boundary_limit_yields_bethes_comparison_identity equations identities asymptotic have energy : (family.dataAt momentum).waveSquareDifference = momentum ^ 2 := by simp [Data.waveSquareDifference, dataAt] have origin : (family.dataAt momentum).phase 0 = -inverseLength := by simpa [Data.phase, dataAt] using zeroPhase rw [energy, origin] at identity have comparison : Approximation.ExactComparisonAt (family.phaseFunction momentum) inverseLength (2 * (family.dataAt momentum).overlapIntegral) (momentum ^ 2) := by dsimp [Approximation.ExactComparisonAt, phaseFunction] linear_combination identity have replacement := Approximation.the_actual_integral_error_bounds_the_range_replacement (family.dataAt momentum) (2 * (family.dataAt momentum).overlapIntegral) effectiveRange (coefficient * momentum ^ 2) asymptotic.1 (by simpa [Data.zeroOverlap, dataAt, zeroOverlap] using zeroIntegrable) (by ring) (by simpa [Data.zeroOverlap, dataAt, zeroOverlap] using zeroValue) (control momentum positive small) have bound := Approximation.a_quadratic_range_error_gives_a_quartic_phase_error (family.phaseFunction momentum) inverseLength (2 * (family.dataAt momentum).overlapIntegral) effectiveRange momentum coefficient comparison replacement have polynomial : Approximation.twoParameterPhase inverseLength effectiveRange (momentum ^ 2) = EffectiveRangeExpansion.twoParameterPhaseFunction inverseLength effectiveRange momentum := by dsimp [Approximation.twoParameterPhase, EffectiveRangeExpansion.twoParameterPhaseFunction] ring simpa only [polynomial] using bound end Family namespace Observation open Approximation PhysicsLogic.Paradigm.ScaleAndRegime /-- One actual neutral S-wave phase-function prediction at positive k squared. -/ def phaseContext : ApproximationContext Real Real Unit Real Real where predictions := { observableIn := fun _ waveSquare => 0 < waveSquare predicts := fun phase _ value => value = phase } validity := { validAt := fun _ waveSquare => 0 < waveSquare } agreesWithin := fun tolerance approximate target => |approximate - target| <= tolerance theorem the_phase_error_is_a_controlled_observable_approximation (phase inverseLength effectiveRange waveSquare tolerance : Real) (positive : 0 < waveSquare) (controlled : PhaseApproximationAt phase inverseLength effectiveRange waveSquare tolerance) : phaseContext.ControlledApproximation (twoParameterPhase inverseLength effectiveRange waveSquare) phase waveSquare (fun _ => True) (|waveSquare| * tolerance) := by refine ⟨positive, positive, ⟨(), phase, trivial, positive, rfl⟩, ?_⟩ intro _observable _selected _physical value predicted change value = phase at predicted subst value refine ⟨twoParameterPhase inverseLength effectiveRange waveSquare, rfl, ?_⟩ change |twoParameterPhase inverseLength effectiveRange waveSquare - phase| <= |waveSquare| * tolerance rw [abs_sub_comm] exact controlled.2 end Observation /-! These free waves satisfy the common radial equations at k squared = 0 and 1, but deliberately lack exterior matching. They are a boundary-condition diagnostic, not a realization of Bethe's selected scattering problem. -/ namespace FreeComparison def unmatched : Data where potential := fun _ => 0 waveNumberSquared := ![0, 1] actual := ![fun radius => radius, Real.sin] comparison := ![fun _ => 1, Real.cos] theorem the_weighted_sine_force_has_the_actual_integral (radius : Real) : (∫ other in (0 : Real)..radius, (radius - other) * (-Real.sin other)) = Real.sin radius - radius := by have primitive : ∀ other : Real, HasDerivAt (fun value => (radius - value) * Real.cos value + Real.sin value) ((radius - other) * (-Real.sin other)) other := by intro other convert (((hasDerivAt_const other radius).sub (hasDerivAt_id other)).mul (Real.hasDerivAt_cos other)).add (Real.hasDerivAt_sin other) using 1 dsimp ring simpa using intervalIntegral.integral_eq_sub_of_hasDerivAt (fun other _ => primitive other) ((by fun_prop : Continuous (fun other => (radius - other) * (-Real.sin other))).intervalIntegrable 0 radius) theorem the_weighted_cosine_force_has_the_actual_integral (radius : Real) : (∫ other in (0 : Real)..radius, (radius - other) * (-Real.cos other)) = Real.cos radius - 1 := by have primitive : ∀ other : Real, HasDerivAt (fun value => -(radius - value) * Real.sin value + Real.cos value) ((radius - other) * (-Real.cos other)) other := by intro other convert (((hasDerivAt_const other radius).sub (hasDerivAt_id other)).neg.mul (Real.hasDerivAt_sin other)).add (Real.hasDerivAt_cos other) using 1 dsimp ring simpa using intervalIntegral.integral_eq_sub_of_hasDerivAt (fun other _ => primitive other) ((by fun_prop : Continuous (fun other => (radius - other) * (-Real.cos other))).intervalIntegrable 0 radius) theorem the_unmatched_free_waves_satisfy_actual_radial_equations : unmatched.SourceEquationsAt := by constructor · intro index fin_cases index · change RegularRadialEquationAt (fun _ => 0) 0 (fun radius => radius) 0 refine ⟨1, fun radius _ => ?_⟩ simp only [sub_self, zero_mul, mul_zero, intervalIntegral.integral_zero, add_zero, zero_add, one_mul] exact ⟨integrableOn_zero, trivial, (hasDerivAt_id radius).hasDerivWithinAt⟩ · change RegularRadialEquationAt (fun _ => 0) 1 Real.sin 0 refine ⟨1, fun radius _ => ?_⟩ simp only [zero_sub, mul_neg_one, neg_mul, one_mul, zero_add] refine ⟨(by fun_prop : Continuous (fun other => -Real.sin other)).continuousOn.integrableOn_Icc, ?_, ?_⟩ · have integral := the_weighted_sine_force_has_the_actual_integral radius simp_rw [mul_neg] at integral rw [integral] ring · simpa [intervalIntegral.integral_neg, integral_sin] using (Real.hasDerivAt_sin radius).hasDerivWithinAt · intro index fin_cases index · change RegularRadialEquationAt (fun _ => 0) 0 (fun _ => 1) 1 refine ⟨0, fun radius _ => ?_⟩ simp only [sub_self, zero_mul, mul_zero, intervalIntegral.integral_zero, add_zero] exact ⟨integrableOn_zero, trivial, (hasDerivAt_const radius (1 : Real)).hasDerivWithinAt⟩ · change RegularRadialEquationAt (fun _ => 0) 1 Real.cos 1 refine ⟨0, fun radius _ => ?_⟩ simp only [zero_sub, mul_neg_one, neg_mul, one_mul, zero_mul, add_zero, zero_add] refine ⟨(by fun_prop : Continuous (fun other => -Real.cos other)).continuousOn.integrableOn_Icc, ?_, ?_⟩ · have integral := the_weighted_cosine_force_has_the_actual_integral radius simp_rw [mul_neg] at integral rw [integral] ring · simpa [intervalIntegral.integral_neg, integral_cos] using (Real.hasDerivAt_cos radius).hasDerivWithinAt theorem the_four_free_derivatives_are_actual (radius : Real) (future : 0 <= radius) : radialDerivative (unmatched.actual 0) radius = 1 ∧ radialDerivative (unmatched.actual 1) radius = Real.cos radius ∧ radialDerivative (unmatched.comparison 0) radius = 0 ∧ radialDerivative (unmatched.comparison 1) radius = -Real.sin radius := by have domain := uniqueDiffOn_Ici (0 : Real) radius future exact ⟨(hasDerivAt_id radius).hasDerivWithinAt.derivWithin domain, (Real.hasDerivAt_sin radius).hasDerivWithinAt.derivWithin domain, (hasDerivAt_const radius (1 : Real)).hasDerivWithinAt.derivWithin domain, (Real.hasDerivAt_cos radius).hasDerivWithinAt.derivWithin domain⟩ theorem the_unmatched_boundary_is_not_an_independent_scalar (radius : Real) (future : 0 <= radius) : unmatched.boundaryRemainder radius = radius * Real.cos radius := by obtain ⟨actualZero, actualOne, comparisonZero, comparisonOne⟩ := the_four_free_derivatives_are_actual radius future dsimp [Data.boundaryRemainder, Data.wronskian] rw [actualZero, actualOne, comparisonZero, comparisonOne] dsimp [unmatched] ring theorem the_regular_wave_product_has_the_actual_integral (radius : Real) : (∫ other in (0 : Real)..radius, other * Real.sin other) = Real.sin radius - radius * Real.cos radius := by have primitive : ∀ other : Real, HasDerivAt (fun value => Real.sin value - value * Real.cos value) (other * Real.sin other) other := by intro other convert (Real.hasDerivAt_sin other).sub ((hasDerivAt_id other).mul (Real.hasDerivAt_cos other)) using 1 dsimp ring simpa using intervalIntegral.integral_eq_sub_of_hasDerivAt (fun other _ => primitive other) ((by fun_prop : Continuous (fun other => other * Real.sin other)).intervalIntegrable 0 radius) theorem the_unmatched_free_waves_satisfy_both_finite_wronskian_identities : unmatched.WronskianIntegralIdentitiesAt := by intro radius future have actualInt : IntervalIntegrable (fun other => other * Real.sin other) volume 0 radius := (by fun_prop : Continuous _).intervalIntegrable 0 radius have comparisonInt : IntervalIntegrable (fun other => Real.cos other) volume 0 radius := Real.continuous_cos.intervalIntegrable 0 radius refine ⟨actualInt, ?_, ?_, ?_⟩ · simpa only [unmatched, Matrix.cons_val_zero, one_mul] using comparisonInt all_goals obtain ⟨actualZero, actualOne, comparisonZero, comparisonOne⟩ := the_four_free_derivatives_are_actual radius future obtain ⟨originActualZero, originActualOne, originComparisonZero, originComparisonOne⟩ := the_four_free_derivatives_are_actual 0 le_rfl dsimp [Data.wronskian] simp only [actualZero, actualOne, comparisonZero, comparisonOne, originActualZero, originActualOne, originComparisonZero, originComparisonOne] simp [Data.waveSquareDifference, unmatched, the_regular_wave_product_has_the_actual_integral, integral_cos] theorem actual_free_radial_equations_do_not_supply_the_boundary_limit : unmatched.SourceEquationsAt ∧ unmatched.WronskianIntegralIdentitiesAt ∧ ¬Tendsto unmatched.boundaryRemainder atTop (nhds 0) := by refine ⟨the_unmatched_free_waves_satisfy_actual_radial_equations, the_unmatched_free_waves_satisfy_both_finite_wronskian_identities, ?_⟩ intro converges have eventuallySmall := converges.eventually (eventually_lt_nhds (by norm_num : (0 : Real) < 1)) obtain ⟨threshold, small⟩ := eventually_atTop.1 eventuallySmall obtain ⟨n, beyond⟩ := exists_nat_gt (max threshold 1 / (2 * Real.pi)) have large : max threshold 1 < (n : Real) * (2 * Real.pi) := (div_lt_iff₀ (by positivity : 0 < 2 * Real.pi)).mp beyond have positive : 0 <= (n : Real) * (2 * Real.pi) := by positivity have bound := small ((n : Real) * (2 * Real.pi)) ((le_max_left _ _).trans large.le) rw [the_unmatched_boundary_is_not_an_independent_scalar _ positive, Real.cos_nat_mul_two_pi, mul_one] at bound linarith [le_max_right threshold (1 : Real)] end FreeComparison /-! Algebraic effective-range diagnostics. These functions are not asserted to arise from a single fixed nuclear potential; the independent client also constructs an elastic unitary scattering amplitude with a nonzero remainder. -/ namespace PhaseControl open Approximation def quarticPhase (momentum : Real) : Real := -1 + momentum ^ 2 + momentum ^ 4 def quarticRange (momentum : Real) : Real := 2 + 2 * momentum ^ 2 theorem the_nonzero_shape_remainder_obeys_the_exact_range_comparison (momentum : Real) : ExactComparisonAt (quarticPhase momentum) 1 (quarticRange momentum) (momentum ^ 2) := by dsimp [ExactComparisonAt, quarticPhase, quarticRange] ring theorem the_nonzero_shape_remainder_has_controlled_range_replacement (momentum : Real) : RangeReplacementAt (quarticRange momentum) 2 (momentum ^ 2) := by refine ⟨sq_nonneg momentum, ?_⟩ have residual : quarticRange momentum / 2 - 2 / 2 = momentum ^ 2 := by dsimp [quarticRange] ring rw [residual, abs_of_nonneg (sq_nonneg momentum)] theorem controlled_replacement_does_not_erase_the_actual_phase_remainder : ExactComparisonAt (quarticPhase (1 / 2)) 1 (quarticRange (1 / 2)) ((1 / 2) ^ 2) ∧ RangeReplacementAt (quarticRange (1 / 2)) 2 ((1 / 2) ^ 2) ∧ PhaseApproximationAt (quarticPhase (1 / 2)) 1 2 ((1 / 2) ^ 2) ((1 / 2) ^ 2) ∧ quarticPhase (1 / 2) ≠ twoParameterPhase 1 2 ((1 / 2) ^ 2) := by refine ⟨the_nonzero_shape_remainder_obeys_the_exact_range_comparison _, the_nonzero_shape_remainder_has_controlled_range_replacement _, controlled_range_replacement_gives_a_phase_error_bound _ _ _ _ _ _ (the_nonzero_shape_remainder_obeys_the_exact_range_comparison _) (the_nonzero_shape_remainder_has_controlled_range_replacement _), ?_⟩ norm_num [quarticPhase, twoParameterPhase] def slowRange (momentum : Real) : Real := 2 + 2 * momentum def cubicPhase (momentum : Real) : Real := -1 + momentum ^ 2 + momentum ^ 3 theorem a_continuous_range_can_approach_its_reference_only_linearly : Continuous slowRange ∧ slowRange 0 = 2 ∧ ∀ momentum, 0 <= momentum -> ExactComparisonAt (cubicPhase momentum) 1 (slowRange momentum) (momentum ^ 2) ∧ RangeReplacementAt (slowRange momentum) 2 momentum := by refine ⟨by unfold slowRange; fun_prop, by norm_num [slowRange], ?_⟩ intro momentum nonnegative refine ⟨?_, nonnegative, ?_⟩ · dsimp [ExactComparisonAt, cubicPhase, slowRange] ring · have residual : slowRange momentum / 2 - 2 / 2 = momentum := by dsimp [slowRange]; ring rw [residual, abs_of_nonneg nonnegative] theorem continuity_and_zero_energy_agreement_do_not_supply_quartic_accuracy : Continuous slowRange ∧ slowRange 0 = 2 ∧ (∀ momentum, 0 <= momentum -> ExactComparisonAt (cubicPhase momentum) 1 (slowRange momentum) (momentum ^ 2) ∧ RangeReplacementAt (slowRange momentum) 2 momentum) ∧ ¬UniformQuarticPhaseErrorAt cubicPhase 1 2 := by refine ⟨a_continuous_range_can_approach_its_reference_only_linearly.1, a_continuous_range_can_approach_its_reference_only_linearly.2.1, a_continuous_range_can_approach_its_reference_only_linearly.2.2, ?_⟩ rintro ⟨radius, coefficient, positive, nonnegative, controlled⟩ let momentum := min radius (1 / (coefficient + 1)) / 2 have momentumPositive : 0 < momentum := by dsimp [momentum] positivity have momentumSmall : momentum < radius := by dsimp [momentum] linarith [min_le_left radius (1 / (coefficient + 1))] have inverseSmall : momentum < 1 / (coefficient + 1) := by dsimp [momentum] have inversePositive : 0 < 1 / (coefficient + 1) := by positivity linarith [min_le_right radius (1 / (coefficient + 1))] have scaled : momentum * (coefficient + 1) < 1 := (lt_div_iff₀ (by positivity : 0 < coefficient + 1)).mp inverseSmall have error := controlled momentum momentumPositive momentumSmall have residual : cubicPhase momentum - twoParameterPhase 1 2 (momentum ^ 2) = momentum ^ 3 := by dsimp [cubicPhase, twoParameterPhase] ring rw [residual, abs_of_pos (pow_pos momentumPositive 3)] at error have impossible : 0 < momentum ^ 3 * (1 - coefficient * momentum) := mul_pos (pow_pos momentumPositive 3) (by nlinarith) nlinarith end PhaseControl end end RadialComparison /-! Charged S-wave comparison from original pp. 43-45, equations (37)-(52). The common logarithmic derivative is removed before taking an origin limit. The two range replacements and the nonresonant threshold input are distinct. -/ namespace CoulombComparison open MeasureTheory Set Filter open scoped Topology BigOperators noncomputable section def eta (bohrRadius momentum : Real) : Real := 1 / (momentum * bohrRadius) def penetrationSquared (parameter : Real) : Real := (2 * Real.pi * parameter) / (Real.exp (2 * Real.pi * parameter) - 1) def normalization (parameter : Real) : Real := Real.sqrt (penetrationSquared parameter) def sourceSeriesTerm (parameter : Real) (index : Nat) : Real := 1 / (((index + 1 : Nat) : Real) * (((index + 1 : Nat) : Real) ^ 2 + parameter ^ 2)) def sourceG (parameter : Real) : Real := -2 * Real.log parameter + 2 * parameter ^ 2 * ∑' index : Nat, sourceSeriesTerm parameter index def sourceFAtEta (parameter phaseShift : Real) : Real := sourceG parameter + 2 * Real.pi * (Real.cos phaseShift / Real.sin phaseShift) / (Real.exp (2 * Real.pi * parameter) - 1) def sourceF (bohrRadius momentum phaseShift : Real) : Real := sourceFAtEta (eta bohrRadius momentum) phaseShift def modifiedPhase (bohrRadius momentum phaseShift : Real) : Real := sourceF bohrRadius momentum phaseShift / bohrRadius structure ProtonParameters where nucleonMass : Real planck : Real chargeSquared : Real namespace ProtonParameters def PositiveAt (parameters : ProtonParameters) : Prop := 0 < parameters.nucleonMass ∧ 0 < parameters.planck ∧ 0 < parameters.chargeSquared def reducedMass (parameters : ProtonParameters) : Real := parameters.nucleonMass / 2 def bohrRadius (parameters : ProtonParameters) : Real := 2 * parameters.planck ^ 2 / (parameters.nucleonMass * parameters.chargeSquared) def scaledCoulombPotential (parameters : ProtonParameters) (radius : Real) : Real := parameters.nucleonMass / parameters.planck ^ 2 * (parameters.chargeSquared / radius) theorem equation_thirty_eight_retains_the_two_proton_reduced_mass (parameters : ProtonParameters) : parameters.bohrRadius = parameters.planck ^ 2 / (parameters.reducedMass * parameters.chargeSquared) := by unfold bohrRadius reducedMass ring theorem positive_proton_parameters_give_a_positive_bohr_radius (parameters : ProtonParameters) (positive : parameters.PositiveAt) : 0 < parameters.bohrRadius := by unfold bohrRadius exact div_pos (mul_pos (by norm_num) (sq_pos_of_pos positive.2.1)) (mul_pos positive.1 positive.2.2) theorem the_scaled_coulomb_potential_is_the_printed_radial_term (parameters : ProtonParameters) (positive : parameters.PositiveAt) (radius : Real) (radiusPositive : 0 < radius) : 0 < parameters.scaledCoulombPotential radius ∧ parameters.scaledCoulombPotential radius = 2 / (parameters.bohrRadius * radius) := by constructor · exact mul_pos (div_pos positive.1 (sq_pos_of_pos positive.2.1)) (div_pos positive.2.2 radiusPositive) · unfold scaledCoulombPotential bohrRadius field_simp end ProtonParameters def commonLogDerivative (bohrRadius radius : Real) : Real := (2 / bohrRadius) * (Real.log (2 * radius / bohrRadius) + Real.eulerMascheroniConstant) /-- The displayed leading small-radius expression, not an exact solution of the Coulomb radial equation. Its derivatives test the boundary inference. -/ def leadingComparison (bohrRadius sourceValue radius : Real) : Real := 1 + radius * ((2 / bohrRadius) * (Real.log radius + (Real.log (2 / bohrRadius) + Real.eulerMascheroniConstant - 1)) + sourceValue / bohrRadius) theorem the_leading_comparison_has_the_actual_logarithmic_derivative (bohrRadius sourceValue radius : Real) (positive : 0 < bohrRadius) (radiusPositive : 0 < radius) : HasDerivAt (leadingComparison bohrRadius sourceValue) (commonLogDerivative bohrRadius radius + sourceValue / bohrRadius) radius := by have inner := (((Real.hasDerivAt_log radiusPositive.ne').add_const (Real.log (2 / bohrRadius) + Real.eulerMascheroniConstant - 1)).const_mul (2 / bohrRadius)).add_const (sourceValue / bohrRadius) convert ((hasDerivAt_id radius).mul inner).const_add 1 using 1 dsimp [commonLogDerivative] rw [show 2 * radius / bohrRadius = (2 / bohrRadius) * radius by ring, Real.log_mul (by positivity) radiusPositive.ne'] field_simp ring theorem the_common_logarithmic_derivative_has_no_finite_origin_limit (bohrRadius : Real) (positive : 0 < bohrRadius) : Tendsto (commonLogDerivative bohrRadius) (𝓝[>] (0 : Real)) atBot := by have logarithm := Real.tendsto_log_nhdsGT_zero.atBot_add (tendsto_const_nhds (x := Real.log (2 / bohrRadius) + Real.eulerMascheroniConstant)) have scaled := logarithm.const_mul_atBot (show (0 : Real) < 2 / bohrRadius by positivity) apply scaled.congr' filter_upwards [self_mem_nhdsWithin] with radius radiusPositive dsimp [commonLogDerivative] rw [show 2 * radius / bohrRadius = (2 / bohrRadius) * radius by ring, Real.log_mul (by positivity) (ne_of_gt radiusPositive)] ring theorem each_actual_leading_derivative_diverges_but_their_difference_is_finite : leadingComparison 1 0 0 = 1 ∧ leadingComparison 1 2 0 = 1 ∧ (∀ radius : Real, 0 < radius → deriv (leadingComparison 1 2) radius - deriv (leadingComparison 1 0) radius = 2) ∧ (∀ value : Real, Tendsto (deriv (leadingComparison 1 value)) (𝓝[>] (0 : Real)) atBot) ∧ ¬∃ value : Real, Tendsto (deriv (leadingComparison 1 0)) (𝓝[>] (0 : Real)) (𝓝 value) := by have divergent (value : Real) : Tendsto (deriv (leadingComparison 1 value)) (𝓝[>] (0 : Real)) atBot := by have target := (the_common_logarithmic_derivative_has_no_finite_origin_limit 1 (by norm_num)).atBot_add (tendsto_const_nhds (x := value / 1)) apply target.congr' filter_upwards [self_mem_nhdsWithin] with radius radiusPositive exact (the_leading_comparison_has_the_actual_logarithmic_derivative 1 value radius (by norm_num) radiusPositive).deriv.symm refine ⟨by simp [leadingComparison], by simp [leadingComparison], ?_, divergent, ?_⟩ · intro radius positive rw [(the_leading_comparison_has_the_actual_logarithmic_derivative 1 2 radius (by norm_num) positive).deriv, (the_leading_comparison_has_the_actual_logarithmic_derivative 1 0 radius (by norm_num) positive).deriv] ring · rintro ⟨value, limit⟩ exact not_tendsto_nhds_of_tendsto_atBot (divergent 0) value limit theorem the_source_series_is_summable (parameter : Real) : Summable (sourceSeriesTerm parameter) := by have reference : Summable (fun index : Nat => 1 / (((index + 1 : Nat) : Real) ^ 2)) := (summable_nat_add_iff 1).2 (Real.summable_one_div_nat_pow.mpr (by norm_num)) apply Summable.of_nonneg_of_le (fun index => by unfold sourceSeriesTerm; positivity) _ reference intro index have one : (1 : Real) ≤ ((index + 1 : Nat) : Real) := by exact_mod_cast Nat.le_add_left 1 index unfold sourceSeriesTerm apply one_div_le_one_div_of_le (by positivity) nlinarith [mul_nonneg (sub_nonneg.mpr one) (sq_nonneg (((index + 1 : Nat) : Real))), mul_nonneg (show (0 : Real) ≤ ((index + 1 : Nat) : Real) by positivity) (sq_nonneg parameter)] theorem the_repulsive_coulomb_factor_is_positive_and_below_one (parameter : Real) (positive : 0 < parameter) : 0 < penetrationSquared parameter ∧ penetrationSquared parameter < 1 := by have scaled : 0 < 2 * Real.pi * parameter := by positivity have denominator : 0 < Real.exp (2 * Real.pi * parameter) - 1 := sub_pos.mpr (Real.one_lt_exp_iff.mpr scaled) refine ⟨div_pos scaled denominator, ?_⟩ unfold penetrationSquared apply (div_lt_one denominator).mpr have strict := Real.add_one_lt_exp scaled.ne' linarith theorem equation_forty_three_has_the_actual_positive_normalization (parameter : Real) (positive : 0 < parameter) : 0 < normalization parameter ∧ normalization parameter ^ 2 = penetrationSquared parameter := by have factor := (the_repulsive_coulomb_factor_is_positive_and_below_one parameter positive).1 exact ⟨Real.sqrt_pos.mpr factor, Real.sq_sqrt factor.le⟩ theorem the_dimensionless_source_function_has_the_printed_coulomb_coefficient (bohrRadius momentum phaseShift : Real) (radiusPositive : 0 < bohrRadius) (momentumPositive : 0 < momentum) : modifiedPhase bohrRadius momentum phaseShift = sourceG (eta bohrRadius momentum) / bohrRadius + penetrationSquared (eta bohrRadius momentum) * momentum * (Real.cos phaseShift / Real.sin phaseShift) := by have parameterPositive : 0 < eta bohrRadius momentum := by unfold eta; positivity have denominator : Real.exp (2 * Real.pi * eta bohrRadius momentum) - 1 ≠ 0 := (sub_pos.mpr (Real.one_lt_exp_iff.mpr (by positivity))).ne' unfold modifiedPhase sourceF sourceFAtEta penetrationSquared rw [add_div] congr 1 unfold eta at * field_simp theorem omitting_the_additive_coulomb_function_changes_the_phase : 0 < modifiedPhase 1 1 (Real.pi / 2) ∧ penetrationSquared (eta 1 1) * (Real.cos (Real.pi / 2) / Real.sin (Real.pi / 2)) = 0 := by have seriesPositive : 0 < ∑' index : Nat, sourceSeriesTerm 1 index := by exact (the_source_series_is_summable 1).tsum_pos (fun index => by unfold sourceSeriesTerm; positivity) 0 (by unfold sourceSeriesTerm; norm_num) constructor · simpa [modifiedPhase, sourceF, sourceFAtEta, eta, sourceG] using mul_pos (by norm_num : (0 : Real) < 2) seriesPositive · simp theorem the_dimensionless_plot_is_not_the_inverse_length_phase : 0 < sourceF 2 (1 / 2) (Real.pi / 2) ∧ sourceF 2 (1 / 2) (Real.pi / 2) ≠ modifiedPhase 2 (1 / 2) (Real.pi / 2) := by have positive : 0 < sourceF 2 (1 / 2) (Real.pi / 2) := by simpa [modifiedPhase, sourceF, eta] using omitting_the_additive_coulomb_function_changes_the_phase.1 refine ⟨positive, ?_⟩ unfold modifiedPhase linarith namespace ErrorDiagnostics open RadialComparison.Approximation /-- Scalar error controls at an actual Coulomb phase. These do not claim that the selected ranges arise from a solved nuclear potential. -/ def phase : Real := modifiedPhase 1 1 (Real.pi / 2) def chargedRange : Real := 2 * phase def shiftedRange : Real := 2 * (phase + 1) theorem a_controlled_charged_phase_error_need_not_be_zero : ExactComparisonAt phase 0 chargedRange 1 ∧ RangeReplacementAt chargedRange shiftedRange 1 ∧ PhaseApproximationAt phase 0 shiftedRange 1 1 ∧ phase ≠ twoParameterPhase 0 shiftedRange 1 := by have rangeResidual : chargedRange / 2 - shiftedRange / 2 = -1 := by unfold chargedRange shiftedRange ring have phaseResidual : phase - twoParameterPhase 0 shiftedRange 1 = -1 := by unfold twoParameterPhase shiftedRange ring refine ⟨?_, ⟨by norm_num, ?_⟩, ⟨by norm_num, ?_⟩, ?_⟩ · unfold ExactComparisonAt chargedRange ring · rw [rangeResidual] norm_num · rw [phaseResidual] norm_num · intro same rw [same, sub_self] at phaseResidual norm_num at phaseResidual theorem exact_energy_replacement_does_not_remove_the_neutralization_error : RangeReplacementAt chargedRange chargedRange 0 ∧ RangeReplacementAt chargedRange shiftedRange 1 ∧ PhaseApproximationAt phase 0 shiftedRange 1 (0 + 1) ∧ ¬PhaseApproximationAt phase 0 shiftedRange 1 0 := by have controlled := a_controlled_charged_phase_error_need_not_be_zero refine ⟨by simp [RangeReplacementAt], controlled.2.1, ?_, ?_⟩ · simpa only [zero_add] using controlled.2.2.1 · intro exactControl have phaseResidual : phase - twoParameterPhase 0 shiftedRange 1 = -1 := by unfold twoParameterPhase shiftedRange ring have small := exactControl.2 rw [phaseResidual] at small norm_num at small end ErrorDiagnostics theorem the_repulsive_penetration_factor_vanishes_at_large_eta : Tendsto penetrationSquared atTop (𝓝 0) := by have scaled : Tendsto (fun parameter : Real => 2 * Real.pi * parameter) atTop atTop := tendsto_id.const_mul_atTop (by positivity) have numerator := (Real.tendsto_pow_mul_exp_neg_atTop_nhds_zero 1).comp scaled have denominator : Tendsto (fun parameter : Real => 1 - Real.exp (-(2 * Real.pi * parameter))) atTop (𝓝 ((1 : Real) - 0)) := tendsto_const_nhds.sub (Real.tendsto_exp_neg_atTop_nhds_zero.comp scaled) have quotient := numerator.div denominator (show (1 : Real) - 0 ≠ 0 by norm_num) simp only [pow_one, zero_div] at quotient apply quotient.congr' filter_upwards [eventually_gt_atTop (0 : Real)] with parameter positive have nonzero : Real.exp (2 * Real.pi * parameter) - 1 ≠ 0 := (sub_pos.mpr (Real.one_lt_exp_iff.mpr (by positivity))).ne' dsimp [penetrationSquared] rw [Real.exp_neg] field_simp structure ReferenceBasis where regular : Real → Real irregular : Real → Real phaseOffset : Real /-- Positive lower radius avoids the Coulomb singularity. Integral radial dynamics permit finite steps in the nuclear potential. -/ def PositiveRadiusRadialEquationAt (potential : Real → Real) (waveSquare : Real) (wave : Real → Real) : Prop := ∀ lower upper : Real, 0 < lower → lower ≤ upper → IntegrableOn (fun radius => (potential radius - waveSquare) * wave radius) (Icc lower upper) ∧ wave upper = wave lower + deriv wave lower * (upper - lower) + ∫ radius in lower..upper, (upper - radius) * (potential radius - waveSquare) * wave radius ∧ HasDerivAt wave (deriv wave lower + ∫ radius in lower..upper, (potential radius - waveSquare) * wave radius) upper theorem the_positive_radius_integral_equation_uses_the_actual_wave_derivative (potential : Real → Real) (waveSquare : Real) (wave : Real → Real) (equation : PositiveRadiusRadialEquationAt potential waveSquare wave) (radius : Real) (positive : 0 < radius) : HasDerivAt wave (deriv wave radius) radius := by simpa using (equation radius radius positive le_rfl).2.2 structure Data where bohrRadius : Real momentum : Real phaseShift : Real zeroIntercept : Real referenceBasis : ReferenceBasis nuclearPotential : Real → Real actual : Fin 2 → Real → Real comparison : Fin 2 → Real → Real namespace Data def PhysicalDomainAt (data : Data) : Prop := 0 < data.bohrRadius ∧ 0 < data.momentum ∧ Real.sin data.phaseShift ≠ 0 def waveSquare (data : Data) (index : Fin 2) : Real := if index = 0 then 0 else data.momentum ^ 2 def phaseCoefficient (data : Data) (index : Fin 2) : Real := if index = 0 then data.zeroIntercept / data.bohrRadius else modifiedPhase data.bohrRadius data.momentum data.phaseShift def coulombPotential (data : Data) (radius : Real) : Real := 2 / (data.bohrRadius * radius) def PositiveRadiusEquationsAt (data : Data) : Prop := (∀ index, data.actual index 0 = 0 ∧ data.comparison index 0 = 1) ∧ ∀ index, PositiveRadiusRadialEquationAt (fun radius => data.nuclearPotential radius + data.coulombPotential radius) (data.waveSquare index) (data.actual index) ∧ PositiveRadiusRadialEquationAt data.coulombPotential (data.waveSquare index) (data.comparison index) def boundaryWronskian (data : Data) (radius : Real) : Real := data.comparison 1 radius * deriv (data.comparison 0) radius - data.comparison 0 radius * deriv (data.comparison 1) radius - (data.actual 1 radius * deriv (data.actual 0) radius - data.actual 0 radius * deriv (data.actual 1) radius) def ExteriorMatchingAt (data : Data) : Prop := Tendsto data.boundaryWronskian atTop (𝓝 0) ∧ ∀ index, Tendsto (fun radius => data.actual index radius - data.comparison index radius) atTop (𝓝 0) /-- The common reference phase is fixed by the supplied Coulomb basis. The separate Gamma-function phase convention in (40) is not inferred here. -/ def referencePhase (data : Data) (radius : Real) : Real := data.momentum * radius - eta data.bohrRadius data.momentum * Real.log (2 * data.momentum * radius) + data.referenceBasis.phaseOffset def PureCoulombEquationAt (data : Data) (wave : Real → Real) : Prop := ∀ radius : Real, 0 < radius → HasDerivAt wave (deriv wave radius) radius ∧ HasDerivAt (deriv wave) ((data.coulombPotential radius - data.momentum ^ 2) * wave radius) radius /-- Actual regular and irregular Coulomb solutions, with their origin and large-radius normalizations. Special-function realization is an imported calculation, not a stored phase-shift conclusion. -/ def SourceBasisAt (data : Data) : Prop := let factor := normalization (eta data.bohrRadius data.momentum) data.PureCoulombEquationAt data.referenceBasis.regular ∧ data.PureCoulombEquationAt data.referenceBasis.irregular ∧ Tendsto (fun radius => data.referenceBasis.regular radius / radius) (𝓝[>] (0 : Real)) (𝓝 (factor * data.momentum)) ∧ Tendsto (fun radius => factor * data.referenceBasis.irregular radius) (𝓝[>] (0 : Real)) (𝓝 1) ∧ Tendsto (fun radius => data.referenceBasis.regular radius - Real.sin (data.referencePhase radius)) atTop (𝓝 0) ∧ Tendsto (fun radius => data.referenceBasis.irregular radius - Real.cos (data.referencePhase radius)) atTop (𝓝 0) def SourceCombinationAt (data : Data) : Prop := ∀ radius : Real, 0 < radius → data.comparison 1 radius = normalization (eta data.bohrRadius data.momentum) * (data.referenceBasis.irregular radius + data.referenceBasis.regular radius * (Real.cos data.phaseShift / Real.sin data.phaseShift)) def relativePhaseAmplitude (data : Data) : Real := normalization (eta data.bohrRadius data.momentum) / Real.sin data.phaseShift def RelativePhaseReadoutAt (data : Data) : Prop := data.relativePhaseAmplitude ≠ 0 ∧ Tendsto (data.comparison 1) (𝓝[>] (0 : Real)) (𝓝 1) ∧ Tendsto (fun radius => data.comparison 1 radius - data.relativePhaseAmplitude * Real.sin (data.referencePhase radius + data.phaseShift)) atTop (𝓝 0) ∧ Tendsto (fun radius => data.actual 1 radius - data.relativePhaseAmplitude * Real.sin (data.referencePhase radius + data.phaseShift)) atTop (𝓝 0) theorem the_regular_irregular_combination_has_an_actual_unit_origin_limit (data : Data) (basis : data.SourceBasisAt) (combination : data.SourceCombinationAt) : Tendsto (data.comparison 1) (𝓝[>] (0 : Real)) (𝓝 1) := by have radiusLimit : Tendsto (fun radius : Real => radius) (𝓝[>] (0 : Real)) (𝓝 0) := continuousAt_id.tendsto.mono_left nhdsWithin_le_nhds have regularLimit : Tendsto data.referenceBasis.regular (𝓝[>] (0 : Real)) (𝓝 0) := by have limit := basis.2.2.1.mul radiusLimit simp only [mul_zero] at limit apply limit.congr' filter_upwards [self_mem_nhdsWithin] with radius positive exact div_mul_cancel₀ _ (ne_of_gt positive) have limit := basis.2.2.2.1.add ((regularLimit.const_mul (normalization (eta data.bohrRadius data.momentum))).mul_const (Real.cos data.phaseShift / Real.sin data.phaseShift)) simp only [mul_zero, zero_mul, add_zero] at limit apply limit.congr' filter_upwards [self_mem_nhdsWithin] with radius positive rw [combination radius positive] ring theorem the_actual_coulomb_basis_identifies_the_relative_nuclear_phase (data : Data) (domain : data.PhysicalDomainAt) (basis : data.SourceBasisAt) (combination : data.SourceCombinationAt) (matching : data.ExteriorMatchingAt) : data.RelativePhaseReadoutAt := by have factorPositive := (equation_forty_three_has_the_actual_positive_normalization (eta data.bohrRadius data.momentum) (one_div_pos.mpr (mul_pos domain.2.1 domain.1))).1 have comparisonLimit : Tendsto (fun radius => data.comparison 1 radius - data.relativePhaseAmplitude * Real.sin (data.referencePhase radius + data.phaseShift)) atTop (𝓝 0) := by have limit := (basis.2.2.2.2.2.add (basis.2.2.2.2.1.mul_const (Real.cos data.phaseShift / Real.sin data.phaseShift))).const_mul (normalization (eta data.bohrRadius data.momentum)) simp only [zero_mul, zero_add, mul_zero] at limit apply limit.congr' filter_upwards [eventually_gt_atTop (0 : Real)] with radius positive rw [combination radius positive, Real.sin_add] unfold relativePhaseAmplitude field_simp [domain.2.2] ring refine ⟨div_ne_zero factorPositive.ne' domain.2.2, data.the_regular_irregular_combination_has_an_actual_unit_origin_limit basis combination, comparisonLimit, ?_⟩ have limit := (matching.2 1).add comparisonLimit simp only [add_zero] at limit convert limit using 1 funext radius ring def commonLogDerivative (data : Data) (radius : Real) : Real := CoulombComparison.commonLogDerivative data.bohrRadius radius def originRemainder (data : Data) (index : Fin 2) (radius : Real) : Real := deriv (data.comparison index) radius - (data.commonLogDerivative radius + data.phaseCoefficient index) def OriginExpansionAt (data : Data) : Prop := ∀ index, Tendsto (data.originRemainder index) (𝓝[>] (0 : Real)) (𝓝 0) /-- Only the common overlap and L1-error interface is used. The neutral comparison-wave equation at the origin is not asserted for Coulomb waves. -/ def radialIntegrals (data : Data) : RadialComparison.Data where potential := fun radius => data.nuclearPotential radius + data.coulombPotential radius waveNumberSquared := data.waveSquare actual := data.actual comparison := data.comparison def energyRange (data : Data) : Real := 2 * data.radialIntegrals.overlapIntegral def zeroRange (data : Data) : Real := 2 * ∫ radius in Ioi (0 : Real), data.radialIntegrals.zeroOverlap radius def inverseLength (data : Data) : Real := -(data.zeroIntercept / data.bohrRadius) /-- The finite-radius comparison (44) and its boundary limits, summarized at the actual derivative difference before any phase-function identification. -/ def IntegratedComparisonAt (data : Data) : Prop := IntegrableOn data.radialIntegrals.overlap (Ioi 0) ∧ Tendsto (fun radius => deriv (data.comparison 1) radius - deriv (data.comparison 0) radius) (𝓝[>] (0 : Real)) (𝓝 (data.momentum ^ 2 * data.radialIntegrals.overlapIntegral)) theorem the_same_radius_logarithm_cancels_before_the_origin_limit (data : Data) (expansion : data.OriginExpansionAt) : Tendsto (fun radius => deriv (data.comparison 1) radius - deriv (data.comparison 0) radius) (𝓝[>] (0 : Real)) (𝓝 (data.phaseCoefficient 1 - data.phaseCoefficient 0)) := by have limit := (expansion 1).sub (expansion 0) have shifted := limit.add_const (data.phaseCoefficient 1 - data.phaseCoefficient 0) simp only [sub_self, zero_add] at shifted convert shifted using 1 funext radius unfold originRemainder ring theorem actual_derivative_comparison_derives_the_charged_range_identity (data : Data) (expansion : data.OriginExpansionAt) (comparison : data.IntegratedComparisonAt) : modifiedPhase data.bohrRadius data.momentum data.phaseShift = -data.inverseLength + data.momentum ^ 2 * data.energyRange / 2 := by have agreement := tendsto_nhds_unique (data.the_same_radius_logarithm_cancels_before_the_origin_limit expansion) comparison.2 simp [phaseCoefficient] at agreement unfold inverseLength energyRange nlinarith def EnergyReplacementAt (data : Data) (tolerance : Real) : Prop := IntegrableOn data.radialIntegrals.zeroOverlap (Ioi 0) ∧ data.radialIntegrals.InteriorReplacementAt tolerance theorem the_actual_charged_overlap_control_bounds_the_effective_range_replacement (data : Data) (tolerance : Real) (comparison : data.IntegratedComparisonAt) (replacement : data.EnergyReplacementAt tolerance) : RadialComparison.Approximation.RangeReplacementAt data.energyRange data.zeroRange tolerance := by apply RadialComparison.Approximation.the_actual_integral_error_bounds_the_range_replacement data.radialIntegrals data.energyRange data.zeroRange tolerance comparison.1 replacement.1 · unfold energyRange ring · unfold zeroRange ring · exact replacement.2 theorem the_charged_range_replacement_controls_the_phase_instead_of_making_it_exact (data : Data) (tolerance : Real) (expansion : data.OriginExpansionAt) (comparison : data.IntegratedComparisonAt) (replacement : data.EnergyReplacementAt tolerance) : RadialComparison.Approximation.PhaseApproximationAt (modifiedPhase data.bohrRadius data.momentum data.phaseShift) data.inverseLength data.zeroRange (data.momentum ^ 2) tolerance := RadialComparison.Approximation.controlled_range_replacement_gives_a_phase_error_bound _ _ _ _ _ _ (data.actual_derivative_comparison_derives_the_charged_range_identity expansion comparison) (data.the_actual_charged_overlap_control_bounds_the_effective_range_replacement tolerance comparison replacement) theorem the_dimensionless_plot_retains_the_bohr_radius_in_its_error_budget (data : Data) (tolerance : Real) (positive : 0 < data.bohrRadius) (expansion : data.OriginExpansionAt) (comparison : data.IntegratedComparisonAt) (replacement : data.EnergyReplacementAt tolerance) : |sourceF data.bohrRadius data.momentum data.phaseShift - data.bohrRadius * (-data.inverseLength + data.momentum ^ 2 * data.zeroRange / 2)| ≤ data.bohrRadius * |data.momentum ^ 2| * tolerance := by have controlled := (data.the_charged_range_replacement_controls_the_phase_instead_of_making_it_exact tolerance expansion comparison replacement).2 have product : data.bohrRadius * modifiedPhase data.bohrRadius data.momentum data.phaseShift = sourceF data.bohrRadius data.momentum data.phaseShift := mul_div_cancel₀ _ positive.ne' have rescaled : data.bohrRadius * (modifiedPhase data.bohrRadius data.momentum data.phaseShift - RadialComparison.Approximation.twoParameterPhase data.inverseLength data.zeroRange (data.momentum ^ 2)) = sourceF data.bohrRadius data.momentum data.phaseShift - data.bohrRadius * (-data.inverseLength + data.momentum ^ 2 * data.zeroRange / 2) := by rw [mul_sub, product] rfl rw [← rescaled, abs_mul, abs_of_pos positive, mul_assoc] exact mul_le_mul_of_nonneg_left controlled positive.le def neutralZeroOverlap (actual comparison : Real → Real) (radius : Real) : Real := comparison radius ^ 2 - actual radius ^ 2 def neutralRange (actual comparison : Real → Real) : Real := 2 * ∫ radius in Ioi (0 : Real), neutralZeroOverlap actual comparison radius def NeutralizationControlAt (data : Data) (actual comparison : Real → Real) (tolerance : Real) : Prop := RadialComparison.RegularRadialEquationAt data.nuclearPotential 0 actual 0 ∧ RadialComparison.RegularRadialEquationAt (fun _ => 0) 0 comparison 1 ∧ IntegrableOn data.radialIntegrals.zeroOverlap (Ioi 0) ∧ IntegrableOn (neutralZeroOverlap actual comparison) (Ioi 0) ∧ 0 ≤ tolerance ∧ (∫ radius in Ioi (0 : Real), |data.radialIntegrals.zeroOverlap radius - neutralZeroOverlap actual comparison radius|) ≤ tolerance theorem neutralizing_the_same_nuclear_potential_has_its_own_range_error (data : Data) (actual comparison : Real → Real) (tolerance : Real) (control : data.NeutralizationControlAt actual comparison tolerance) : RadialComparison.Approximation.RangeReplacementAt data.zeroRange (neutralRange actual comparison) tolerance := by refine ⟨control.2.2.2.2.1, ?_⟩ unfold zeroRange neutralRange rw [mul_div_cancel_left₀ _ (by norm_num : (2 : Real) ≠ 0), mul_div_cancel_left₀ _ (by norm_num : (2 : Real) ≠ 0), ← integral_sub control.2.2.1 control.2.2.2.1] exact abs_integral_le_integral_abs.trans control.2.2.2.2.2 theorem energy_replacement_and_coulomb_removal_have_separate_error_budgets (data : Data) (actual comparison : Real → Real) (energyTolerance neutralizationTolerance : Real) (expansion : data.OriginExpansionAt) (radialComparison : data.IntegratedComparisonAt) (energyControl : data.EnergyReplacementAt energyTolerance) (neutralization : data.NeutralizationControlAt actual comparison neutralizationTolerance) : RadialComparison.Approximation.PhaseApproximationAt (modifiedPhase data.bohrRadius data.momentum data.phaseShift) data.inverseLength (neutralRange actual comparison) (data.momentum ^ 2) (energyTolerance + neutralizationTolerance) := by have energy := data.the_actual_charged_overlap_control_bounds_the_effective_range_replacement energyTolerance radialComparison energyControl have neutral := data.neutralizing_the_same_nuclear_potential_has_its_own_range_error actual comparison neutralizationTolerance neutralization apply RadialComparison.Approximation.controlled_range_replacement_gives_a_phase_error_bound _ _ _ _ _ _ (data.actual_derivative_comparison_derives_the_charged_range_identity expansion radialComparison) refine ⟨add_nonneg energy.1 neutral.1, ?_⟩ have triangle := abs_sub_le (data.energyRange / 2) (data.zeroRange / 2) (neutralRange actual comparison / 2) linarith [energy.2, neutral.2] end Data /-- The phase shift is relative to pure Coulomb scattering. The squared partial-wave amplitude below excludes the Coulomb phase, which has unit modulus. It is not the total proton cross section, with its spin weights and Coulomb interference. -/ structure ThresholdData where bohrRadius : Real phaseShift : Real → Real namespace ThresholdData def momentum (data : ThresholdData) (parameter : Real) : Real := 1 / (data.bohrRadius * parameter) def sourcePlot (data : ThresholdData) (parameter : Real) : Real := sourceFAtEta parameter (data.phaseShift parameter) def sourceGap (data : ThresholdData) (parameter : Real) : Real := data.sourcePlot parameter - sourceG parameter def phaseFunction (data : ThresholdData) (parameter : Real) : Real := data.sourceGap parameter / (data.bohrRadius * penetrationSquared parameter) def nuclearPartialWaveStrength (data : ThresholdData) (parameter : Real) : Real := 1 / (data.momentum parameter ^ 2 + data.phaseFunction parameter ^ 2) def PhysicalAt (data : ThresholdData) (parameter : Real) : Prop := 0 < data.bohrRadius ∧ 0 < parameter ∧ Real.sin (data.phaseShift parameter) ≠ 0 def RepresentsThresholdPointAt (data : ThresholdData) (potential : Real → Real) (parameter : Real) (scattering : Data) : Prop := scattering.bohrRadius = data.bohrRadius ∧ scattering.momentum = data.momentum parameter ∧ scattering.phaseShift = data.phaseShift parameter ∧ scattering.nuclearPotential = potential def ScatteringRealizationAt (data : ThresholdData) (potential : Real → Real) (parameter : Real) : Prop := ∃ scattering : Data, data.RepresentsThresholdPointAt potential parameter scattering ∧ scattering.PositiveRadiusEquationsAt ∧ scattering.SourceBasisAt ∧ scattering.SourceCombinationAt ∧ scattering.ExteriorMatchingAt def RealizedRelativePhaseAt (data : ThresholdData) (potential : Real → Real) (parameter : Real) : Prop := ∃ scattering : Data, data.RepresentsThresholdPointAt potential parameter scattering ∧ scattering.RelativePhaseReadoutAt theorem a_realized_threshold_point_has_the_actual_relative_coulomb_phase (data : ThresholdData) (potential : Real → Real) (parameter : Real) (physical : data.PhysicalAt parameter) (realized : data.ScatteringRealizationAt potential parameter) : data.RealizedRelativePhaseAt potential parameter := by obtain ⟨scattering, represents, _equations, basis, combination, matching⟩ := realized have domain : scattering.PhysicalDomainAt := by unfold Data.PhysicalDomainAt rw [represents.1, represents.2.1, represents.2.2.1] exact ⟨physical.1, one_div_pos.mpr (mul_pos physical.1 physical.2.1), physical.2.2⟩ exact ⟨scattering, represents, scattering.the_actual_coulomb_basis_identifies_the_relative_nuclear_phase domain basis combination matching⟩ theorem large_coulomb_parameter_is_an_actual_zero_momentum_limit (data : ThresholdData) (positive : 0 < data.bohrRadius) : Tendsto data.momentum atTop (𝓝 0) := tendsto_const_nhds.div_atTop (tendsto_id.const_mul_atTop positive) def UniformSourceGapAt (data : ThresholdData) : Prop := ∃ gap : Real, 0 < gap ∧ ∀ᶠ parameter in atTop, gap ≤ |data.sourceGap parameter| /-- The special-function limit and finite source intercept are explicit inputs. Their noncancellation is not inferred from barrier penetration. -/ def NonresonantInterceptAt (data : ThresholdData) : Prop := ∃ intercept : Real, Tendsto data.sourcePlot atTop (𝓝 intercept) ∧ Tendsto sourceG atTop (𝓝 (2 * Real.eulerMascheroniConstant)) ∧ intercept ≠ 2 * Real.eulerMascheroniConstant theorem a_noncancelling_source_intercept_supplies_the_uniform_gap (data : ThresholdData) (asymptotics : data.NonresonantInterceptAt) : data.UniformSourceGapAt := by obtain ⟨intercept, sourceLimit, functionLimit, noncancellation⟩ := asymptotics have positive : 0 < |intercept - 2 * Real.eulerMascheroniConstant| := abs_pos.mpr (sub_ne_zero.mpr noncancellation) have bound := ((sourceLimit.sub functionLimit).abs).eventually (lt_mem_nhds (half_lt_self positive)) refine ⟨|intercept - 2 * Real.eulerMascheroniConstant| / 2, by positivity, ?_⟩ filter_upwards [bound] with parameter separated exact separated.le theorem the_charged_readout_recovers_the_actual_nuclear_phase_function (data : ThresholdData) (parameter : Real) (positive : data.PhysicalAt parameter) : data.phaseFunction parameter = data.momentum parameter * (Real.cos (data.phaseShift parameter) / Real.sin (data.phaseShift parameter)) := by have denominator : Real.exp (2 * Real.pi * parameter) - 1 ≠ 0 := (sub_pos.mpr (Real.one_lt_exp_iff.mpr (by have := positive.2.1; positivity))).ne' unfold phaseFunction sourceGap sourcePlot sourceFAtEta penetrationSquared momentum simp only [add_sub_cancel_left] field_simp theorem the_nuclear_partial_wave_strength_is_sine_squared_over_momentum_squared (data : ThresholdData) (parameter : Real) (positive : data.PhysicalAt parameter) : data.nuclearPartialWaveStrength parameter = Real.sin (data.phaseShift parameter) ^ 2 / data.momentum parameter ^ 2 := by have momentumPositive : 0 < data.momentum parameter := by unfold momentum exact one_div_pos.mpr (mul_pos positive.1 positive.2.1) unfold nuclearPartialWaveStrength rw [data.the_charged_readout_recovers_the_actual_nuclear_phase_function parameter positive] have trig := Real.sin_sq_add_cos_sq (data.phaseShift parameter) have denominatorPositive : 0 < data.momentum parameter ^ 2 + (data.momentum parameter * (Real.cos (data.phaseShift parameter) / Real.sin (data.phaseShift parameter))) ^ 2 := add_pos_of_pos_of_nonneg (sq_pos_of_pos momentumPositive) (sq_nonneg _) apply (div_eq_iff denominatorPositive.ne').2 field_simp [positive.2.2] nlinarith theorem a_uniform_gap_bounds_the_nuclear_partial_wave_by_the_penetration_factor (data : ThresholdData) (parameter gap : Real) (radiusPositive : 0 < data.bohrRadius) (parameterPositive : 0 < parameter) (gapPositive : 0 < gap) (separated : gap ≤ |data.sourceGap parameter|) : data.nuclearPartialWaveStrength parameter ≤ (data.bohrRadius ^ 2 / gap ^ 2) * penetrationSquared parameter ^ 2 := by have factorPositive := (the_repulsive_coulomb_factor_is_positive_and_below_one parameter parameterPositive).1 have momentumPositive : 0 < data.momentum parameter := by unfold momentum positivity have gapSquare : gap ^ 2 ≤ data.sourceGap parameter ^ 2 := by nlinarith [sq_abs (data.sourceGap parameter)] have denominatorPositive : 0 < data.momentum parameter ^ 2 + data.phaseFunction parameter ^ 2 := add_pos_of_pos_of_nonneg (sq_pos_of_pos momentumPositive) (sq_nonneg _) have representation : data.nuclearPartialWaveStrength parameter = ((data.bohrRadius * penetrationSquared parameter) ^ 2) / ((data.bohrRadius * penetrationSquared parameter) ^ 2 * data.momentum parameter ^ 2 + data.sourceGap parameter ^ 2) := by unfold nuclearPartialWaveStrength phaseFunction field_simp rw [representation] have lower : gap ^ 2 ≤ (data.bohrRadius * penetrationSquared parameter) ^ 2 * data.momentum parameter ^ 2 + data.sourceGap parameter ^ 2 := le_add_of_nonneg_left (mul_nonneg (sq_nonneg _) (sq_nonneg _)) |>.trans' gapSquare calc _ ≤ ((data.bohrRadius * penetrationSquared parameter) ^ 2) / gap ^ 2 := div_le_div_of_nonneg_left (by positivity) (sq_pos_of_pos gapPositive) lower _ = _ := by ring theorem the_nonresonant_source_gap_makes_the_nuclear_contribution_vanish (data : ThresholdData) (positive : 0 < data.bohrRadius) (gap : data.UniformSourceGapAt) : Tendsto data.nuclearPartialWaveStrength atTop (𝓝 0) := by obtain ⟨gap, gapPositive, separated⟩ := gap have limit : Tendsto (fun parameter : Real => (data.bohrRadius ^ 2 / gap ^ 2) * penetrationSquared parameter ^ 2) atTop (𝓝 0) := by simpa using tendsto_const_nhds.mul (the_repulsive_penetration_factor_vanishes_at_large_eta.pow 2) apply squeeze_zero' (Eventually.of_forall (fun parameter => by unfold nuclearPartialWaveStrength; positivity)) _ limit filter_upwards [separated, eventually_gt_atTop (0 : Real)] with parameter separation parameterPositive exact data.a_uniform_gap_bounds_the_nuclear_partial_wave_by_the_penetration_factor parameter gap positive parameterPositive gapPositive separation def resonantDiagnostic : ThresholdData where bohrRadius := 1 phaseShift := fun _ => Real.pi / 2 theorem the_resonant_diagnostic_has_actual_charged_phase_and_partial_wave_strength (parameter : Real) (positive : 0 < parameter) : resonantDiagnostic.PhysicalAt parameter ∧ resonantDiagnostic.sourceGap parameter = 0 ∧ resonantDiagnostic.nuclearPartialWaveStrength parameter = parameter ^ 2 := by refine ⟨⟨by norm_num [resonantDiagnostic], positive, by simp [resonantDiagnostic]⟩, ?_, ?_⟩ · simp [sourceGap, sourcePlot, sourceFAtEta, resonantDiagnostic] · simp [nuclearPartialWaveStrength, phaseFunction, sourceGap, sourcePlot, sourceFAtEta, resonantDiagnostic, momentum] theorem an_exponentially_small_penetration_factor_does_not_by_itself_suppress_nuclear_scattering : Tendsto penetrationSquared atTop (𝓝 0) ∧ (∀ parameter : Real, 0 < parameter → resonantDiagnostic.PhysicalAt parameter) ∧ ¬Tendsto resonantDiagnostic.nuclearPartialWaveStrength atTop (𝓝 0) := by refine ⟨the_repulsive_penetration_factor_vanishes_at_large_eta, fun parameter positive => (the_resonant_diagnostic_has_actual_charged_phase_and_partial_wave_strength parameter positive).1, ?_⟩ intro limit have small := limit.eventually (gt_mem_nhds (show (0 : Real) < 1 by norm_num)) obtain ⟨parameter, beyond, small⟩ := ((eventually_ge_atTop (1 : Real)).and small).exists have positive : 0 < parameter := lt_of_lt_of_le zero_lt_one beyond rw [(the_resonant_diagnostic_has_actual_charged_phase_and_partial_wave_strength parameter positive).2.2] at small have square : (1 : Real) ≤ parameter ^ 2 := by nlinarith nlinarith end ThresholdData end end CoulombComparison /-! Same-potential charge comparison in original pp. 47-49, equations (57)-(60). Finite weighted integration remains an explicit analytic input; its boundary limit and the equivalent neutral reciprocal length are derived. The norm controls are independently constructed diagnostics, not solutions for an assigned nuclear potential. -/ namespace CoulombChargeComparison open MeasureTheory Set Filter noncomputable section structure Data where bohrRadius : Real potential : Real -> Real neutralWave : Real -> Real chargedWave : Real -> Real chargedComparison : Real -> Real neutralReciprocalLength : Real namespace Data def neutralComparison (data : Data) (radius : Real) : Real := 1 - data.neutralReciprocalLength * radius def wronskian (first second : Real -> Real) (radius : Real) : Real := first radius * deriv second radius - second radius * deriv first radius def actualWronskian (data : Data) : Real -> Real := wronskian data.neutralWave data.chargedWave def comparisonWronskian (data : Data) : Real -> Real := wronskian data.neutralComparison data.chargedComparison def boundaryDifference (data : Data) (radius : Real) : Real := data.comparisonWronskian radius - data.actualWronskian radius def actualWeight (data : Data) (radius : Real) : Real := data.neutralWave radius * data.chargedWave radius / radius def comparisonWeight (data : Data) (radius : Real) : Real := data.neutralComparison radius * data.chargedComparison radius / radius def differenceWeight (data : Data) (radius : Real) : Real := (data.neutralComparison radius * data.chargedComparison radius - data.neutralWave radius * data.chargedWave radius) / radius def SamePotentialZeroEnergyAt (data : Data) : Prop := 0 < data.bohrRadius ∧ RadialComparison.RegularRadialEquationAt data.potential 0 data.neutralWave 0 ∧ data.chargedWave 0 = 0 ∧ CoulombComparison.PositiveRadiusRadialEquationAt (fun radius => data.potential radius + 2 / (data.bohrRadius * radius)) 0 data.chargedWave ∧ CoulombComparison.PositiveRadiusRadialEquationAt (fun radius => 2 / (data.bohrRadius * radius)) 0 data.chargedComparison def FiniteWeightedIdentitiesAt (data : Data) (cutoff : Real) : Prop := 0 < cutoff ∧ ∀ radius : Real, cutoff ≤ radius -> IntervalIntegrable data.actualWeight volume 0 cutoff ∧ IntervalIntegrable data.actualWeight volume cutoff radius ∧ IntervalIntegrable data.comparisonWeight volume cutoff radius ∧ data.actualWronskian radius - data.actualWronskian 0 = (2 / data.bohrRadius) * ∫ other in (0 : Real)..radius, data.actualWeight other ∧ data.comparisonWronskian radius - data.comparisonWronskian cutoff = (2 / data.bohrRadius) * ∫ other in cutoff..radius, data.comparisonWeight other def WeightedBalanceAt (data : Data) (cutoff : Real) : Prop := IntegrableOn data.differenceWeight (Ioi cutoff) ∧ (∫ radius in Ioi cutoff, data.differenceWeight radius) = ∫ radius in (0 : Real)..cutoff, data.actualWeight radius theorem the_same_potential_regular_waves_have_zero_origin_wronskian (data : Data) (physical : data.SamePotentialZeroEnergyAt) : data.actualWronskian 0 = 0 := by have neutral := RadialComparison.the_integral_radial_equation_fixes_its_origin_value data.potential 0 data.neutralWave 0 physical.2.1 simp [actualWronskian, wronskian, neutral, physical.2.2.1] theorem the_finite_weighted_comparison_retains_its_boundary_difference (data : Data) (physical : data.SamePotentialZeroEnergyAt) (cutoff radius : Real) (identities : data.FiniteWeightedIdentitiesAt cutoff) (beyond : cutoff ≤ radius) : data.comparisonWronskian cutoff = data.boundaryDifference radius - (2 / data.bohrRadius) * ((∫ other in cutoff..radius, data.differenceWeight other) - ∫ other in (0 : Real)..cutoff, data.actualWeight other) := by obtain ⟨firstInt, secondInt, comparisonInt, actualIdentity, comparisonIdentity⟩ := identities.2 radius beyond have split := intervalIntegral.integral_add_adjacent_intervals firstInt secondInt have difference : data.differenceWeight = fun other => data.comparisonWeight other - data.actualWeight other := by funext other unfold differenceWeight comparisonWeight actualWeight ring rw [difference, intervalIntegral.integral_sub comparisonInt secondInt] rw [data.the_same_potential_regular_waves_have_zero_origin_wronskian physical, sub_zero] at actualIdentity unfold boundaryDifference linear_combination -comparisonIdentity + actualIdentity - (2 / data.bohrRadius) * split theorem weighted_balance_and_the_actual_boundary_limit_give_zero_comparison_wronskian (data : Data) (physical : data.SamePotentialZeroEnergyAt) (cutoff : Real) (identities : data.FiniteWeightedIdentitiesAt cutoff) (balance : data.WeightedBalanceAt cutoff) (boundary : Tendsto data.boundaryDifference atTop (nhds 0)) : data.comparisonWronskian cutoff = 0 := by have integralLimit : Tendsto (fun radius : Real => ∫ other in cutoff..radius, data.differenceWeight other) atTop (nhds (∫ radius in Ioi cutoff, data.differenceWeight radius)) := intervalIntegral_tendsto_integral_Ioi cutoff balance.1 tendsto_id have combined := boundary.sub ((integralLimit.sub_const (∫ radius in (0 : Real)..cutoff, data.actualWeight radius)).const_mul (2 / data.bohrRadius)) rw [balance.2, sub_self, mul_zero, sub_zero] at combined have equal : (fun radius => data.boundaryDifference radius - (2 / data.bohrRadius) * ((∫ other in cutoff..radius, data.differenceWeight other) - ∫ other in (0 : Real)..cutoff, data.actualWeight other)) =ᶠ[atTop] fun _ => data.comparisonWronskian cutoff := by filter_upwards [eventually_ge_atTop cutoff] with radius beyond exact (data.the_finite_weighted_comparison_retains_its_boundary_difference physical cutoff radius identities beyond).symm exact tendsto_nhds_unique tendsto_const_nhds (combined.congr' equal) theorem the_neutral_comparison_derivative_is_the_negative_reciprocal_length (data : Data) (radius : Real) : deriv data.neutralComparison radius = -data.neutralReciprocalLength := by have derivative := (hasDerivAt_const radius (1 : Real)).sub ((hasDerivAt_id radius).const_mul data.neutralReciprocalLength) simpa [neutralComparison] using derivative.deriv def LogarithmicSlopesAgreeAt (data : Data) (radius : Real) : Prop := deriv data.neutralComparison radius / data.neutralComparison radius = deriv data.chargedComparison radius / data.chargedComparison radius theorem a_zero_wronskian_gives_logarithmic_slope_agreement_only_at_nonzero_values (data : Data) (radius : Real) (comparison : data.comparisonWronskian radius = 0) (neutral : data.neutralComparison radius ≠ 0) (charged : data.chargedComparison radius ≠ 0) : data.LogarithmicSlopesAgreeAt radius := by unfold LogarithmicSlopesAgreeAt apply (div_eq_div_iff neutral charged).mpr dsimp [comparisonWronskian, wronskian] at comparison nlinarith def equivalentReciprocalLength (data : Data) (radius : Real) : Real := -deriv data.chargedComparison radius / (data.chargedComparison radius - radius * deriv data.chargedComparison radius) theorem the_linear_comparison_determines_the_equivalent_neutral_length (data : Data) (radius : Real) (comparison : data.comparisonWronskian radius = 0) (charged : data.chargedComparison radius ≠ 0) : data.neutralReciprocalLength = data.equivalentReciprocalLength radius := by dsimp [comparisonWronskian, wronskian] at comparison rw [data.the_neutral_comparison_derivative_is_the_negative_reciprocal_length radius] at comparison dsimp [neutralComparison] at comparison have relation : data.neutralReciprocalLength * (data.chargedComparison radius - radius * deriv data.chargedComparison radius) = -deriv data.chargedComparison radius := by nlinarith [comparison] have denominator : data.chargedComparison radius - radius * deriv data.chargedComparison radius ≠ 0 := by intro zero rw [zero, mul_zero] at relation have slope : deriv data.chargedComparison radius = 0 := by linarith exact charged (by simpa [slope] using zero) exact (eq_div_iff denominator).mpr relation theorem the_source_weighted_comparison_determines_the_equivalent_neutral_length (data : Data) (physical : data.SamePotentialZeroEnergyAt) (cutoff : Real) (identities : data.FiniteWeightedIdentitiesAt cutoff) (balance : data.WeightedBalanceAt cutoff) (boundary : Tendsto data.boundaryDifference atTop (nhds 0)) (charged : data.chargedComparison cutoff ≠ 0) : data.neutralReciprocalLength = data.equivalentReciprocalLength cutoff := data.the_linear_comparison_determines_the_equivalent_neutral_length cutoff (data.weighted_balance_and_the_actual_boundary_limit_give_zero_comparison_wronskian physical cutoff identities balance boundary) charged end Data structure ValueSlope where value : Real slope : Real namespace ValueSlope def denominator (point : ValueSlope) (radius : Real) : Real := point.value - radius * point.slope def reciprocalLength (point : ValueSlope) (radius : Real) : Real := -point.slope / point.denominator radius def ControlledAt (actual approximate : ValueSlope) (radius valueError slopeError floor : Real) : Prop := 0 ≤ valueError ∧ 0 ≤ slopeError ∧ 0 < floor ∧ |actual.value - approximate.value| ≤ valueError ∧ |actual.slope - approximate.slope| ≤ slopeError ∧ floor + valueError + |radius| * slopeError ≤ |approximate.denominator radius| def errorBound (approximate : ValueSlope) (radius valueError slopeError floor : Real) : Real := (|approximate.slope| * valueError + |approximate.value| * slopeError) / (floor * |approximate.denominator radius|) theorem actual_wave_errors_control_the_readout_denominator (actual approximate : ValueSlope) (radius valueError slopeError floor : Real) (control : actual.ControlledAt approximate radius valueError slopeError floor) : floor ≤ |actual.denominator radius| ∧ 0 < |approximate.denominator radius| := by rcases control with ⟨valueNonnegative, slopeNonnegative, floorPositive, valueControl, slopeControl, margin⟩ have difference : approximate.denominator radius - actual.denominator radius = -(actual.value - approximate.value) + radius * (actual.slope - approximate.slope) := by unfold denominator ring have changeBound : |approximate.denominator radius - actual.denominator radius| ≤ valueError + |radius| * slopeError := by rw [difference] calc _ ≤ |-(actual.value - approximate.value)| + |radius * (actual.slope - approximate.slope)| := abs_add_le _ _ _ = |actual.value - approximate.value| + |radius| * |actual.slope - approximate.slope| := by rw [abs_neg, abs_mul] _ ≤ _ := add_le_add valueControl (mul_le_mul_of_nonneg_left slopeControl (abs_nonneg _)) have triangle := abs_sub_le (approximate.denominator radius) (actual.denominator radius) 0 simp only [sub_zero] at triangle refine ⟨by linarith, ?_⟩ have product := mul_nonneg (abs_nonneg radius) slopeNonnegative linarith theorem the_reciprocal_length_difference_uses_both_actual_denominators (actual approximate : ValueSlope) (radius : Real) (actualNonzero : actual.denominator radius ≠ 0) (approximateNonzero : approximate.denominator radius ≠ 0) : actual.reciprocalLength radius - approximate.reciprocalLength radius = (approximate.slope * (actual.value - approximate.value) - approximate.value * (actual.slope - approximate.slope)) / (actual.denominator radius * approximate.denominator radius) := by unfold reciprocalLength apply (eq_div_iff (mul_ne_zero actualNonzero approximateNonzero)).mpr field_simp unfold denominator ring theorem controlled_wave_and_slope_errors_bound_the_reciprocal_length (actual approximate : ValueSlope) (radius valueError slopeError floor : Real) (control : actual.ControlledAt approximate radius valueError slopeError floor) : |actual.reciprocalLength radius - approximate.reciprocalLength radius| ≤ approximate.errorBound radius valueError slopeError floor := by have denominators := actual.actual_wave_errors_control_the_readout_denominator approximate radius valueError slopeError floor control have floorPositive := control.2.2.1 have actualPositive : 0 < |actual.denominator radius| := lt_of_lt_of_le floorPositive denominators.1 rw [actual.the_reciprocal_length_difference_uses_both_actual_denominators approximate radius (abs_pos.mp actualPositive) (abs_pos.mp denominators.2), abs_div, abs_mul] have numerator : |approximate.slope * (actual.value - approximate.value) - approximate.value * (actual.slope - approximate.slope)| ≤ |approximate.slope| * valueError + |approximate.value| * slopeError := by calc _ ≤ |approximate.slope * (actual.value - approximate.value)| + |approximate.value * (actual.slope - approximate.slope)| := abs_sub _ _ _ = |approximate.slope| * |actual.value - approximate.value| + |approximate.value| * |actual.slope - approximate.slope| := by rw [abs_mul, abs_mul] _ ≤ _ := add_le_add (mul_le_mul_of_nonneg_left control.2.2.2.1 (abs_nonneg _)) (mul_le_mul_of_nonneg_left control.2.2.2.2.1 (abs_nonneg _)) exact div_le_div₀ (le_trans (abs_nonneg _) numerator) numerator (mul_pos floorPositive denominators.2) (mul_le_mul_of_nonneg_right denominators.1 denominators.2.le) end ValueSlope def Data.pointAt (data : Data) (radius : Real) : ValueSlope := ⟨data.chargedComparison radius, deriv data.chargedComparison radius⟩ structure SourceEstimate where bohrRadius : Real cutoff : Real intercept : Real namespace SourceEstimate def leadingSlope (estimate : SourceEstimate) : Real := (2 / estimate.bohrRadius) * (Real.log (2 * estimate.cutoff / estimate.bohrRadius) + Real.eulerMascheroniConstant) + estimate.intercept / estimate.bohrRadius def point (estimate : SourceEstimate) : ValueSlope where value := 1 + estimate.cutoff * (estimate.leadingSlope - 2 / estimate.bohrRadius) slope := estimate.leadingSlope + (2 * estimate.cutoff / estimate.bohrRadius) * (estimate.leadingSlope - 4 / estimate.bohrRadius) def firstOrderLength (estimate : SourceEstimate) : Real := -(estimate.leadingSlope + (4 * estimate.cutoff / estimate.bohrRadius) * (estimate.leadingSlope - 2 / estimate.bohrRadius)) def remainderNumerator (estimate : SourceEstimate) : Real := estimate.cutoff ^ 2 * (16 / estimate.bohrRadius ^ 3 - 2 * estimate.leadingSlope ^ 2 / estimate.bohrRadius - estimate.cutoff * (8 * estimate.leadingSlope ^ 2 / estimate.bohrRadius ^ 2 - 48 * estimate.leadingSlope / estimate.bohrRadius ^ 3 + 64 / estimate.bohrRadius ^ 4)) def remainder (estimate : SourceEstimate) : Real := estimate.remainderNumerator / estimate.point.denominator estimate.cutoff theorem the_printed_first_order_formula_has_an_explicit_rational_remainder (estimate : SourceEstimate) (positive : 0 < estimate.bohrRadius) (nonzero : estimate.point.denominator estimate.cutoff ≠ 0) : estimate.point.reciprocalLength estimate.cutoff = estimate.firstOrderLength + estimate.remainder := by have identity : -estimate.point.slope = estimate.firstOrderLength * estimate.point.denominator estimate.cutoff + estimate.remainderNumerator := by unfold firstOrderLength remainderNumerator point ValueSlope.denominator field_simp ring unfold ValueSlope.reciprocalLength remainder apply (div_eq_iff nonzero).mpr rw [identity] field_simp theorem changing_only_the_intercept_has_calculated_value_and_slope_effects (estimate : SourceEstimate) (intercept : Real) : estimate.point.value - ({estimate with intercept := intercept} : SourceEstimate).point.value = (estimate.cutoff / estimate.bohrRadius) * (estimate.intercept - intercept) ∧ estimate.point.slope - ({estimate with intercept := intercept} : SourceEstimate).point.slope = ((1 + 2 * estimate.cutoff / estimate.bohrRadius) / estimate.bohrRadius) * (estimate.intercept - intercept) := by constructor <;> dsimp [point, leadingSlope] <;> ring theorem the_controlled_wave_readout_retains_the_first_order_remainder (estimate : SourceEstimate) (actual : ValueSlope) (valueError slopeError floor : Real) (positive : 0 < estimate.bohrRadius) (control : actual.ControlledAt estimate.point estimate.cutoff valueError slopeError floor) : |actual.reciprocalLength estimate.cutoff - estimate.firstOrderLength| ≤ estimate.point.errorBound estimate.cutoff valueError slopeError floor + |estimate.remainder| := by have denominators := actual.actual_wave_errors_control_the_readout_denominator estimate.point estimate.cutoff valueError slopeError floor control have approximation := actual.controlled_wave_and_slope_errors_bound_the_reciprocal_length estimate.point estimate.cutoff valueError slopeError floor control have remainder := estimate.the_printed_first_order_formula_has_an_explicit_rational_remainder positive (abs_pos.mp denominators.2) have split := abs_sub_le (actual.reciprocalLength estimate.cutoff) (estimate.point.reciprocalLength estimate.cutoff) estimate.firstOrderLength have residual : |estimate.point.reciprocalLength estimate.cutoff - estimate.firstOrderLength| = |estimate.remainder| := by rw [remainder, add_sub_cancel_left] rw [residual] at split exact split.trans (add_le_add approximation le_rfl) def valueFitFactor (estimate : SourceEstimate) : Real := |estimate.cutoff / estimate.bohrRadius| def slopeFitFactor (estimate : SourceEstimate) : Real := |(1 + 2 * estimate.cutoff / estimate.bohrRadius) / estimate.bohrRadius| theorem intercept_calibration_has_distinct_value_and_slope_error_factors (estimate : SourceEstimate) (trueIntercept error : Real) (calibration : |trueIntercept - estimate.intercept| ≤ error) : |({estimate with intercept := trueIntercept} : SourceEstimate).point.value - estimate.point.value| ≤ estimate.valueFitFactor * error ∧ |({estimate with intercept := trueIntercept} : SourceEstimate).point.slope - estimate.point.slope| ≤ estimate.slopeFitFactor * error := by have effects := ({estimate with intercept := trueIntercept} : SourceEstimate) |>.changing_only_the_intercept_has_calculated_value_and_slope_effects estimate.intercept dsimp only at effects constructor · rw [effects.1, abs_mul] exact mul_le_mul_of_nonneg_left calibration (abs_nonneg _) · rw [effects.2, abs_mul] exact mul_le_mul_of_nonneg_left calibration (abs_nonneg _) theorem expansion_and_intercept_errors_are_added_before_the_inverse_readout (estimate : SourceEstimate) (actual : ValueSlope) (trueIntercept fitError valueError slopeError : Real) (calibration : |trueIntercept - estimate.intercept| ≤ fitError) (valueControl : |actual.value - ({estimate with intercept := trueIntercept} : SourceEstimate).point.value| ≤ valueError) (slopeControl : |actual.slope - ({estimate with intercept := trueIntercept} : SourceEstimate).point.slope| ≤ slopeError) : |actual.value - estimate.point.value| ≤ valueError + estimate.valueFitFactor * fitError ∧ |actual.slope - estimate.point.slope| ≤ slopeError + estimate.slopeFitFactor * fitError := by have fit := estimate.intercept_calibration_has_distinct_value_and_slope_error_factors trueIntercept fitError calibration exact ⟨(abs_sub_le actual.value _ estimate.point.value).trans (add_le_add valueControl fit.1), (abs_sub_le actual.slope _ estimate.point.slope).trans (add_le_add slopeControl fit.2)⟩ end SourceEstimate namespace TailProfile def neutralExterior (reciprocalLength radius : Real) : Real := 1 - reciprocalLength * radius def printedFiniteLength (decay slopeParameter radius : Real) : Real := 1 + slopeParameter * radius - Real.exp (-decay * radius) def MatchesNeutralAt (decay slopeParameter reciprocalLength : Real) : Prop := Tendsto (fun radius => printedFiniteLength decay slopeParameter radius - neutralExterior reciprocalLength radius) atTop (nhds 0) theorem the_printed_plus_profile_and_minus_exterior_have_an_actual_linear_difference (decay slopeParameter reciprocalLength radius : Real) : printedFiniteLength decay slopeParameter radius - neutralExterior reciprocalLength radius = (slopeParameter + reciprocalLength) * radius - Real.exp (-decay * radius) := by unfold printedFiniteLength neutralExterior ring theorem asymptotic_matching_requires_the_parameter_sign_identification (decay slopeParameter reciprocalLength : Real) (positive : 0 < decay) : MatchesNeutralAt decay slopeParameter reciprocalLength ↔ slopeParameter = -reciprocalLength := by have exponential : Tendsto (fun radius : Real => Real.exp (-decay * radius)) atTop (nhds 0) := by exact Real.tendsto_exp_atBot.comp (tendsto_id.const_mul_atTop_of_neg (neg_neg_of_pos positive)) constructor · intro matching have limit := (matching.add exponential).div_atTop tendsto_id have equality : (fun radius => (printedFiniteLength decay slopeParameter radius - neutralExterior reciprocalLength radius + Real.exp (-decay * radius)) / radius) =ᶠ[atTop] fun _ => slopeParameter + reciprocalLength := by filter_upwards [eventually_gt_atTop (0 : Real)] with radius positiveRadius rw [the_printed_plus_profile_and_minus_exterior_have_an_actual_linear_difference, sub_add_cancel, mul_div_cancel_right₀ _ positiveRadius.ne'] have sumZero := tendsto_nhds_unique tendsto_const_nhds (limit.congr' equality) linarith · intro identification have equality : (fun radius => printedFiniteLength decay slopeParameter radius - neutralExterior reciprocalLength radius) = fun radius => -Real.exp (-decay * radius) := by funext radius rw [the_printed_plus_profile_and_minus_exterior_have_an_actual_linear_difference, identification] ring unfold MatchesNeutralAt rw [equality] simpa using exponential.neg theorem one_nonzero_parameter_cannot_be_used_in_both_literal_asymptotic_conventions (decay reciprocalLength : Real) (positive : 0 < decay) (nonzero : reciprocalLength ≠ 0) : ¬MatchesNeutralAt decay reciprocalLength reciprocalLength := by intro matching have sign := (asymptotic_matching_requires_the_parameter_sign_identification _ _ _ positive).mp matching exact nonzero (by linarith) end TailProfile inductive NuclearShape where | squareWell | yukawa | exponential | gaussian deriving DecidableEq, Repr def NuclearShape.profile : NuclearShape -> Real -> Real | .squareWell, radius => if radius ≤ 1 then 1 else 0 | .yukawa, radius => Real.exp (-radius) / radius | .exponential, radius => Real.exp (-radius) | .gaussian, radius => Real.exp (-(radius ^ 2)) structure PotentialParameters where shape : NuclearShape range : Real depth : Real namespace PotentialParameters def value (potential : PotentialParameters) (radius : Real) : Real := -potential.depth * potential.shape.profile (radius / potential.range) def PhysicalAt (potential : PotentialParameters) : Prop := 0 < potential.range ∧ 0 < potential.depth def SameRangeAndShapeAt (left right : PotentialParameters) : Prop := left.range = right.range ∧ left.shape = right.shape def RelativeDifferenceAt (left right : PotentialParameters) (tolerance : Real) : Prop := 0 ≤ tolerance ∧ ∀ radius : Real, 0 < radius -> |left.value radius - right.value radius| ≤ tolerance * |right.value radius| theorem a_depth_comparison_controls_the_actual_potential_only_with_common_range_and_shape (left right : PotentialParameters) (physical : right.PhysicalAt) (tolerance : Real) (nonnegative : 0 ≤ tolerance) (common : left.SameRangeAndShapeAt right) (depthControl : |left.depth - right.depth| ≤ tolerance * right.depth) : left.RelativeDifferenceAt right tolerance := by refine ⟨nonnegative, ?_⟩ intro radius _positive have difference : left.value radius - right.value radius = -(left.depth - right.depth) * right.shape.profile (radius / right.range) := by unfold value rw [common.1, common.2] ring rw [difference, abs_mul, abs_neg] calc _ ≤ (tolerance * right.depth) * |right.shape.profile (radius / right.range)| := mul_le_mul_of_nonneg_right depthControl (abs_nonneg _) _ = tolerance * |right.value radius| := by simp only [value, abs_mul, abs_neg, abs_of_pos physical.2] ring def shortSquare : PotentialParameters := ⟨.squareWell, 1, 1⟩ def longSquare : PotentialParameters := ⟨.squareWell, 2, 1⟩ def gaussian : PotentialParameters := ⟨.gaussian, 1, 1⟩ def slightlyShallowerSquare : PotentialParameters := ⟨.squareWell, 1, 49 / 50⟩ theorem equal_depth_and_shape_do_not_control_potentials_with_different_ranges : shortSquare.PhysicalAt ∧ longSquare.PhysicalAt ∧ shortSquare.depth = longSquare.depth ∧ shortSquare.shape = longSquare.shape ∧ ¬shortSquare.RelativeDifferenceAt longSquare (1 / 10) := by refine ⟨by norm_num [PhysicalAt, shortSquare], by norm_num [PhysicalAt, longSquare], rfl, rfl, ?_⟩ intro bound have atRadius := bound.2 (3 / 2) (by norm_num) norm_num [value, shortSquare, longSquare, NuclearShape.profile] at atRadius theorem equal_depth_and_range_do_not_control_potentials_with_different_shapes : shortSquare.PhysicalAt ∧ gaussian.PhysicalAt ∧ shortSquare.depth = gaussian.depth ∧ shortSquare.range = gaussian.range ∧ ¬shortSquare.RelativeDifferenceAt gaussian (1 / 10) := by refine ⟨by norm_num [PhysicalAt, shortSquare], by norm_num [PhysicalAt, gaussian], rfl, rfl, ?_⟩ intro bound have atRadius := bound.2 2 (by norm_num) have positive := Real.exp_pos (-(4 : Real)) norm_num [value, shortSquare, gaussian, NuclearShape.profile, abs_of_pos positive] at atRadius linarith theorem a_common_shape_realizes_nonzero_but_controlled_potential_difference : slightlyShallowerSquare.PhysicalAt ∧ shortSquare.PhysicalAt ∧ slightlyShallowerSquare.SameRangeAndShapeAt shortSquare ∧ slightlyShallowerSquare.RelativeDifferenceAt shortSquare (3 / 100) ∧ slightlyShallowerSquare.value (1 / 2) ≠ shortSquare.value (1 / 2) := by have physical : shortSquare.PhysicalAt := by norm_num [PhysicalAt, shortSquare] have common : slightlyShallowerSquare.SameRangeAndShapeAt shortSquare := ⟨rfl, rfl⟩ refine ⟨by norm_num [PhysicalAt, slightlyShallowerSquare], physical, common, a_depth_comparison_controls_the_actual_potential_only_with_common_range_and_shape _ _ physical _ (by norm_num) common (by norm_num [slightlyShallowerSquare, shortSquare]), ?_⟩ norm_num [value, slightlyShallowerSquare, shortSquare, NuclearShape.profile] end PotentialParameters structure NeutralChannel where potential : Real -> Real wave : Real -> Real reciprocalLength : Real namespace NeutralChannel def AdmissibleAt (channel : NeutralChannel) : Prop := RadialComparison.RegularRadialEquationAt channel.potential 0 channel.wave 0 ∧ Tendsto (fun radius => channel.wave radius - (1 - channel.reciprocalLength * radius)) atTop (nhds 0) ∧ Tendsto (fun radius => RadialComparison.radialDerivative channel.wave radius + channel.reciprocalLength) atTop (nhds 0) ∧ ∀ upper : Real, 0 < upper -> IntegrableOn (fun radius => radius * channel.potential radius) (Ioc 0 upper) /-- The well-posed normalized zero-energy scattering problem is an explicit mathematical input, quantified over actual radial solutions. -/ def SamePotentialReadoutUniqueness : Prop := ∀ left right : NeutralChannel, left.AdmissibleAt -> right.AdmissibleAt -> (∀ radius : Real, 0 < radius -> left.potential radius = right.potential radius) -> left.reciprocalLength = right.reciprocalLength theorem different_actual_scattering_lengths_exclude_equal_nuclear_potentials (left right : NeutralChannel) (leftAdmissible : left.AdmissibleAt) (rightAdmissible : right.AdmissibleAt) (uniqueness : SamePotentialReadoutUniqueness) (different : left.reciprocalLength ≠ right.reciprocalLength) : ¬∀ radius : Real, 0 < radius -> left.potential radius = right.potential radius := by intro equal exact different (uniqueness left right leftAdmissible rightAdmissible equal) end NeutralChannel theorem estimate_and_measurement_errors_require_a_strict_separation_margin (actual neutral estimate observed estimateError measurementError : Real) (calculation : |actual - estimate| ≤ estimateError) (measurement : |neutral - observed| ≤ measurementError) (margin : estimateError + measurementError < |estimate - observed|) : actual ≠ neutral := by intro same rw [same] at calculation have bound := (abs_sub_le estimate neutral observed).trans (add_le_add (by simpa only [abs_sub_comm] using calculation) measurement) linarith theorem an_observed_length_difference_and_both_errors_bound_the_true_difference (actual neutral estimate observed estimateError measurementError : Real) (calculation : |actual - estimate| ≤ estimateError) (measurement : |neutral - observed| ≤ measurementError) : |actual - neutral| ≤ |estimate - observed| + estimateError + measurementError := by have first := abs_sub_le actual estimate neutral have second := abs_sub_le estimate observed neutral have measured : |observed - neutral| ≤ measurementError := by simpa only [abs_sub_comm] using measurement linarith namespace ReportedComparison def squareUncorrected : Real := -(585 / 1000) def tailUncorrected : Real := -(517 / 1000) def squareCorrected : Real := -(582 / 1000) def tailCorrected : Real := -(529 / 1000) def neutronSinglet : Real := -(421 / 1000) /-- Coordinates are in the paper's unit 10^12 inverse centimeters. These are reported rounded estimates, not exact physical scattering lengths. -/ theorem both_reported_corrected_estimates_have_a_small_nonzero_inverse_length_gap : |squareCorrected - neutronSinglet| = 161 / 1000 ∧ |tailCorrected - neutronSinglet| = 108 / 1000 ∧ 0 < |squareCorrected - neutronSinglet| ∧ 0 < |tailCorrected - neutronSinglet| ∧ |squareCorrected - neutronSinglet| / 4 < 1 / 20 ∧ |tailCorrected - neutronSinglet| / 4 < 1 / 20 := by norm_num [squareCorrected, tailCorrected, neutronSinglet] def InCorrectedBracket (estimate : Real) : Prop := squareCorrected ≤ estimate ∧ estimate ≤ tailCorrected def InSourceShapeBracket (estimate : Real) : Prop := squareUncorrected ≤ estimate ∧ estimate ≤ tailUncorrected theorem the_source_shape_bracket_has_a_gap_before_finite_length_corrections (estimate : Real) (bracket : InSourceShapeBracket estimate) : 96 / 1000 ≤ |estimate - neutronSinglet| ∧ |estimate - neutronSinglet| ≤ 164 / 1000 := by rcases bracket with ⟨lower, upper⟩ norm_num [squareUncorrected, tailUncorrected] at lower upper rw [abs_of_neg (show estimate - neutronSinglet < 0 by dsimp [neutronSinglet]; linarith)] dsimp [neutronSinglet] constructor <;> linarith theorem any_bracketed_estimate_retains_the_reported_gap (estimate : Real) (bracket : InCorrectedBracket estimate) : 108 / 1000 ≤ |estimate - neutronSinglet| ∧ |estimate - neutronSinglet| ≤ 161 / 1000 := by rcases bracket with ⟨lower, upper⟩ norm_num [squareCorrected, tailCorrected] at lower upper rw [abs_of_neg (show estimate - neutronSinglet < 0 by dsimp [neutronSinglet]; linarith)] dsimp [neutronSinglet] constructor <;> linarith end ReportedComparison inductive EvaluatedShape where | squareWell | yukawa deriving DecidableEq, Repr def EvaluatedShape.nuclearShape : EvaluatedShape -> NuclearShape | .squareWell => .squareWell | .yukawa => .yukawa structure RadiusReference where shape : EvaluatedShape intrinsicRange : Real tailDecay : Real tailSlopeParameter : Real finiteCorrection : Real seriesRemainder : Real namespace RadiusReference def zeroBindingWave (reference : RadiusReference) (radius : Real) : Real := match reference.shape with | .squareWell => if radius ≤ reference.intrinsicRange then Real.sin (Real.pi * radius / (2 * reference.intrinsicRange)) else 1 | .yukawa => 1 - Real.exp (-reference.tailDecay * radius) def zeroBindingRadius (reference : RadiusReference) : Real := match reference.shape with | .squareWell => reference.intrinsicRange * Real.exp (-(∫ radius in (0 : Real)..reference.intrinsicRange, reference.zeroBindingWave radius ^ 2 / radius)) | .yukawa => 2 / (reference.tailDecay * Real.exp Real.eulerMascheroniConstant) def estimate (reference : RadiusReference) : Real := reference.zeroBindingRadius * (1 + reference.finiteCorrection) def PhysicalAt (reference : RadiusReference) : Prop := 0 < reference.intrinsicRange ∧ 0 < reference.tailDecay ∧ -1 < reference.finiteCorrection def SourceSeriesAt (reference : RadiusReference) (neutralReciprocalLength : Real) : Prop := reference.finiteCorrection = (match reference.shape with | .squareWell => (114 / 1000) * neutralReciprocalLength * reference.intrinsicRange + (471 / 1000) * neutralReciprocalLength ^ 2 * reference.intrinsicRange ^ 2 | .yukawa => -(245 / 1000) * reference.tailSlopeParameter / reference.tailDecay - (51 / 1000) * reference.tailSlopeParameter ^ 2 / reference.tailDecay ^ 2) + reference.seriesRemainder theorem the_source_radius_estimate_is_positive (reference : RadiusReference) (physical : reference.PhysicalAt) : 0 < reference.estimate := by have base : 0 < reference.zeroBindingRadius := by unfold zeroBindingRadius cases reference.shape · exact mul_pos physical.1 (Real.exp_pos _) · exact div_pos (by norm_num) (mul_pos physical.2.1 (Real.exp_pos _)) exact mul_pos base (by linarith [physical.2.2]) end RadiusReference def Data.LogRadiusControlAt (data : Data) (lower upper sensitivity : Real) : Prop := 0 < lower ∧ lower ≤ upper ∧ 0 ≤ sensitivity ∧ (∀ radius ∈ Icc lower upper, data.chargedComparison radius - radius * deriv data.chargedComparison radius ≠ 0) ∧ ∀ first ∈ Icc lower upper, ∀ second ∈ Icc lower upper, |data.equivalentReciprocalLength first - data.equivalentReciprocalLength second| ≤ sensitivity * |Real.log first - Real.log second| theorem Data.a_controlled_log_radius_error_has_its_own_reciprocal_length_error (data : Data) (lower upper sensitivity exactRadius estimatedRadius radiusError : Real) (regular : data.LogRadiusControlAt lower upper sensitivity) (exactMember : exactRadius ∈ Icc lower upper) (estimatedMember : estimatedRadius ∈ Icc lower upper) (radiusControl : |Real.log exactRadius - Real.log estimatedRadius| ≤ radiusError) : |data.equivalentReciprocalLength exactRadius - data.equivalentReciprocalLength estimatedRadius| ≤ sensitivity * radiusError := (regular.2.2.2.2 exactRadius exactMember estimatedRadius estimatedMember).trans (mul_le_mul_of_nonneg_left radiusControl regular.2.2.1) structure StudyData where exactRadius : Real radiusReference : RadiusReference radiusLower : Real radiusUpper : Real radiusSensitivity : Real radiusError : Real interceptError : Real waveValueError : Real waveSlopeError : Real denominatorFloor : Real neutronMeasurementError : Real naturalInverseRange : Real smallGapFraction : Real depthTolerance : Real protonPotential : PotentialParameters neutronPotential : PotentialParameters neutronWave : Real -> Real otherPotential : Fin 2 -> PotentialParameters otherWave : Fin 2 -> Real -> Real otherReciprocalLength : Fin 2 -> Real otherShapeEstimate : Fin 2 -> Real otherShapeError : Fin 2 -> Real inverseLengthUnit : Real namespace ReadoutDiagnostics /-- These normalized smooth curves diagnose inversion, not a selected Coulomb or nuclear radial equation. -/ def curve (parameter radius : Real) : Real := 1 + (1 - parameter) * radius ^ 2 def point (parameter : Real) : ValueSlope := ⟨curve parameter 1, deriv (curve parameter) 1⟩ theorem the_diagnostic_slope_is_the_derivative_of_the_normalized_curve (parameter radius : Real) : deriv (curve parameter) radius = 2 * (1 - parameter) * radius := by have derivative := ((hasDerivAt_const radius (1 : Real)).add (((hasDerivAt_id radius).pow 2).const_mul (1 - parameter))).deriv change deriv (curve parameter) radius = 0 + (1 - parameter) * (2 * radius ^ (2 - 1) * 1) at derivative simpa only [Nat.reduceSub, pow_one, mul_one, one_mul, zero_add, mul_comm, mul_left_comm, mul_assoc] using derivative theorem small_wave_errors_need_not_give_a_small_inverse_length_error_near_a_pole : Continuous (curve (1 / 100)) ∧ Continuous (curve (1 / 50)) ∧ curve (1 / 100) 0 = 1 ∧ curve (1 / 50) 0 = 1 ∧ |(point (1 / 100)).value - (point (1 / 50)).value| = 1 / 100 ∧ |(point (1 / 100)).slope - (point (1 / 50)).slope| = 1 / 50 ∧ 0 < (point (1 / 100)).denominator 1 ∧ 0 < (point (1 / 50)).denominator 1 ∧ ¬|(point (1 / 100)).reciprocalLength 1 - (point (1 / 50)).reciprocalLength 1| ≤ 1 := by refine ⟨by unfold curve; fun_prop, by unfold curve; fun_prop, ?_⟩ simp only [ValueSlope.reciprocalLength, ValueSlope.denominator, point, the_diagnostic_slope_is_the_derivative_of_the_normalized_curve] norm_num [curve] rfl def truncatedEstimate : SourceEstimate := ⟨2, 1 / 10, -2 * (Real.log (1 / 10) + Real.eulerMascheroniConstant)⟩ set_option backward.isDefEq.respectTransparency false in theorem the_source_first_order_truncation_can_have_a_nonzero_remainder : 0 < truncatedEstimate.bohrRadius ∧ 0 < truncatedEstimate.cutoff ∧ truncatedEstimate.point.denominator truncatedEstimate.cutoff = 23 / 25 ∧ truncatedEstimate.point.reciprocalLength truncatedEstimate.cutoff = 5 / 23 ∧ truncatedEstimate.firstOrderLength = 1 / 5 ∧ truncatedEstimate.point.reciprocalLength truncatedEstimate.cutoff ≠ truncatedEstimate.firstOrderLength := by have leading : truncatedEstimate.leadingSlope = 0 := by norm_num [truncatedEstimate, SourceEstimate.leadingSlope] ring simp only [ValueSlope.reciprocalLength, ValueSlope.denominator, SourceEstimate.point, SourceEstimate.firstOrderLength, leading] norm_num [truncatedEstimate] theorem reparameterizing_the_tail_sign_matches_but_literal_parameter_reuse_does_not : TailProfile.MatchesNeutralAt 1 (-(1 / 4)) (1 / 4) ∧ ¬TailProfile.MatchesNeutralAt 1 (1 / 4) (1 / 4) := by constructor · exact (TailProfile.asymptotic_matching_requires_the_parameter_sign_identification _ _ _ (by norm_num)).mpr rfl · exact TailProfile.one_nonzero_parameter_cannot_be_used_in_both_literal_asymptotic_conventions _ _ (by norm_num) (by norm_num) structure CalibratedReadout where actual : Real neutral : Real estimate : Real observed : Real estimateError : Real measurementError : Real def CalibratedReadout.NonStrictlySeparatedAt (readout : CalibratedReadout) : Prop := |readout.actual - readout.estimate| ≤ readout.estimateError ∧ |readout.neutral - readout.observed| ≤ readout.measurementError ∧ 0 < |readout.estimate - readout.observed| ∧ readout.estimateError + readout.measurementError ≤ |readout.estimate - readout.observed| def overlappingErrors : CalibratedReadout := ⟨ReportedComparison.neutronSinglet, ReportedComparison.neutronSinglet, ReportedComparison.tailCorrected, ReportedComparison.neutronSinglet, 108 / 1000, 0⟩ theorem a_nonzero_reported_gap_with_only_nonstrict_error_separation_can_hide_equal_lengths : overlappingErrors.NonStrictlySeparatedAt ∧ ¬overlappingErrors.actual ≠ overlappingErrors.neutral := by norm_num [CalibratedReadout.NonStrictlySeparatedAt, overlappingErrors, ReportedComparison.neutronSinglet, ReportedComparison.tailCorrected] theorem the_uncorrected_shape_bracket_does_not_supply_the_corrected_bracket : ReportedComparison.InSourceShapeBracket (-(13 / 25)) ∧ ¬ReportedComparison.InCorrectedBracket (-(13 / 25)) := by norm_num [ReportedComparison.InSourceShapeBracket, ReportedComparison.InCorrectedBracket, ReportedComparison.squareUncorrected, ReportedComparison.tailUncorrected, ReportedComparison.squareCorrected, ReportedComparison.tailCorrected] end ReadoutDiagnostics namespace WeightedErrorControl /-! Smooth origin-regular error profiles on an origin-touching interval. They test norms of overlap errors, not a fixed nuclear-potential model. -/ def overlapError (scale radius : Real) : Real := (radius / scale) ^ 2 * (1 - radius / scale) ^ 2 def weightedError (scale radius : Real) : Real := radius / scale ^ 2 * (1 - radius / scale) ^ 2 def overlapPrimitive (scale radius : Real) : Real := radius ^ 3 / (3 * scale ^ 2) - radius ^ 4 / (2 * scale ^ 3) + radius ^ 5 / (5 * scale ^ 4) def weightedPrimitive (scale radius : Real) : Real := radius ^ 2 / (2 * scale ^ 2) - 2 * radius ^ 3 / (3 * scale ^ 3) + radius ^ 4 / (4 * scale ^ 4) theorem the_weight_is_the_actual_inverse_radius (scale radius : Real) (positive : 0 < scale) : weightedError scale radius = overlapError scale radius / radius := by by_cases zero : radius = 0 · simp [zero, weightedError, overlapError] · unfold weightedError overlapError field_simp theorem the_overlap_error_is_smooth_and_nonnegative (scale : Real) : ContDiff Real ⊤ (overlapError scale) ∧ overlapError scale 0 = 0 ∧ ∀ radius, 0 ≤ overlapError scale radius := by refine ⟨?_, by simp [overlapError], fun radius => mul_nonneg (sq_nonneg _) (sq_nonneg _)⟩ unfold overlapError fun_prop theorem overlap_primitive_derivative (scale radius : Real) (positive : 0 < scale) : HasDerivAt (overlapPrimitive scale) (overlapError scale radius) radius := by unfold overlapPrimitive convert (((((hasDerivAt_id radius).pow 3).div_const (3 * scale ^ 2)).sub (((hasDerivAt_id radius).pow 4).div_const (2 * scale ^ 3))).add (((hasDerivAt_id radius).pow 5).div_const (5 * scale ^ 4))) using 1 dsimp [overlapError] field_simp ring theorem weighted_primitive_derivative (scale radius : Real) (positive : 0 < scale) : HasDerivAt (weightedPrimitive scale) (weightedError scale radius) radius := by unfold weightedPrimitive convert (((((hasDerivAt_id radius).pow 2).div_const (2 * scale ^ 2)).sub ((((hasDerivAt_id radius).pow 3).const_mul 2).div_const (3 * scale ^ 3))).add (((hasDerivAt_id radius).pow 4).div_const (4 * scale ^ 4))) using 1 dsimp [weightedError] field_simp ring theorem the_actual_unweighted_integral_is_linear_in_the_radius (scale : Real) (positive : 0 < scale) : (∫ radius in (0 : Real)..scale, overlapError scale radius) = scale / 30 := by have continuous : Continuous (overlapError scale) := by unfold overlapError; fun_prop rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun radius _ => overlap_primitive_derivative scale radius positive) (continuous.intervalIntegrable 0 scale)] dsimp [overlapPrimitive] field_simp ring theorem the_actual_weighted_integral_is_independent_of_the_radius (scale : Real) (positive : 0 < scale) : (∫ radius in (0 : Real)..scale, weightedError scale radius) = 1 / 12 := by have continuous : Continuous (weightedError scale) := by unfold weightedError; fun_prop rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun radius _ => weighted_primitive_derivative scale radius positive) (continuous.intervalIntegrable 0 scale)] dsimp [weightedPrimitive] field_simp ring theorem arbitrarily_small_unweighted_errors_do_not_give_small_origin_weighted_errors (tolerance : Real) (positive : 0 < tolerance) : ∃ scale : Real, 0 < scale ∧ ContDiff Real ⊤ (overlapError scale) ∧ overlapError scale 0 = 0 ∧ (∫ radius in (0 : Real)..scale, |overlapError scale radius|) ≤ tolerance ∧ (∫ radius in (0 : Real)..scale, overlapError scale radius / radius) = 1 / 12 := by refine ⟨tolerance, positive, (the_overlap_error_is_smooth_and_nonnegative tolerance).1, (the_overlap_error_is_smooth_and_nonnegative tolerance).2.1, ?_, ?_⟩ · simp_rw [abs_of_nonneg ((the_overlap_error_is_smooth_and_nonnegative tolerance).2.2 _)] rw [the_actual_unweighted_integral_is_linear_in_the_radius tolerance positive] linarith · simp_rw [← the_weight_is_the_actual_inverse_radius tolerance _ positive] exact the_actual_weighted_integral_is_independent_of_the_radius tolerance positive theorem the_same_unweighted_tolerance_fails_for_a_smooth_origin_regular_profile : let scale : Real := 1 / 120 ContDiff Real ⊤ (overlapError scale) ∧ overlapError scale 0 = 0 ∧ (∫ radius in (0 : Real)..scale, |overlapError scale radius|) ≤ 1 / 120 ∧ ¬(|∫ radius in (0 : Real)..scale, overlapError scale radius / radius| ≤ 1 / 120) := by dsimp only have regular := the_overlap_error_is_smooth_and_nonnegative (1 / 120) refine ⟨regular.1, regular.2.1, ?_, ?_⟩ · simp_rw [abs_of_nonneg (regular.2.2 _)] rw [the_actual_unweighted_integral_is_linear_in_the_radius (1 / 120) (by norm_num)] norm_num · simp_rw [← the_weight_is_the_actual_inverse_radius (1 / 120) _ (by norm_num)] rw [the_actual_weighted_integral_is_independent_of_the_radius (1 / 120) (by norm_num)] norm_num def extendedError (scale : Real) : Real -> Real := (Icc 0 scale).indicator (overlapError scale) theorem the_zero_extension_has_the_actual_positive_axis_integral (profile : Real -> Real) (scale : Real) (positive : 0 < scale) : (∫ radius in Ioi (0 : Real), (Icc 0 scale).indicator profile radius) = ∫ radius in (0 : Real)..scale, profile radius := by have domain : Ioi (0 : Real) ∩ Icc 0 scale = Ioc 0 scale := by ext radius simp only [mem_inter_iff, mem_Ioi, mem_Icc, mem_Ioc] constructor · exact fun member => ⟨member.1, member.2.2⟩ · exact fun member => ⟨member.1, member.1.le, member.2⟩ rw [setIntegral_indicator measurableSet_Icc, domain, intervalIntegral.integral_of_le positive.le] rfl theorem the_extended_weight_is_the_actual_inverse_radius (scale : Real) (positive : 0 < scale) : (fun radius => extendedError scale radius / radius) = (Icc 0 scale).indicator (weightedError scale) := by funext radius by_cases inside : radius ∈ Icc (0 : Real) scale · simpa [extendedError, inside] using (the_weight_is_the_actual_inverse_radius scale radius positive).symm · simp [extendedError, inside] theorem the_zero_extension_is_continuous_and_vanishes_at_its_endpoints (scale : Real) (positive : 0 < scale) : Continuous (extendedError scale) ∧ extendedError scale 0 = 0 ∧ extendedError scale scale = 0 := by classical have continuous : Continuous (overlapError scale) := by unfold overlapError; fun_prop have agreement : ∀ radius ∈ frontier (Icc (0 : Real) scale), overlapError scale radius = (0 : Real) := by intro radius boundary rw [frontier_Icc positive.le] at boundary rcases (show radius = 0 ∨ radius = scale by simpa using boundary) with rfl | rfl · simp [overlapError] · simp [overlapError, positive.ne'] refine ⟨?_, ?_, ?_⟩ · have expression : extendedError scale = (Icc (0 : Real) scale).piecewise (overlapError scale) (fun _ => 0) := by funext radius by_cases inside : radius ∈ Icc (0 : Real) scale <;> simp [extendedError, Set.piecewise, inside] rw [expression] exact Continuous.piecewise agreement continuous continuous_const · simp [extendedError, overlapError, positive.le] · simp [extendedError, overlapError, positive.le, positive.ne'] theorem the_zero_extension_and_its_weight_are_nonnegative (scale : Real) : (∀ radius, 0 ≤ extendedError scale radius) ∧ ∀ radius, 0 ≤ extendedError scale radius / radius := by have nonnegative : ∀ radius, 0 ≤ extendedError scale radius := by intro radius by_cases inside : radius ∈ Icc (0 : Real) scale · simpa [extendedError, inside] using (the_overlap_error_is_smooth_and_nonnegative scale).2.2 radius · simp [extendedError, inside] refine ⟨nonnegative, ?_⟩ intro radius by_cases inside : radius ∈ Icc (0 : Real) scale · exact div_nonneg (nonnegative radius) inside.1 · simp [extendedError, inside] theorem the_compact_profile_has_distinct_global_unweighted_and_weighted_norms (scale : Real) (positive : 0 < scale) : Integrable (extendedError scale) ∧ Integrable (fun radius => extendedError scale radius / radius) ∧ (∫ radius in Ioi (0 : Real), |extendedError scale radius|) = scale / 30 ∧ (∫ radius in Ioi (0 : Real), |extendedError scale radius / radius|) = 1 / 12 := by have continuous : Continuous (overlapError scale) := by unfold overlapError; fun_prop have weightedContinuous : Continuous (weightedError scale) := by unfold weightedError; fun_prop have weight := the_extended_weight_is_the_actual_inverse_radius scale positive have nonnegative := the_zero_extension_and_its_weight_are_nonnegative scale refine ⟨continuous.continuousOn.integrableOn_Icc.integrable_indicator measurableSet_Icc, ?_, ?_, ?_⟩ · rw [weight] exact weightedContinuous.continuousOn.integrableOn_Icc.integrable_indicator measurableSet_Icc · simp_rw [abs_of_nonneg (nonnegative.1 _)] rw [extendedError, the_zero_extension_has_the_actual_positive_axis_integral _ scale positive] exact the_actual_unweighted_integral_is_linear_in_the_radius scale positive · simp_rw [abs_of_nonneg (nonnegative.2 _)] rw [weight, the_zero_extension_has_the_actual_positive_axis_integral _ scale positive] exact the_actual_weighted_integral_is_independent_of_the_radius scale positive theorem a_global_unweighted_error_bound_does_not_supply_the_same_coulomb_weighted_bound : let scale : Real := 1 / 120 Continuous (extendedError scale) ∧ extendedError scale 0 = 0 ∧ Integrable (extendedError scale) ∧ Integrable (fun radius => extendedError scale radius / radius) ∧ (∫ radius in Ioi (0 : Real), |extendedError scale radius|) ≤ 1 / 120 ∧ ¬((∫ radius in Ioi (0 : Real), |extendedError scale radius / radius|) ≤ 1 / 120) := by dsimp only have continuous := the_zero_extension_is_continuous_and_vanishes_at_its_endpoints (1 / 120) (by norm_num) have norms := the_compact_profile_has_distinct_global_unweighted_and_weighted_norms (1 / 120) (by norm_num) refine ⟨continuous.1, continuous.2.1, norms.1, norms.2.1, ?_, ?_⟩ · rw [norms.2.2.1] norm_num · rw [norms.2.2.2] norm_num end WeightedErrorControl end end CoulombChargeComparison /-! Finite empirical samples and the affine Coulomb plot. Source: original pp. 39, 45-47, equations (4), (51), (53), and Figures 3-4. The fitted parameters are estimates, not the exact integral-defined range. Calibration and held-out validation are finite sets of measured phase-shift data; their error bounds and reported slope accuracy remain empirical inputs. -/ namespace CoulombEmpiricalFit open CoulombComparison structure StudyData (Experiment : Type uExperiment) (Energy : Type uEnergy) where measuredPhaseShift : Experiment -> Energy -> Real plotUncertainty : Experiment -> Energy -> Real calibrationSample : Set (Experiment × Energy) validationSample : Set (Experiment × Energy) fittedIntercept : Real fittedSlope : Real slopeUncertainty : Real rangeRoundingAllowance : Real squareWellHighEnergyDeviation : Real structure Data (Experiment : Type uExperiment) (Energy : Type uEnergy) where parameters : ProtonParameters laboratoryEnergy : Energy -> Real momentum : Energy -> Real study : StudyData Experiment Energy noncomputable section variable {Experiment : Type uExperiment} {Energy : Type uEnergy} namespace Data def fittedLine (data : Data Experiment Energy) (energy : Real) : Real := data.study.fittedIntercept + data.study.fittedSlope * energy def sourceValue (data : Data Experiment Energy) (point : Experiment × Energy) : Real := sourceF data.parameters.bohrRadius (data.momentum point.2) (data.study.measuredPhaseShift point.1 point.2) def residual (data : Data Experiment Energy) (point : Experiment × Energy) : Real := data.sourceValue point - data.fittedLine (data.laboratoryEnergy point.2) def EnergyCalibratedAt (data : Data Experiment Energy) (energy : Energy) : Prop := 0 < data.laboratoryEnergy energy ∧ 0 < data.momentum energy ∧ data.laboratoryEnergy energy = 2 * data.parameters.planck ^ 2 * data.momentum energy ^ 2 / data.parameters.nucleonMass def PhysicalDatumAt (data : Data Experiment Energy) (point : Experiment × Energy) : Prop := data.EnergyCalibratedAt point.2 ∧ Real.sin (data.study.measuredPhaseShift point.1 point.2) ≠ 0 ∧ 0 < data.study.plotUncertainty point.1 point.2 def SampleSetup (data : Data Experiment Energy) : Prop := data.parameters.PositiveAt ∧ data.study.calibrationSample.Finite ∧ data.study.validationSample.Finite ∧ (∃ first ∈ data.study.calibrationSample, ∃ second ∈ data.study.calibrationSample, data.laboratoryEnergy first.2 ≠ data.laboratoryEnergy second.2) ∧ data.study.validationSample.Nonempty ∧ Disjoint data.study.calibrationSample data.study.validationSample ∧ ∀ point ∈ data.study.calibrationSample ∪ data.study.validationSample, data.PhysicalDatumAt point def FitAgreesOn (data : Data Experiment Energy) (sample : Set (Experiment × Energy)) : Prop := ∀ point ∈ sample, |data.residual point| ≤ data.study.plotUncertainty point.1 point.2 def QualifiedSlope (data : Data Experiment Energy) : Prop := 0 < data.study.fittedSlope ∧ 0 < data.study.slopeUncertainty ∧ data.study.slopeUncertainty ≤ data.study.fittedSlope / 20 def FitEvaluation (data : Data Experiment Energy) : Prop := data.FitAgreesOn data.study.calibrationSample ∧ data.FitAgreesOn data.study.validationSample ∧ data.QualifiedSlope def ComparisonSetupAt (data : Data Experiment Energy) (point : Experiment × Energy) : Prop := data.PhysicalDatumAt point ∧ ∀ low ∈ data.study.calibrationSample ∪ data.study.validationSample, data.laboratoryEnergy low.2 < data.laboratoryEnergy point.2 def rangeConversion (data : Data Experiment Energy) : Real := 4 * data.parameters.planck ^ 2 / (data.parameters.bohrRadius * data.parameters.nucleonMass) def rangeEstimate (data : Data Experiment Energy) : Real := data.rangeConversion * data.study.fittedSlope def rangeUncertainty (data : Data Experiment Energy) : Real := data.rangeConversion * data.study.slopeUncertainty def inverseLengthEstimate (data : Data Experiment Energy) : Real := -data.study.fittedIntercept / data.parameters.bohrRadius def effectiveRangeFitValue (data : Data Experiment Energy) (energy : Energy) : Real := data.parameters.bohrRadius * (-data.inverseLengthEstimate + data.momentum energy ^ 2 * data.rangeEstimate / 2) def ReportedRangeCompatible (data : Data Experiment Energy) (reportedRange : Real) : Prop := 0 ≤ data.study.rangeRoundingAllowance ∧ |reportedRange - data.rangeEstimate| ≤ data.study.rangeRoundingAllowance def FiniteSampleRangeResult (data : Data Experiment Energy) : Prop := data.SampleSetup ∧ data.FitEvaluation ∧ 0 < data.rangeEstimate ∧ 0 < data.rangeUncertainty ∧ data.rangeUncertainty ≤ data.rangeEstimate / 20 ∧ ∀ point ∈ data.study.calibrationSample ∪ data.study.validationSample, |data.sourceValue point - data.effectiveRangeFitValue point.2| ≤ data.study.plotUncertainty point.1 point.2 theorem the_laboratory_energy_range_conversion_is_positive (data : Data Experiment Energy) (positive : data.parameters.PositiveAt) : 0 < data.rangeConversion := by exact div_pos (mul_pos (by norm_num) (sq_pos_of_pos positive.2.1)) (mul_pos (ProtonParameters.positive_proton_parameters_give_a_positive_bohr_radius _ positive) positive.1) theorem laboratory_energy_calibration_derives_the_effective_range_fit (data : Data Experiment Energy) (positive : data.parameters.PositiveAt) (energy : Energy) (calibration : data.EnergyCalibratedAt energy) : data.fittedLine (data.laboratoryEnergy energy) = data.effectiveRangeFitValue energy := by have radius := ProtonParameters.positive_proton_parameters_give_a_positive_bohr_radius _ positive unfold fittedLine effectiveRangeFitValue inverseLengthEstimate rangeEstimate rangeConversion rw [calibration.2.2] field_simp [radius.ne', positive.1.ne'] ring theorem calibrated_finite_samples_give_range_estimates_and_actual_phase_residuals (data : Data Experiment Energy) (setup : data.SampleSetup) (evaluation : data.FitEvaluation) : data.FiniteSampleRangeResult := by have conversion := data.the_laboratory_energy_range_conversion_is_positive setup.1 refine ⟨setup, evaluation, mul_pos conversion evaluation.2.2.1, mul_pos conversion evaluation.2.2.2.1, ?_, ?_⟩ · unfold rangeUncertainty rangeEstimate nlinarith [mul_le_mul_of_nonneg_left evaluation.2.2.2.2 conversion.le] · intro point member rw [← data.laboratory_energy_calibration_derives_the_effective_range_fit setup.1 point.2 ((setup.2.2.2.2.2.2 point member).1)] rcases member with calibration | validation · exact evaluation.1 point calibration · exact evaluation.2.1 point validation theorem slope_uncertainty_propagates_through_the_actual_range_conversion (data : Data Experiment Energy) (positive : data.parameters.PositiveAt) (candidateSlope : Real) (controlled : |candidateSlope - data.study.fittedSlope| ≤ data.study.slopeUncertainty) : |data.rangeConversion * candidateSlope - data.rangeEstimate| ≤ data.rangeUncertainty := by have conversion := data.the_laboratory_energy_range_conversion_is_positive positive rw [rangeEstimate, ← mul_sub, abs_mul, abs_of_pos conversion] exact mul_le_mul_of_nonneg_left controlled conversion.le theorem a_reported_range_retains_separate_slope_and_rounding_errors (data : Data Experiment Energy) (positive : data.parameters.PositiveAt) (reportedRange candidateSlope : Real) (reporting : data.ReportedRangeCompatible reportedRange) (controlled : |candidateSlope - data.study.fittedSlope| ≤ data.study.slopeUncertainty) : |data.rangeConversion * candidateSlope - reportedRange| ≤ data.rangeUncertainty + data.study.rangeRoundingAllowance := by have converted := data.slope_uncertainty_propagates_through_the_actual_range_conversion positive candidateSlope controlled calc |data.rangeConversion * candidateSlope - reportedRange| ≤ |data.rangeConversion * candidateSlope - data.rangeEstimate| + |data.rangeEstimate - reportedRange| := abs_sub_le _ _ _ _ ≤ data.rangeUncertainty + data.study.rangeRoundingAllowance := by rw [abs_sub_comm data.rangeEstimate reportedRange] exact add_le_add converted reporting.2 end Data end end CoulombEmpiricalFit /-! Inhabited empirical-boundary controls using actual Coulomb source functions and unitary relative phases at positive laboratory energy. They do not assert realization by one fixed nuclear potential and are not the historical data. A controlled continuum fit is a stronger diagnostic input than the finite experimental fit; neither includes the zero-energy threshold endpoint. -/ namespace CoulombEmpiricalFit.CurveControls open CoulombComparison noncomputable section -- Equation (4) uses laboratory energy, not the relative kinetic energy. def momentum (parameters : ProtonParameters) (labEnergy : Real) : Real := Real.sqrt (parameters.nucleonMass * labEnergy / (2 * parameters.planck ^ 2)) theorem positive_laboratory_energy_gives_positive_momentum (parameters : ProtonParameters) (positive : parameters.PositiveAt) (energy : Real) (energyPositive : 0 < energy) : 0 < momentum parameters energy := by unfold momentum exact Real.sqrt_pos.mpr (div_pos (mul_pos positive.1 energyPositive) (mul_pos (by norm_num) (sq_pos_of_pos positive.2.1))) theorem the_momentum_has_the_source_laboratory_energy (parameters : ProtonParameters) (positive : parameters.PositiveAt) (energy : Real) (energyPositive : 0 < energy) : 2 * parameters.planck ^ 2 * momentum parameters energy ^ 2 / parameters.nucleonMass = energy := by have nonnegative : 0 <= parameters.nucleonMass * energy / (2 * parameters.planck ^ 2) := by exact le_of_lt (div_pos (mul_pos positive.1 energyPositive) (mul_pos (by norm_num) (sq_pos_of_pos positive.2.1))) rw [momentum, Real.sq_sqrt nonnegative] field_simp [positive.1.ne', positive.2.1.ne'] def phaseForPlot (parameter value : Real) : Real := Real.pi / 2 - Real.arctan ((value - sourceG parameter) * (Real.exp (2 * Real.pi * parameter) - 1) / (2 * Real.pi)) theorem the_constructed_relative_phase_has_nonzero_sine (parameter value : Real) : 0 < Real.sin (phaseForPlot parameter value) := by rw [phaseForPlot, Real.sin_pi_div_two_sub] exact Real.cos_arctan_pos _ theorem the_constructed_phase_realizes_the_actual_coulomb_plot (parameter value : Real) (positive : 0 < parameter) : sourceFAtEta parameter (phaseForPlot parameter value) = value := by have denominator : 0 < Real.exp (2 * Real.pi * parameter) - 1 := by exact sub_pos.mpr (Real.one_lt_exp_iff.mpr (mul_pos (mul_pos (by norm_num) Real.pi_pos) positive)) simp only [sourceFAtEta, phaseForPlot, Real.cos_pi_div_two_sub, Real.sin_pi_div_two_sub, <- Real.tan_eq_sin_div_cos, Real.tan_arctan] field_simp [denominator.ne', Real.pi_ne_zero] ring def phaseCurve (parameters : ProtonParameters) (curve : Real -> Real) (energy : Real) : Real := phaseForPlot (eta parameters.bohrRadius (momentum parameters energy)) (curve energy) def sourceCurve (parameters : ProtonParameters) (curve : Real -> Real) (energy : Real) : Real := sourceF parameters.bohrRadius (momentum parameters energy) (phaseCurve parameters curve energy) theorem the_source_curve_is_realized_at_each_positive_energy (parameters : ProtonParameters) (positive : parameters.PositiveAt) (curve : Real -> Real) (energy : Real) (energyPositive : 0 < energy) : sourceCurve parameters curve energy = curve energy := by apply the_constructed_phase_realizes_the_actual_coulomb_plot unfold eta exact one_div_pos.mpr (mul_pos (positive_laboratory_energy_gives_positive_momentum parameters positive energy energyPositive) (ProtonParameters.positive_proton_parameters_give_a_positive_bohr_radius parameters positive)) def relativeS (parameters : ProtonParameters) (curve : Real -> Real) (energy : Real) : Complex := ⟨Real.cos (2 * phaseCurve parameters curve energy), Real.sin (2 * phaseCurve parameters curve energy)⟩ theorem the_constructed_phase_matrix_has_unit_norm (parameters : ProtonParameters) (curve : Real -> Real) (energy : Real) : Complex.normSq (relativeS parameters curve energy) = 1 := by rw [relativeS, Complex.normSq_mk] nlinarith [Real.sin_sq_add_cos_sq (2 * phaseCurve parameters curve energy)] theorem positive_energy_realization_retains_the_physical_phase_and_unitarity (parameters : ProtonParameters) (positive : parameters.PositiveAt) (curve : Real -> Real) (energy : Real) (energyPositive : 0 < energy) : 0 < momentum parameters energy ∧ 0 < parameters.bohrRadius ∧ 0 < Real.sin (phaseCurve parameters curve energy) ∧ sourceCurve parameters curve energy = curve energy ∧ Complex.normSq (relativeS parameters curve energy) = 1 := by exact ⟨positive_laboratory_energy_gives_positive_momentum parameters positive energy energyPositive, ProtonParameters.positive_proton_parameters_give_a_positive_bohr_radius parameters positive, the_constructed_relative_phase_has_nonzero_sine _ _, the_source_curve_is_realized_at_each_positive_energy parameters positive curve energy energyPositive, the_constructed_phase_matrix_has_unit_norm parameters curve energy⟩ def fittedLine (energy : Real) : Real := 2 + energy def curvedPlot (coefficient energy : Real) : Real := fittedLine energy + coefficient * energy ^ 2 theorem the_curved_plot_has_its_actual_first_derivative (coefficient energy : Real) : HasDerivAt (curvedPlot coefficient) (1 + 2 * coefficient * energy) energy := by have base := (hasDerivAt_id energy).const_add (2 : Real) have correction := ((hasDerivAt_id energy).pow 2).const_mul coefficient convert base.add correction using 1 simp only [id_eq] ring theorem the_actual_source_curve_has_the_fitted_derivative (parameters : ProtonParameters) (positive : parameters.PositiveAt) (coefficient energy : Real) (energyPositive : 0 < energy) : HasDerivAt (sourceCurve parameters (curvedPlot coefficient)) (1 + 2 * coefficient * energy) energy := by apply (the_curved_plot_has_its_actual_first_derivative coefficient energy).congr_of_eventuallyEq filter_upwards [eventually_gt_nhds energyPositive] with other positiveEnergy exact the_source_curve_is_realized_at_each_positive_energy parameters positive _ other positiveEnergy theorem the_actual_source_curve_has_the_quadratic_curvature (parameters : ProtonParameters) (positive : parameters.PositiveAt) (coefficient energy : Real) (energyPositive : 0 < energy) : HasDerivAt (deriv (sourceCurve parameters (curvedPlot coefficient))) (2 * coefficient) energy := by have affine : HasDerivAt (fun other : Real => 1 + 2 * coefficient * other) (2 * coefficient) energy := by simpa using ((hasDerivAt_id energy).const_mul (2 * coefficient)).const_add (1 : Real) apply affine.congr_of_eventuallyEq filter_upwards [eventually_gt_nhds energyPositive] with other positiveEnergy exact (the_actual_source_curve_has_the_fitted_derivative parameters positive coefficient other positiveEnergy).deriv def ControlledFitOn (observed fitted : Real -> Real) (window : Set Real) (tolerance : Real) : Prop := window.Nonempty ∧ 0 < tolerance ∧ ∀ energy ∈ window, |observed energy - fitted energy| <= tolerance theorem each_curvature_sign_is_compatible_with_a_controlled_low_energy_line (parameters : ProtonParameters) (positive : parameters.PositiveAt) (coefficient : Real) (small : |coefficient| <= 1 / 10) : ControlledFitOn (sourceCurve parameters (curvedPlot coefficient)) fittedLine (Set.Ioc 0 1) (1 / 10) := by refine ⟨⟨1, by constructor <;> norm_num⟩, by norm_num, ?_⟩ intro energy member rw [the_source_curve_is_realized_at_each_positive_energy parameters positive _ energy member.1] have square : energy ^ 2 <= 1 := by nlinarith [member.1, member.2] have nonnegative : 0 <= energy ^ 2 := sq_nonneg energy dsimp [curvedPlot] rw [add_sub_cancel_left, abs_mul, abs_of_nonneg nonnegative] exact le_trans (mul_le_mul_of_nonneg_right small nonnegative) (by nlinarith) theorem a_controlled_low_energy_line_does_not_supply_higher_energy_agreement (parameters : ProtonParameters) (positive : parameters.PositiveAt) : ControlledFitOn (sourceCurve parameters (curvedPlot (1 / 10))) fittedLine (Set.Ioc 0 1) (1 / 10) ∧ (1 / 10 : Real) < |sourceCurve parameters (curvedPlot (1 / 10)) 4 - fittedLine 4| := by refine ⟨each_curvature_sign_is_compatible_with_a_controlled_low_energy_line parameters positive (1 / 10) (by norm_num), ?_⟩ rw [the_source_curve_is_realized_at_each_positive_energy parameters positive _ 4 (by norm_num)] norm_num [curvedPlot, fittedLine] theorem low_energy_fit_tolerance_does_not_select_the_actual_curvature_sign (parameters : ProtonParameters) (positive : parameters.PositiveAt) : ControlledFitOn (sourceCurve parameters (curvedPlot (1 / 10))) fittedLine (Set.Ioc 0 1) (1 / 10) ∧ ControlledFitOn (sourceCurve parameters (curvedPlot (-1 / 10))) fittedLine (Set.Ioc 0 1) (1 / 10) ∧ 0 < deriv (deriv (sourceCurve parameters (curvedPlot (1 / 10)))) (1 / 2) ∧ deriv (deriv (sourceCurve parameters (curvedPlot (-1 / 10)))) (1 / 2) < 0 := by refine ⟨each_curvature_sign_is_compatible_with_a_controlled_low_energy_line parameters positive (1 / 10) (by norm_num), each_curvature_sign_is_compatible_with_a_controlled_low_energy_line parameters positive (-1 / 10) (by norm_num), ?_, ?_⟩ · rw [(the_actual_source_curve_has_the_quadratic_curvature parameters positive (1 / 10) (1 / 2) (by norm_num)).deriv] norm_num · rw [(the_actual_source_curve_has_the_quadratic_curvature parameters positive (-1 / 10) (1 / 2) (by norm_num)).deriv] norm_num def controlParameters : ProtonParameters where nucleonMass := 2 planck := 1 chargeSquared := 1 theorem the_control_has_positive_parameters_and_an_actual_laboratory_energy : controlParameters.PositiveAt ∧ controlParameters.bohrRadius = 1 ∧ momentum controlParameters 1 = 1 := by norm_num [controlParameters, ProtonParameters.PositiveAt, ProtonParameters.bohrRadius, momentum] def PhysicalCurve (parameters : ProtonParameters) (curve : Real -> Real) : Prop := parameters.PositiveAt ∧ ∀ energy : Real, 0 < energy → 2 * parameters.planck ^ 2 * momentum parameters energy ^ 2 / parameters.nucleonMass = energy ∧ 0 < momentum parameters energy ∧ 0 < parameters.bohrRadius ∧ 0 < Real.sin (phaseCurve parameters curve energy) ∧ sourceCurve parameters curve energy = curve energy ∧ Complex.normSq (relativeS parameters curve energy) = 1 theorem each_control_curve_has_positive_energy_phase_calibration (curve : Real -> Real) : PhysicalCurve controlParameters curve := by have positive := the_control_has_positive_parameters_and_an_actual_laboratory_energy.1 refine ⟨positive, ?_⟩ intro energy energyPositive exact ⟨the_momentum_has_the_source_laboratory_energy _ positive energy energyPositive, positive_energy_realization_retains_the_physical_phase_and_unitarity _ positive curve energy energyPositive⟩ def sampleData (curve : Real -> Real) : Data Bool Real where parameters := controlParameters laboratoryEnergy := id momentum := momentum controlParameters study := { measuredPhaseShift := fun _ energy => phaseCurve controlParameters curve energy plotUncertainty := fun _ _ => 1 / 10 calibrationSample := {(false, 1 / 4), (false, 1)} validationSample := {(true, 1 / 2)} fittedIntercept := 2 fittedSlope := 1 slopeUncertainty := 1 / 20 rangeRoundingAllowance := 0 squareWellHighEnergyDeviation := 1 / 10 } theorem each_positive_energy_sample_has_an_actual_phase_and_laboratory_calibration (curve : Real -> Real) (experiment : Bool) (energy : Real) (positive : 0 < energy) : (sampleData curve).PhysicalDatumAt (experiment, energy) := by have parameters := the_control_has_positive_parameters_and_an_actual_laboratory_energy.1 refine ⟨⟨positive, positive_laboratory_energy_gives_positive_momentum _ parameters energy positive, (the_momentum_has_the_source_laboratory_energy _ parameters energy positive).symm⟩, (the_constructed_relative_phase_has_nonzero_sine _ _).ne', ?_⟩ norm_num [sampleData] theorem the_control_sample_is_finite_physical_and_has_held_out_validation (curve : Real -> Real) : (sampleData curve).SampleSetup := by refine ⟨the_control_has_positive_parameters_and_an_actual_laboratory_energy.1, (Set.finite_singleton _).insert _, Set.finite_singleton _, ?_, ?_, ?_, ?_⟩ · refine ⟨(false, 1 / 4), by simp [sampleData], (false, 1), by simp [sampleData], ?_⟩ norm_num [sampleData] · exact ⟨(true, 1 / 2), by simp [sampleData]⟩ · apply Set.disjoint_left.mpr intro point calibration validation simp only [sampleData, Set.mem_insert_iff, Set.mem_singleton_iff] at calibration validation subst point rcases calibration with equal | equal · have impossible := congrArg Prod.fst equal cases impossible · have impossible := congrArg Prod.fst equal cases impossible · intro point member simp only [sampleData, Set.mem_union, Set.mem_insert_iff, Set.mem_singleton_iff] at member rcases member with (rfl | rfl) | rfl all_goals apply each_positive_energy_sample_has_an_actual_phase_and_laboratory_calibration all_goals norm_num theorem matching_the_three_sample_values_gives_the_finite_fit (curve : Real -> Real) (first : curve (1 / 4) = fittedLine (1 / 4)) (second : curve 1 = fittedLine 1) (heldOut : curve (1 / 2) = fittedLine (1 / 2)) : (sampleData curve).FitEvaluation := by have parameters := the_control_has_positive_parameters_and_an_actual_laboratory_energy.1 refine ⟨?_, ?_, ?_⟩ · intro point member simp only [sampleData, Set.mem_insert_iff, Set.mem_singleton_iff] at member rcases member with rfl | rfl · change |sourceCurve controlParameters curve (1 / 4) - (2 + 1 * (1 / 4))| ≤ 1 / 10 simp only [one_mul] rw [the_source_curve_is_realized_at_each_positive_energy _ parameters _ _ (by norm_num), first] norm_num [fittedLine] · change |sourceCurve controlParameters curve 1 - (2 + 1 * 1)| ≤ 1 / 10 simp only [one_mul] rw [the_source_curve_is_realized_at_each_positive_energy _ parameters _ _ (by norm_num), second] norm_num [fittedLine] · intro point member simp only [sampleData, Set.mem_singleton_iff] at member subst point change |sourceCurve controlParameters curve (1 / 2) - (2 + 1 * (1 / 2))| ≤ 1 / 10 simp only [one_mul] rw [the_source_curve_is_realized_at_each_positive_energy _ parameters _ _ (by norm_num), heldOut] norm_num [fittedLine] · norm_num [Data.QualifiedSlope, sampleData] def sampledCurve (energy : Real) : Real := fittedLine energy + 1024 * (energy - 1 / 4) ^ 2 * (energy - 1 / 2) ^ 2 * (energy - 1) ^ 2 theorem finite_fitting_and_validation_do_not_control_an_unsampled_low_energy : (sampleData sampledCurve).FiniteSampleRangeResult ∧ ¬ControlledFitOn (sourceCurve controlParameters sampledCurve) fittedLine (Set.Ioc 0 1) (1 / 10) := by have evaluation := matching_the_three_sample_values_gives_the_finite_fit sampledCurve (by simp [sampledCurve]) (by simp [sampledCurve]) (by simp [sampledCurve]) refine ⟨(sampleData sampledCurve).calibrated_finite_samples_give_range_estimates_and_actual_phase_residuals (the_control_sample_is_finite_physical_and_has_held_out_validation _) evaluation, ?_⟩ intro uniform have atMissing := uniform.2.2 (3 / 4) (by constructor <;> norm_num) rw [the_source_curve_is_realized_at_each_positive_energy _ the_control_has_positive_parameters_and_an_actual_laboratory_energy.1 _ _ (by norm_num)] at atMissing norm_num [sampledCurve, fittedLine] at atMissing exact (by norm_num : ¬ |(1 : Real)| ≤ 1 / 10) atMissing def relativeEnergyRangeEstimate (data : Data Bool Real) : Real := 2 * data.parameters.planck ^ 2 / (data.parameters.bohrRadius * data.parameters.nucleonMass) * data.study.fittedSlope theorem the_measured_laboratory_slope_does_not_have_the_relative_energy_range : (sampleData fittedLine).FiniteSampleRangeResult ∧ (sampleData fittedLine).rangeEstimate ≠ relativeEnergyRangeEstimate (sampleData fittedLine) := by refine ⟨(sampleData fittedLine).calibrated_finite_samples_give_range_estimates_and_actual_phase_residuals (the_control_sample_is_finite_physical_and_has_held_out_validation _) (matching_the_three_sample_values_gives_the_finite_fit _ rfl rfl rfl), ?_⟩ norm_num [Data.rangeEstimate, Data.rangeConversion, relativeEnergyRangeEstimate, sampleData, controlParameters, ProtonParameters.bohrRadius] exact (by norm_num : (2 : Real) ≠ 1) end end CoulombEmpiricalFit.CurveControls structure BetheTypes where Channel : Type uChannel Energy : Type uEnergy WaveFunction : Type uWaveFunction Potential : Type uPotential Experiment : Type uExperiment Regime : Type uRegime /-- Paper-local physical vocabulary. Numerical quantities are data; physical, calculation, approximation, empirical, and interpretive assertions are proposition-valued relations. -/ structure EffectiveRangeFramework (T : BetheTypes) where neutronProtonTriplet : T.Channel neutronProtonSinglet : T.Channel protonProtonSinglet : T.Channel neutralCounterpartOfProtonProton : T.Channel zeroEnergy : T.Energy selectedLowEnergy : T.Energy selectedCrossSectionEnergy : T.Energy selectedHighEnergy : T.Energy selectedCompatibleHighEnergy : T.Energy deuteronBoundEnergy : T.Energy neutralActualWave : T.WaveFunction neutralComparisonWave : T.WaveFunction neutralZeroEnergyWave : T.WaveFunction neutralZeroEnergyComparisonWave : T.WaveFunction coulombActualWave : T.WaveFunction coulombComparisonWave : T.WaveFunction coulombZeroEnergyWave : T.WaveFunction coulombZeroEnergyComparisonWave : T.WaveFunction neutralizedProtonWave : T.WaveFunction neutralizedProtonComparisonWave : T.WaveFunction neutronProtonPotential : T.Potential protonProtonNuclearPotential : T.Potential coulombPotential : T.Potential neutronProtonExperiment : T.Experiment protonProtonHighEnergyExperiment : T.Experiment protonProtonCompatibleHighEnergyExperiment : T.Experiment nuclearRegime : T.Regime laboratoryEnergyValue : T.Energy -> Real waveNumberSquared : T.Energy → Real waveNumberValue : T.Energy → Real neutralPhaseShiftValue : T.Channel → T.Energy → Real neutralPhaseFunctionValue : T.Channel → T.Energy → Real observedNeutralPhaseFunctionValue : T.Experiment → T.Channel → T.Energy → Real coulombPhaseShiftValue : T.Channel → T.Energy → Real coulombProtonParameters : T.Channel → CoulombComparison.ProtonParameters coulombReferenceBasis : T.Channel → T.Energy → CoulombComparison.ReferenceBasis coulombNuclearRangeValue : T.Channel → Real coulombHierarchyTolerance : T.Channel → Real coulombEnergyRangeToleranceAt : T.Channel → T.Energy → Real coulombNeutralizationToleranceAt : T.Channel → Real coulombEnergyAtEta : Real → T.Energy protonEmpiricalStudy : CoulombEmpiricalFit.StudyData T.Experiment T.Energy neutralCrossSectionValue : T.Channel → T.Energy → Real reciprocalScatteringLength : T.Channel → Real energyDependentRangeValue : T.Channel → T.Energy → Real effectiveRangeValue : T.Channel → Real shapeCoefficientValue : T.Channel → Real bindingWaveNumber : T.Channel → Real reportedTripletEffectiveRange : Real reportedProtonProtonEffectiveRange : Real chargeStudy : CoulombChargeComparison.StudyData measuredNeutronProtonSingletReciprocalLength : Real neutralBoundaryDifference : T.Channel → T.Energy → T.Energy → Real neutralWaveNumberDifference : T.Energy → T.Energy → Real neutralOverlapIntegral : T.Channel → T.Energy → T.Energy → Real radialWaveValueAt : T.WaveFunction → Real → Real neutralScaledPotentialValueAt : T.Potential → Real → Real rangeReplacementToleranceAt : T.Regime → Real coulombBoundaryDifference : T.Channel → T.Energy → T.Energy → Real coulombWaveNumberDifference : T.Energy → T.Energy → Real coulombOverlapIntegral : T.Channel → T.Energy → T.Energy → Real sWaveChannelAt : T.Channel → T.Regime → Prop energyInNeutralScatteringScopeAt : T.Energy → T.Regime → Prop lowEnergyRelativeToForceRangeAt : T.Energy → T.Potential → T.Regime → Prop finiteRangeNuclearPotentialAt : T.Channel → T.Potential → T.Regime → Prop waveSolvesRadialEquationAt : T.WaveFunction → T.Channel → T.Potential → T.Energy → T.Regime → Prop comparisonWaveMatchesOutsideForceRangeAt : T.WaveFunction → T.WaveFunction → T.Channel → T.Energy → T.Regime → Prop waveNormalizedAtOriginAt : T.WaveFunction → T.Channel → T.Energy → T.Regime → Prop phaseFunctionMatchesEffectiveRangeLawAt : T.Channel → T.Energy → T.Regime → Prop neutralCrossSectionCalculatedAt : T.Channel → T.Energy → T.Regime → Prop neutralCrossSectionSatisfiesUnitarityBoundAt : T.Channel → T.Energy → T.Regime → Prop neutralPhaseFunctionVanishingAt : T.Channel → T.Energy → T.Regime → Prop neutralCrossSectionMaximalAt : T.Channel → T.Energy → T.Regime → Prop nextCrossSectionTermRequiredForUnitarityNearMaximumAt : T.Channel → T.Energy → T.Regime → Prop higherOrderShapeExpansionCalculatedAt : T.Channel → T.Energy → T.Regime → Prop shapeCoefficientSmallAt : T.Channel → T.Energy → T.Regime → Prop effectiveRangeApproximationAccurateAt : T.Channel → T.Energy → T.Regime → Prop potentialShapeResolvedByPhaseDataAt : T.Experiment → T.Channel → T.Regime → Prop resolvedCurvatureWouldDiscriminatePotentialTailAt : T.Experiment → T.Channel → T.Regime → Prop upwardCurvatureWouldIndicateConcentratedPotentialAt : T.Experiment → T.Channel → T.Regime → Prop downwardCurvatureWouldIndicateLongTailedPotentialAt : T.Experiment → T.Channel → T.Regime → Prop curvatureDeviationSignificantAt : T.Experiment → T.Channel → T.Regime → Prop squareWellWouldRequireDifferentIntrinsicRangesAt : T.Channel → T.Channel → T.Regime → Prop longTailedPotentialAllowsCommonIntrinsicRangeAt : T.Channel → T.Channel → T.Regime → Prop singleChannelEnergyDependenceDeterminesPotentialShapeAt : T.Experiment → T.Channel → T.Regime → Prop deuteronBoundStateAt : T.Channel → T.Energy → T.Regime → Prop deuteronBindingDatumMeasuredAt : T.Experiment → T.Channel → T.Energy → T.Regime → Prop lowEnergyScatteringDatumMeasuredAt : T.Experiment → T.Channel → T.Regime → Prop tripletBoundStateRelationControlledAt : T.Channel → T.Energy → T.Regime → Prop effectiveRangeExtractedAt : T.Experiment → T.Channel → Real → T.Regime → Prop reportedTripletEffectiveRangeQualifiedAt : T.Experiment → T.Channel → Real → T.Regime → Prop singletRangeAccuratelyDeterminedFromNeutronProtonDataAt : T.Experiment → T.Channel → T.Regime → Prop approximateSingletForceEqualityUsedAt : T.Channel → T.Channel → T.Regime → Prop effectiveRangeBorrowedFromToAt : T.Channel → T.Channel → T.Regime → Prop coulombPhaseFunctionMatchesEffectiveRangeLawAt : T.Channel → T.Energy → T.Regime → Prop phaseShiftDataExtractedAt : T.Experiment → T.Channel → T.Regime → Prop highEnergyDeviationPointsTowardConcentratedPotentialAt : T.Experiment → T.Channel → T.Regime → Prop tensorForceEffectExplainsHighEnergyDiscrepancyAt : T.Experiment → T.Channel → T.Regime → Prop highEnergyDiscrepancyExplainedAt : T.Experiment → T.Channel → T.Regime → Prop tensorForceExtensionDeferredAt : T.Regime → Prop deuteronPhotoeffectExtensionDeferredAt : T.Regime → Prop namespace EffectiveRangeFramework open MeasureTheory Set Filter variable {T : BetheTypes} noncomputable def radialIntegralValueAt (_framework : EffectiveRangeFramework T) (integrand : Real -> Real) : Real := ∫ radius in Ioi (0 : Real), integrand radius def rangeApproximatelyEqualAt (framework : EffectiveRangeFramework T) (first second : Real) (regime : T.Regime) : Prop := 0 <= framework.rangeReplacementToleranceAt regime ∧ |first - second| <= framework.rangeReplacementToleranceAt regime def zeroEnergyInteriorReplacementControlledAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) : Prop := framework.rangeApproximatelyEqualAt (framework.energyDependentRangeValue channel energy / 2) (framework.effectiveRangeValue channel / 2) regime def neutralRadialData (framework : EffectiveRangeFramework T) : RadialComparison.Data where potential := framework.neutralScaledPotentialValueAt framework.neutronProtonPotential waveNumberSquared := fun index => if index = 0 then framework.waveNumberSquared framework.zeroEnergy else framework.waveNumberSquared framework.selectedLowEnergy actual := fun index => framework.radialWaveValueAt (if index = 0 then framework.neutralZeroEnergyWave else framework.neutralActualWave) comparison := fun index => framework.radialWaveValueAt (if index = 0 then framework.neutralZeroEnergyComparisonWave else framework.neutralComparisonWave) /-- Physical Review p. 39, equation (7): the asymptotic comparison wave is normalized to one at the origin by dividing sin(kr + delta) by sin(delta). The wave-number square relation and the stated origin-derivative readout k cot(delta) are retained so the k and delta used here are the same ones later used in equations (10)-(17). -/ def EquationSevenComparisonWaveFormulaAt (framework : EffectiveRangeFramework T) : Prop := framework.waveNumberSquared framework.selectedLowEnergy = framework.waveNumberValue framework.selectedLowEnergy ^ 2 ∧ Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy) ≠ 0 ∧ (∀ radius, framework.radialWaveValueAt framework.neutralComparisonWave radius = Real.sin (framework.waveNumberValue framework.selectedLowEnergy * radius + framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy) / Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)) ∧ framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy = framework.waveNumberValue framework.selectedLowEnergy * (Real.cos (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy) / Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)) /-- Physical Review p. 39, equation (10): subtracting the two exact and comparison radial identities leaves the phase-function difference equal to the wave-number-square difference times the comparison-minus-exact overlap. -/ def EquationTenNeutralComparisonFormulaAt (framework : EffectiveRangeFramework T) : Prop := framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy - framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.zeroEnergy = (framework.waveNumberSquared framework.selectedLowEnergy - framework.waveNumberSquared framework.zeroEnergy) * framework.radialIntegralValueAt (fun radius => framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave radius * framework.radialWaveValueAt framework.neutralComparisonWave radius - framework.radialWaveValueAt framework.neutralZeroEnergyWave radius * framework.radialWaveValueAt framework.neutralActualWave radius) /-- Physical Review p. 39, equation (11): k cot(delta) at zero energy is -alpha. -/ def EquationElevenZeroEnergyScatteringLengthFormulaAt (framework : EffectiveRangeFramework T) : Prop := framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.zeroEnergy = -framework.reciprocalScatteringLength framework.neutronProtonTriplet /-- Physical Review p. 39, equation (13): half of rho(0,E) is the comparison-minus exact overlap integral. This is the same integral appearing in equation (10), not an independently named range datum. -/ def EquationThirteenEnergyDependentRangeIntegralFormulaAt (framework : EffectiveRangeFramework T) : Prop := IntegrableOn framework.neutralRadialData.overlap (Ioi 0) ∧ (1 / 2 : Real) * framework.energyDependentRangeValue framework.neutronProtonTriplet framework.selectedLowEnergy = framework.radialIntegralValueAt (fun radius => framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave radius * framework.radialWaveValueAt framework.neutralComparisonWave radius - framework.radialWaveValueAt framework.neutralZeroEnergyWave radius * framework.radialWaveValueAt framework.neutralActualWave radius) /-- The exact definition within equation (14): half of r0 is the actual zero-energy comparison-minus-exact square integral. The approximate replacement of rho(0,E) by r0 is a separate, later controlled input. -/ def EquationFourteenEffectiveRangeIntegralFormulaAt (framework : EffectiveRangeFramework T) : Prop := IntegrableOn (fun radius => framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave radius ^ 2 - framework.radialWaveValueAt framework.neutralZeroEnergyWave radius ^ 2) (Ioi 0) ∧ (1 / 2 : Real) * framework.effectiveRangeValue framework.neutronProtonTriplet = framework.radialIntegralValueAt (fun radius => framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave radius ^ 2 - framework.radialWaveValueAt framework.neutralZeroEnergyWave radius ^ 2) /-- The literal early radial readout used by Bethe's effective-range reduction. The last conjunct is the k1 = 0 specialization used between equations (10) and (11). -/ def NeutralRadialFormulaReadoutAt (framework : EffectiveRangeFramework T) : Prop := framework.EquationSevenComparisonWaveFormulaAt ∧ framework.EquationTenNeutralComparisonFormulaAt ∧ framework.EquationElevenZeroEnergyScatteringLengthFormulaAt ∧ framework.EquationThirteenEnergyDependentRangeIntegralFormulaAt ∧ framework.EquationFourteenEffectiveRangeIntegralFormulaAt ∧ framework.waveNumberSquared framework.zeroEnergy = 0 def ExactNeutralComparisonIdentityAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (firstEnergy secondEnergy : T.Energy) : Prop := framework.neutralBoundaryDifference channel firstEnergy secondEnergy = framework.neutralWaveNumberDifference firstEnergy secondEnergy * framework.neutralOverlapIntegral channel firstEnergy secondEnergy def NeutralZeroEnergyRelationAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.neutralPhaseFunctionValue channel energy = -framework.reciprocalScatteringLength channel + (1 / 2 : Real) * framework.waveNumberSquared energy * framework.energyDependentRangeValue channel energy /-- The model's two-parameter phase prediction is distinct from k cot(delta). -/ noncomputable def twoParameterPhaseValueAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Real := RadialComparison.Approximation.twoParameterPhase (framework.reciprocalScatteringLength channel) (framework.effectiveRangeValue channel) (framework.waveNumberSquared energy) /-- Equation (16) is the approximation obtained from (14), not an exact identity of the physical phase function. The tolerance is an explicit quantitative reconstruction, not a numerical bound printed by Bethe. -/ def NeutralEffectiveRangeLawAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := RadialComparison.Approximation.PhaseApproximationAt (framework.neutralPhaseFunctionValue channel energy) (framework.reciprocalScatteringLength channel) (framework.effectiveRangeValue channel) (framework.waveNumberSquared energy) (framework.rangeReplacementToleranceAt framework.nuclearRegime) def ExactTwoParameterPhaseLawAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.neutralPhaseFunctionValue channel energy = framework.twoParameterPhaseValueAt channel energy def NeutralComparisonSetup (framework : EffectiveRangeFramework T) : Prop := framework.sWaveChannelAt framework.neutronProtonTriplet framework.nuclearRegime ∧ framework.finiteRangeNuclearPotentialAt framework.neutronProtonTriplet framework.neutronProtonPotential framework.nuclearRegime ∧ framework.waveSolvesRadialEquationAt framework.neutralActualWave framework.neutronProtonTriplet framework.neutronProtonPotential framework.selectedLowEnergy framework.nuclearRegime ∧ framework.waveSolvesRadialEquationAt framework.neutralZeroEnergyWave framework.neutronProtonTriplet framework.neutronProtonPotential framework.zeroEnergy framework.nuclearRegime ∧ framework.comparisonWaveMatchesOutsideForceRangeAt framework.neutralActualWave framework.neutralComparisonWave framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.comparisonWaveMatchesOutsideForceRangeAt framework.neutralZeroEnergyWave framework.neutralZeroEnergyComparisonWave framework.neutronProtonTriplet framework.zeroEnergy framework.nuclearRegime ∧ framework.waveNormalizedAtOriginAt framework.neutralComparisonWave framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.waveNormalizedAtOriginAt framework.neutralZeroEnergyComparisonWave framework.neutronProtonTriplet framework.zeroEnergy framework.nuclearRegime ∧ framework.neutralRadialData.SourceEquationsAt /-- The zero-energy comparison function is linear with the inverse scattering length as minus its origin slope. It is not the regular interior wave. -/ def ZeroEnergyComparisonWaveFormulaAt (framework : EffectiveRangeFramework T) : Prop := ∀ radius : Real, framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave radius = 1 - framework.reciprocalScatteringLength framework.neutronProtonTriplet * radius def NeutralRadialCalculationInputs (framework : EffectiveRangeFramework T) : Prop := framework.EquationSevenComparisonWaveFormulaAt ∧ framework.ZeroEnergyComparisonWaveFormulaAt ∧ framework.EquationElevenZeroEnergyScatteringLengthFormulaAt ∧ framework.EquationThirteenEnergyDependentRangeIntegralFormulaAt ∧ framework.EquationFourteenEffectiveRangeIntegralFormulaAt ∧ framework.waveNumberSquared framework.zeroEnergy = 0 ∧ framework.neutralRadialData.WronskianIntegralIdentitiesAt ∧ framework.neutralRadialData.AsymptoticComparisonAt /-- The exact finite-radius identities and boundary limit are imported analytic outputs. The desired infinite-radius comparison (10) is derived. -/ def NeutralRadialFormulaCalculation (framework : EffectiveRangeFramework T) : Prop := framework.NeutralComparisonSetup → framework.NeutralRadialCalculationInputs /-- Equation (7) really performs the advertised normalization: the selected comparison wave evaluates to one at r = 0 when sin(delta) is nonzero. -/ theorem equation_seven_normalizes_comparison_wave_at_origin (framework : EffectiveRangeFramework T) (formula : framework.EquationSevenComparisonWaveFormulaAt) : framework.radialWaveValueAt framework.neutralComparisonWave 0 = 1 := by rcases formula with ⟨_waveNumberSquare, phaseNonzero, waveFormula, _phaseFunctionFormula⟩ rw [waveFormula 0] simp [phaseNonzero] /-- The derivative readout following equation (7) is not hidden in a field name: the selected phase function is explicitly the same k cot(delta) built from the comparison-wave k and delta. -/ theorem equation_seven_retains_k_cotangent_phase_function (framework : EffectiveRangeFramework T) (formula : framework.EquationSevenComparisonWaveFormulaAt) : framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy = framework.waveNumberValue framework.selectedLowEnergy * (Real.cos (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy) / Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)) := formula.2.2.2 theorem equation_seven_gives_the_actual_comparison_origin_derivative (framework : EffectiveRangeFramework T) (formula : framework.EquationSevenComparisonWaveFormulaAt) : framework.neutralRadialData.phase 1 = framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy := by rcases formula with ⟨_square, _sineNonzero, waves, phase⟩ have derivative : HasDerivAt (fun radius : Real => Real.sin (framework.waveNumberValue framework.selectedLowEnergy * radius + framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy) / Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)) (framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy) 0 := by have derived := ((((hasDerivAt_id (0 : Real)).const_mul (framework.waveNumberValue framework.selectedLowEnergy)).add_const (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)).sin).div_const (Real.sin (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedLowEnergy)) convert derived using 1 rw [phase] simp only [id_eq, mul_zero, zero_add, mul_one] ring have actualDerivative : HasDerivWithinAt (framework.radialWaveValueAt framework.neutralComparisonWave) (framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy) (Ici 0) 0 := by rw [funext waves] exact derivative.hasDerivWithinAt simpa [RadialComparison.Data.phase, RadialComparison.radialDerivative, neutralRadialData] using actualDerivative.derivWithin (uniqueDiffWithinAt_Ici 0) theorem the_zero_energy_comparison_has_the_actual_scattering_length_slope (framework : EffectiveRangeFramework T) (wave : framework.ZeroEnergyComparisonWaveFormulaAt) (phase : framework.EquationElevenZeroEnergyScatteringLengthFormulaAt) : framework.neutralRadialData.phase 0 = framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.zeroEnergy := by have derivative := (hasDerivAt_const (0 : Real) (1 : Real)).sub ((hasDerivAt_id (0 : Real)).const_mul (framework.reciprocalScatteringLength framework.neutronProtonTriplet)) have actualDerivative : HasDerivWithinAt (framework.radialWaveValueAt framework.neutralZeroEnergyComparisonWave) (-framework.reciprocalScatteringLength framework.neutronProtonTriplet) (Ici 0) 0 := by rw [funext wave] simpa using derivative.hasDerivWithinAt rw [phase] simpa [RadialComparison.Data.phase, RadialComparison.radialDerivative, neutralRadialData] using actualDerivative.derivWithin (uniqueDiffWithinAt_Ici 0) theorem lower_radial_inputs_derive_the_infinite_comparison_identity (framework : EffectiveRangeFramework T) (setup : framework.NeutralComparisonSetup) (inputs : framework.NeutralRadialCalculationInputs) : framework.EquationTenNeutralComparisonFormulaAt := by rcases setup with ⟨_channel, _range, _actual, _zero, _matching, _zeroMatching, _normalized, _zeroNormalized, equations⟩ rcases inputs with ⟨seven, zeroWave, eleven, _thirteen, _fourteen, _zeroSquare, identities, asymptotic⟩ have identity := framework.neutralRadialData.the_actual_boundary_limit_yields_bethes_comparison_identity equations identities asymptotic rw [framework.equation_seven_gives_the_actual_comparison_origin_derivative seven, framework.the_zero_energy_comparison_has_the_actual_scattering_length_slope zeroWave eleven] at identity simpa [EquationTenNeutralComparisonFormulaAt, RadialComparison.Data.waveSquareDifference, RadialComparison.Data.overlapIntegral, RadialComparison.Data.overlap, neutralRadialData, radialIntegralValueAt] using identity theorem lower_radial_inputs_derive_the_source_formula_readout (framework : EffectiveRangeFramework T) (setup : framework.NeutralComparisonSetup) (inputs : framework.NeutralRadialCalculationInputs) : framework.NeutralRadialFormulaReadoutAt := ⟨inputs.1, framework.lower_radial_inputs_derive_the_infinite_comparison_identity setup inputs, inputs.2.2.1, inputs.2.2.2.1, inputs.2.2.2.2.1, inputs.2.2.2.2.2.1⟩ /-- Equations (10), (11), and (13), together with k1 = 0, algebraically give equation (12). The effective-range replacement in equation (14) is not used yet; it remains a later controlled approximation. -/ theorem equations_ten_eleven_and_thirteen_yield_zero_energy_relation (framework : EffectiveRangeFramework T) (readout : framework.NeutralRadialFormulaReadoutAt) : framework.NeutralZeroEnergyRelationAt framework.neutronProtonTriplet framework.selectedLowEnergy := by rcases readout with ⟨_equationSeven, equationTen, equationEleven, equationThirteen, _equationFourteen, zeroWaveNumberSquared⟩ unfold NeutralZeroEnergyRelationAt unfold EquationTenNeutralComparisonFormulaAt at equationTen unfold EquationElevenZeroEnergyScatteringLengthFormulaAt at equationEleven unfold EquationThirteenEnergyDependentRangeIntegralFormulaAt at equationThirteen rw [equationEleven, zeroWaveNumberSquared] at equationTen rw [← equationThirteen.2] at equationTen nlinarith def NeutralComparisonValueRepresentationAt (framework : EffectiveRangeFramework T) : Prop := framework.neutralBoundaryDifference framework.neutronProtonTriplet framework.zeroEnergy framework.selectedLowEnergy = framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy - framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.zeroEnergy ∧ framework.neutralWaveNumberDifference framework.zeroEnergy framework.selectedLowEnergy = framework.waveNumberSquared framework.selectedLowEnergy - framework.waveNumberSquared framework.zeroEnergy ∧ framework.neutralOverlapIntegral framework.neutronProtonTriplet framework.zeroEnergy framework.selectedLowEnergy = framework.neutralRadialData.overlapIntegral def NeutralComparisonCalculation (framework : EffectiveRangeFramework T) : Prop := framework.NeutralComparisonSetup → framework.NeutralComparisonValueRepresentationAt def EstablishedNeutralComparison (framework : EffectiveRangeFramework T) : Prop := framework.NeutralComparisonSetup ∧ framework.ExactNeutralComparisonIdentityAt framework.neutronProtonTriplet framework.zeroEnergy framework.selectedLowEnergy ∧ framework.NeutralZeroEnergyRelationAt framework.neutronProtonTriplet framework.selectedLowEnergy ∧ framework.NeutralRadialFormulaReadoutAt theorem radial_comparison_and_formula_readout_yield_exact_neutral_identity (framework : EffectiveRangeFramework T) (setup : framework.NeutralComparisonSetup) (calculation : framework.NeutralComparisonCalculation) (formulaReadout : framework.NeutralRadialFormulaReadoutAt) : framework.EstablishedNeutralComparison := by have representation := calculation setup have identity : framework.ExactNeutralComparisonIdentityAt framework.neutronProtonTriplet framework.zeroEnergy framework.selectedLowEnergy := by unfold ExactNeutralComparisonIdentityAt rw [representation.1, representation.2.1, representation.2.2] simpa [EquationTenNeutralComparisonFormulaAt, RadialComparison.Data.overlapIntegral, RadialComparison.Data.overlap, neutralRadialData, radialIntegralValueAt] using formulaReadout.2.1 exact ⟨setup, identity, framework.equations_ten_eleven_and_thirteen_yield_zero_energy_relation formulaReadout, formulaReadout⟩ theorem radial_comparison_yields_exact_neutral_identity (framework : EffectiveRangeFramework T) (setup : framework.NeutralComparisonSetup) (calculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) : framework.EstablishedNeutralComparison := framework.radial_comparison_and_formula_readout_yield_exact_neutral_identity setup calculation (framework.lower_radial_inputs_derive_the_source_formula_readout setup (formulaCalculation setup)) def EffectiveRangeApproximationSetup (framework : EffectiveRangeFramework T) : Prop := framework.lowEnergyRelativeToForceRangeAt framework.selectedLowEnergy framework.neutronProtonPotential framework.nuclearRegime def EffectiveRangeReferenceCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralComparison → framework.EffectiveRangeApproximationSetup → framework.neutralRadialData.InteriorReplacementAt (framework.rangeReplacementToleranceAt framework.nuclearRegime) def EffectiveRangeRouteCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EffectiveRangeReferenceCalculation theorem the_actual_interior_integral_control_derives_the_range_replacement (framework : EffectiveRangeFramework T) (neutral : framework.EstablishedNeutralComparison) (control : framework.neutralRadialData.InteriorReplacementAt (framework.rangeReplacementToleranceAt framework.nuclearRegime)) : framework.zeroEnergyInteriorReplacementControlledAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime := by have thirteen := neutral.2.2.2.2.2.2.1 have fourteen := neutral.2.2.2.2.2.2.2.1 apply RadialComparison.Approximation.the_actual_integral_error_bounds_the_range_replacement framework.neutralRadialData _ _ _ thirteen.1 · simpa [RadialComparison.Data.zeroOverlap, neutralRadialData] using fourteen.1 · simpa [RadialComparison.Data.overlapIntegral, RadialComparison.Data.overlap, neutralRadialData, radialIntegralValueAt, div_eq_mul_inv, mul_comm] using thirteen.2 · simpa [RadialComparison.Data.zeroOverlap, neutralRadialData, radialIntegralValueAt, div_eq_mul_inv, mul_comm] using fourteen.2 · exact control theorem the_exact_neutral_comparison_and_controlled_replacement_bound_the_phase_error (framework : EffectiveRangeFramework T) (neutral : framework.EstablishedNeutralComparison) (replacement : framework.zeroEnergyInteriorReplacementControlledAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime) : framework.NeutralEffectiveRangeLawAt framework.neutronProtonTriplet framework.selectedLowEnergy := by have comparison : RadialComparison.Approximation.ExactComparisonAt (framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy) (framework.reciprocalScatteringLength framework.neutronProtonTriplet) (framework.energyDependentRangeValue framework.neutronProtonTriplet framework.selectedLowEnergy) (framework.waveNumberSquared framework.selectedLowEnergy) := by have exactRelation := neutral.2.2.1 dsimp [NeutralZeroEnergyRelationAt, RadialComparison.Approximation.ExactComparisonAt] at * nlinarith exact RadialComparison.Approximation.controlled_range_replacement_gives_a_phase_error_bound _ _ _ _ _ _ comparison replacement def EffectiveRangeIdentificationBridge (framework : EffectiveRangeFramework T) : Prop := framework.NeutralEffectiveRangeLawAt framework.neutronProtonTriplet framework.selectedLowEnergy → framework.phaseFunctionMatchesEffectiveRangeLawAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime def EstablishedNeutralEffectiveRangeLaw (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralComparison ∧ framework.EffectiveRangeApproximationSetup ∧ framework.zeroEnergyInteriorReplacementControlledAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.NeutralEffectiveRangeLawAt framework.neutronProtonTriplet framework.selectedLowEnergy ∧ framework.phaseFunctionMatchesEffectiveRangeLawAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime theorem controlled_zero_energy_replacement_yields_effective_range_law (framework : EffectiveRangeFramework T) (neutral : framework.EstablishedNeutralComparison) (setup : framework.EffectiveRangeApproximationSetup) (calculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) : framework.EstablishedNeutralEffectiveRangeLaw := by have replacement := framework.the_actual_interior_integral_control_derives_the_range_replacement neutral (calculation neutral setup) have law := framework.the_exact_neutral_comparison_and_controlled_replacement_bound_the_phase_error neutral replacement exact ⟨neutral, setup, replacement, law, identification law⟩ theorem the_effective_range_output_is_a_controlled_observable_approximation (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (positive : 0 < framework.waveNumberSquared framework.selectedLowEnergy) : RadialComparison.Observation.phaseContext.ControlledApproximation (framework.twoParameterPhaseValueAt framework.neutronProtonTriplet framework.selectedLowEnergy) (framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy) (framework.waveNumberSquared framework.selectedLowEnergy) (fun _ => True) (|framework.waveNumberSquared framework.selectedLowEnergy| * framework.rangeReplacementToleranceAt framework.nuclearRegime) := RadialComparison.Observation.the_phase_error_is_a_controlled_observable_approximation _ _ _ _ _ positive law.2.2.2.1 theorem the_selected_phase_error_is_quartic_under_quadratic_replacement_control (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (coefficient : Real) (quadratic : framework.rangeReplacementToleranceAt framework.nuclearRegime <= coefficient * framework.waveNumberValue framework.selectedLowEnergy ^ 2) : |framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedLowEnergy - framework.twoParameterPhaseValueAt framework.neutronProtonTriplet framework.selectedLowEnergy| <= coefficient * framework.waveNumberValue framework.selectedLowEnergy ^ 4 := by have bound := law.2.2.2.1.2 have square := law.1.2.2.2.1.1 have waveSquareNorm : |framework.waveNumberSquared framework.selectedLowEnergy| = framework.waveNumberValue framework.selectedLowEnergy ^ 2 := by rw [square, abs_of_nonneg (sq_nonneg _)] rw [waveSquareNorm] at bound calc _ <= framework.waveNumberValue framework.selectedLowEnergy ^ 2 * framework.rangeReplacementToleranceAt framework.nuclearRegime := bound _ <= framework.waveNumberValue framework.selectedLowEnergy ^ 2 * (coefficient * framework.waveNumberValue framework.selectedLowEnergy ^ 2) := mul_le_mul_of_nonneg_left quadratic (sq_nonneg _) _ = _ := by ring /-! ## Equation (17): selected-energy wave number and physical phase shift -/ /-- Equation (7)'s `k` and `delta` must be read at the actual selected cross-section energy; the earlier low-energy comparison does not transport those value identities to a distinct energy index. -/ def NeutralWaveNumberAndPhaseShiftReadoutAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.waveNumberSquared energy = framework.waveNumberValue energy ^ 2 ∧ Real.sin (framework.neutralPhaseShiftValue channel energy) ≠ 0 ∧ framework.neutralPhaseFunctionValue channel energy = framework.waveNumberValue energy * (Real.cos (framework.neutralPhaseShiftValue channel energy) / Real.sin (framework.neutralPhaseShiftValue channel energy)) def NeutralCrossSectionSetup (framework : EffectiveRangeFramework T) : Prop := framework.energyInNeutralScatteringScopeAt framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ 0 < framework.waveNumberSquared framework.selectedCrossSectionEnergy ∧ framework.NeutralWaveNumberAndPhaseShiftReadoutAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy /-- The numerical S-wave unitarity claim on the selected physical energy: the observable cross section is positive and at most `4 pi / k^2`. -/ def NeutralUnitarityBoundValueAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := 0 < framework.neutralCrossSectionValue channel energy ∧ framework.neutralCrossSectionValue channel energy ≤ (4 * Real.pi) / framework.waveNumberSquared energy /-- Bethe's stated maximum is an equality of physical cross-section values, not merely a proposition named for a maximum. -/ def NeutralUnitarityMaximumValueAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.neutralCrossSectionValue channel energy = (4 * Real.pi) / framework.waveNumberSquared energy /-- The permitted S-wave maximum is attained exactly when the selected numerical phase function is zero. -/ def NeutralUnitaritySaturationCharacterizationAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.NeutralUnitarityMaximumValueAt channel energy ↔ framework.neutralPhaseFunctionValue channel energy = 0 /-- Bethe's first displayed equation-(17) form reads the physical selected phase shift directly: `sigma = 4 pi sin(delta)^2 / k^2`. -/ def EquationSeventeenSineSquaredCrossSectionFormulaAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.neutralCrossSectionValue channel energy = (4 * Real.pi * Real.sin (framework.neutralPhaseShiftValue channel energy) ^ 2) / framework.waveNumberSquared energy /-- Physical Review p. 40, equation (17): the neutral S-wave cross section is `4 pi / (k^2 + (k cot delta)^2)`. The formula uses the paper's already typed phase-function value and does not silently transport the selected low-energy effective-range law to a different energy index. -/ def EquationSeventeenCrossSectionFormulaAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := framework.neutralCrossSectionValue channel energy = (4 * Real.pi) / (framework.waveNumberSquared energy + framework.neutralPhaseFunctionValue channel energy ^ 2) /-- The two forms printed together in Bethe's equation (17) agree only when the squared wave number and `k cot delta` are tied to the same selected physical `k` and phase shift. -/ theorem equation_seventeen_coherent_phase_readout_yields_sine_squared_formula (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (readout : framework.NeutralWaveNumberAndPhaseShiftReadoutAt channel energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) : framework.EquationSeventeenSineSquaredCrossSectionFormulaAt channel energy := by rcases readout with ⟨waveSquare, sineNonzero, phaseReadout⟩ have waveNonzero : framework.waveNumberValue energy ≠ 0 := by intro zeroWave rw [waveSquare, zeroWave] at waveNumberPositive norm_num at waveNumberPositive change framework.neutralCrossSectionValue channel energy = (4 * Real.pi * Real.sin (framework.neutralPhaseShiftValue channel energy) ^ 2) / framework.waveNumberSquared energy rw [formula, waveSquare, phaseReadout] have trigIdentity := Real.sin_sq_add_cos_sq (framework.neutralPhaseShiftValue channel energy) field_simp nlinarith /-- On the selected nonzero wave and nonvanishing-sine domain, the physical phase function vanishes exactly when the phase-shift cosine is zero. -/ theorem coherent_phase_function_vanishes_iff_phase_shift_cosine_vanishes (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (readout : framework.NeutralWaveNumberAndPhaseShiftReadoutAt channel energy) : framework.neutralPhaseFunctionValue channel energy = 0 ↔ Real.cos (framework.neutralPhaseShiftValue channel energy) = 0 := by rcases readout with ⟨waveSquare, sineNonzero, phaseReadout⟩ have waveNonzero : framework.waveNumberValue energy ≠ 0 := by intro zeroWave rw [waveSquare, zeroWave] at waveNumberPositive norm_num at waveNumberPositive rw [phaseReadout] constructor · intro zeroPhase have zeroCotangent := (mul_eq_zero.1 zeroPhase).resolve_left waveNonzero exact (div_eq_zero_iff.1 zeroCotangent).resolve_right sineNonzero · intro zeroCosine simp [zeroCosine] def NeutralCrossSectionCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralEffectiveRangeLaw → framework.NeutralCrossSectionSetup → framework.neutralCrossSectionCalculatedAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.EquationSeventeenCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.neutralPhaseFunctionVanishingAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedCrossSectionEnergy = 0 ∧ framework.neutralCrossSectionSatisfiesUnitarityBoundAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.neutralCrossSectionMaximalAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime /-- With positive selected `k^2`, the printed equation (17) itself yields a positive cross section and the S-wave unitarity bound. -/ theorem equation_seventeen_at_positive_wave_number_implies_unitarity_bound (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) : framework.NeutralUnitarityBoundValueAt channel energy := by have numeratorPositive : 0 < 4 * Real.pi := mul_pos (by norm_num) Real.pi_pos have denominatorPositive : 0 < framework.waveNumberSquared energy + framework.neutralPhaseFunctionValue channel energy ^ 2 := by nlinarith [sq_nonneg (framework.neutralPhaseFunctionValue channel energy)] constructor · rw [formula] exact div_pos numeratorPositive denominatorPositive · rw [formula] apply (div_le_div_iff₀ denominatorPositive waveNumberPositive).2 have phaseSquareNonnegative := sq_nonneg (framework.neutralPhaseFunctionValue channel energy) exact mul_le_mul_of_nonneg_left (by linarith) numeratorPositive.le /-- The permitted S-wave maximum is attained only after the named vanishing phase is tied to the actual zero value in Bethe's displayed formula. -/ theorem equation_seventeen_and_zero_phase_saturate_unitarity_maximum (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) (phaseVanishes : framework.neutralPhaseFunctionValue channel energy = 0) : framework.NeutralUnitarityMaximumValueAt channel energy := by simpa [EquationSeventeenCrossSectionFormulaAt, NeutralUnitarityMaximumValueAt, phaseVanishes] using formula /-- At physical positive `k^2`, equation (17) reaches its permitted maximum if and only if the actual phase function vanishes. -/ theorem equation_seventeen_saturates_unitarity_maximum_iff_phase_vanishes (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) : framework.NeutralUnitaritySaturationCharacterizationAt channel energy := by constructor · intro maximum have numeratorNonzero : 4 * Real.pi ≠ 0 := ne_of_gt (mul_pos (by norm_num) Real.pi_pos) have denominatorPositive : 0 < framework.waveNumberSquared energy + framework.neutralPhaseFunctionValue channel energy ^ 2 := by nlinarith [sq_nonneg (framework.neutralPhaseFunctionValue channel energy)] have quotientEquality : (4 * Real.pi) / (framework.waveNumberSquared energy + framework.neutralPhaseFunctionValue channel energy ^ 2) = (4 * Real.pi) / framework.waveNumberSquared energy := by rw [← formula] exact maximum have crossMultiplied := (div_eq_div_iff (ne_of_gt denominatorPositive) (ne_of_gt waveNumberPositive)).1 quotientEquality have denominatorsEqual := mul_left_cancel₀ numeratorNonzero crossMultiplied have phaseSquareZero : framework.neutralPhaseFunctionValue channel energy ^ 2 = 0 := by linarith exact (sq_eq_zero_iff).1 phaseSquareZero · exact framework.equation_seventeen_and_zero_phase_saturate_unitarity_maximum channel energy formula /-- In Bethe's actual phase-shift variables, saturation of the S-wave bound is equivalent to `cos delta = 0`, not merely to a freely assigned scalar named for the phase function. -/ theorem equation_seventeen_saturates_unitarity_maximum_iff_phase_shift_cosine_vanishes (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (readout : framework.NeutralWaveNumberAndPhaseShiftReadoutAt channel energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) : framework.NeutralUnitarityMaximumValueAt channel energy ↔ Real.cos (framework.neutralPhaseShiftValue channel energy) = 0 := (framework.equation_seventeen_saturates_unitarity_maximum_iff_phase_vanishes channel energy waveNumberPositive formula).trans (framework.coherent_phase_function_vanishes_iff_phase_shift_cosine_vanishes channel energy waveNumberPositive readout) /-- Every genuinely nonzero selected phase suppresses the S-wave cross section strictly below the permitted unitarity maximum. -/ theorem equation_seventeen_nonzero_phase_is_strictly_below_unitarity_maximum (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (waveNumberPositive : 0 < framework.waveNumberSquared energy) (formula : framework.EquationSeventeenCrossSectionFormulaAt channel energy) (phaseNonzero : framework.neutralPhaseFunctionValue channel energy ≠ 0) : framework.neutralCrossSectionValue channel energy < (4 * Real.pi) / framework.waveNumberSquared energy := by have bound := (framework.equation_seventeen_at_positive_wave_number_implies_unitarity_bound channel energy waveNumberPositive formula).2 apply lt_of_le_of_ne bound intro saturation apply phaseNonzero exact (framework.equation_seventeen_saturates_unitarity_maximum_iff_phase_vanishes channel energy waveNumberPositive formula).1 saturation def NeutralCrossSectionTruncationInterpretation (framework : EffectiveRangeFramework T) : Prop := framework.neutralCrossSectionMaximalAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime → framework.nextCrossSectionTermRequiredForUnitarityNearMaximumAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime def EstablishedNeutralCrossSectionAssessment (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralEffectiveRangeLaw ∧ framework.NeutralCrossSectionSetup ∧ framework.neutralCrossSectionCalculatedAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.EquationSeventeenCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.neutralPhaseFunctionVanishingAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.neutralPhaseFunctionValue framework.neutronProtonTriplet framework.selectedCrossSectionEnergy = 0 ∧ framework.neutralCrossSectionSatisfiesUnitarityBoundAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.neutralCrossSectionMaximalAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.nextCrossSectionTermRequiredForUnitarityNearMaximumAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy framework.nuclearRegime ∧ framework.NeutralUnitarityBoundValueAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.NeutralUnitarityMaximumValueAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.NeutralUnitaritySaturationCharacterizationAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.EquationSeventeenSineSquaredCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy /-- Physical Review p. 40, equations (17)-(18): inserting the phase law into the S-wave cross section retains the unitarity bound and its maximum. Bethe's warning that the next term is needed near that maximum is kept separately from the two-parameter phase law itself. -/ theorem effective_range_phase_law_yields_unitarity_scoped_cross_section (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.NeutralCrossSectionSetup) (calculation : framework.NeutralCrossSectionCalculation) (interpretation : framework.NeutralCrossSectionTruncationInterpretation) : framework.EstablishedNeutralCrossSectionAssessment := by have calculated := calculation law setup have numericalBound := framework.equation_seventeen_at_positive_wave_number_implies_unitarity_bound framework.neutronProtonTriplet framework.selectedCrossSectionEnergy setup.2.1 calculated.2.1 have numericalMaximum := framework.equation_seventeen_and_zero_phase_saturate_unitarity_maximum framework.neutronProtonTriplet framework.selectedCrossSectionEnergy calculated.2.1 calculated.2.2.2.1 have saturationCharacterization := framework.equation_seventeen_saturates_unitarity_maximum_iff_phase_vanishes framework.neutronProtonTriplet framework.selectedCrossSectionEnergy setup.2.1 calculated.2.1 have sineSquaredFormula := framework.equation_seventeen_coherent_phase_readout_yields_sine_squared_formula framework.neutronProtonTriplet framework.selectedCrossSectionEnergy setup.2.1 setup.2.2 calculated.2.1 exact ⟨law, setup, calculated.1, calculated.2.1, calculated.2.2.1, calculated.2.2.2.1, calculated.2.2.2.2.1, calculated.2.2.2.2.2, interpretation calculated.2.2.2.2.2, numericalBound, numericalMaximum, saturationCharacterization, sineSquaredFormula⟩ /-- The assessed observable branch retains Bethe's literal equation-(17) cross-section formula instead of only a named calculation predicate. -/ theorem established_neutral_cross_section_retains_equation_seventeen_formula (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.EquationSeventeenCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy := established.2.2.2.1 /-- The established observable consequence contains the derived positive unitarity bound and its actual vanishing-phase saturation. -/ theorem established_neutral_cross_section_retains_numerical_bound_and_maximum (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.NeutralUnitarityBoundValueAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.NeutralUnitarityMaximumValueAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy := by rcases established with ⟨_law, _setup, _calculated, _formula, _vanishing, _phaseZero, _bounded, _maximal, _nextTerm, numericalBound, numericalMaximum, _saturationCharacterization, _sineSquaredFormula⟩ exact ⟨numericalBound, numericalMaximum⟩ /-- The original observable conclusion retains the full numerical characterization: saturation is equivalent to vanishing physical phase. -/ theorem established_neutral_cross_section_characterizes_saturation_by_zero_phase (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.NeutralUnitaritySaturationCharacterizationAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy := by rcases established with ⟨_law, _setup, _calculated, _formula, _vanishing, _phaseZero, _bounded, _maximal, _nextTerm, _numericalBound, _numericalMaximum, saturationCharacterization, _sineSquaredFormula⟩ exact saturationCharacterization /-- The selected observable route retains both equalities actually printed in equation (17), with the same physical wave number and phase shift. -/ theorem established_neutral_cross_section_retains_both_equation_seventeen_forms (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.EquationSeventeenCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ∧ framework.EquationSeventeenSineSquaredCrossSectionFormulaAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy := by rcases established with ⟨_law, _setup, _calculated, formula, _vanishing, _phaseZero, _bounded, _maximal, _nextTerm, _numericalBound, _numericalMaximum, _saturationCharacterization, sineSquaredFormula⟩ exact ⟨formula, sineSquaredFormula⟩ /-- The established maximum is characterized by the selected physical phase shift itself rather than only by an independently named scalar. -/ theorem established_neutral_cross_section_characterizes_physical_phase_shift_maximum (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.NeutralUnitarityMaximumValueAt framework.neutronProtonTriplet framework.selectedCrossSectionEnergy ↔ Real.cos (framework.neutralPhaseShiftValue framework.neutronProtonTriplet framework.selectedCrossSectionEnergy) = 0 := by have selectedSetup := established.2.1 have formula := framework.established_neutral_cross_section_retains_equation_seventeen_formula established exact framework.equation_seventeen_saturates_unitarity_maximum_iff_phase_shift_cosine_vanishes framework.neutronProtonTriplet framework.selectedCrossSectionEnergy selectedSetup.2.1 selectedSetup.2.2 formula theorem established_neutral_cross_section_assessment_exposes_complete_route (framework : EffectiveRangeFramework T) (established : framework.EstablishedNeutralCrossSectionAssessment) : framework.NeutralCrossSectionCalculation ∧ framework.NeutralCrossSectionTruncationInterpretation := by rcases established with ⟨law, setup, calculated, formula, vanishing, phaseZero, bounded, maximal, nextTerm, _numericalBound, _numericalMaximum, _saturationCharacterization, _sineSquaredFormula⟩ exact ⟨fun _law _setup => ⟨calculated, formula, vanishing, phaseZero, bounded, maximal⟩, fun _maximal => nextTerm⟩ def HigherOrderCorrectionCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralEffectiveRangeLaw → framework.higherOrderShapeExpansionCalculatedAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.shapeCoefficientSmallAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.effectiveRangeApproximationAccurateAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime /-- Physical Review p. 43: the sign of a resolved deviation has a directional meaning. Upward curvature would favor a concentrated potential; downward curvature would favor a long-tailed potential. Bethe then says that the available data do not make either deviation significant. -/ def CurvatureDiagnosticScope (framework : EffectiveRangeFramework T) : Prop := framework.upwardCurvatureWouldIndicateConcentratedPotentialAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ framework.downwardCurvatureWouldIndicateLongTailedPotentialAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ ¬framework.curvatureDeviationSignificantAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime def CurvatureDiagnosticInterpretation (framework : EffectiveRangeFramework T) : Prop := framework.higherOrderShapeExpansionCalculatedAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime → framework.CurvatureDiagnosticScope def ShapeSensitivityInterpretation (framework : EffectiveRangeFramework T) : Prop := framework.higherOrderShapeExpansionCalculatedAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime → framework.resolvedCurvatureWouldDiscriminatePotentialTailAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ ¬framework.potentialShapeResolvedByPhaseDataAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ framework.squareWellWouldRequireDifferentIntrinsicRangesAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.longTailedPotentialAllowsCommonIntrinsicRangeAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ ¬framework.singleChannelEnergyDependenceDeterminesPotentialShapeAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime def EstablishedAccuracyAndShapeScope (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralEffectiveRangeLaw ∧ framework.higherOrderShapeExpansionCalculatedAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.shapeCoefficientSmallAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.effectiveRangeApproximationAccurateAt framework.neutronProtonTriplet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.CurvatureDiagnosticScope ∧ framework.resolvedCurvatureWouldDiscriminatePotentialTailAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ ¬framework.potentialShapeResolvedByPhaseDataAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime ∧ framework.squareWellWouldRequireDifferentIntrinsicRangesAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.longTailedPotentialAllowsCommonIntrinsicRangeAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ ¬framework.singleChannelEnergyDependenceDeterminesPotentialShapeAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime theorem small_shape_correction_supports_accuracy_not_shape_determination (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (calculation : framework.HigherOrderCorrectionCalculation) (diagnostic : framework.CurvatureDiagnosticInterpretation) (interpretation : framework.ShapeSensitivityInterpretation) : framework.EstablishedAccuracyAndShapeScope := by have correction := calculation law have curvatureScope := diagnostic correction.1 have scope := interpretation correction.1 exact ⟨law, correction.1, correction.2.1, correction.2.2, curvatureScope, scope.1, scope.2.1, scope.2.2.1, scope.2.2.2.1, scope.2.2.2.2⟩ /-- The accuracy assessment retains Bethe's sign-sensitive diagnostic together with his statement that the measured phase-shift curvature is not yet significant. A possible diagnostic is not reported as an observed tail type. -/ theorem accuracy_scope_retains_sign_sensitive_but_unresolved_curvature (framework : EffectiveRangeFramework T) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.CurvatureDiagnosticScope := by rcases accuracy with ⟨_law, _expansion, _small, _accurate, curvatureScope, _discriminator, _unresolved, _squareWell, _longTailed, _singleChannel⟩ exact curvatureScope theorem accuracy_scope_retains_cross_channel_intrinsic_range_distinctions (framework : EffectiveRangeFramework T) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.squareWellWouldRequireDifferentIntrinsicRangesAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.longTailedPotentialAllowsCommonIntrinsicRangeAt framework.neutronProtonTriplet framework.neutronProtonSinglet framework.nuclearRegime ∧ ¬framework.singleChannelEnergyDependenceDeterminesPotentialShapeAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime := by rcases accuracy with ⟨_law, _expansion, _small, _accurate, _curvature, _discriminator, _unresolved, squareWell, longTailed, singleChannel⟩ exact ⟨squareWell, longTailed, singleChannel⟩ /-- Equation (15) is the normalized comparison mode, not the interior solution. -/ noncomputable def boundComparisonWaveValueAt (framework : EffectiveRangeFramework T) (channel : T.Channel) : Real → Real := NeutralBoundState.decayingFactor (framework.bindingWaveNumber channel) /-- Equations (10)-(11), specialized to the negative bound-state wave-number square and the actual derivative of the equation-(15) comparison function. The Wronskian/overlap evaluation remains the explicit source calculation. -/ def BoundStateRadialComparisonAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := 0 < framework.bindingWaveNumber channel ∧ framework.waveNumberSquared energy = -(framework.bindingWaveNumber channel ^ 2) ∧ framework.waveNumberSquared framework.zeroEnergy = 0 ∧ framework.neutralPhaseFunctionValue channel framework.zeroEnergy = -framework.reciprocalScatteringLength channel ∧ deriv (framework.boundComparisonWaveValueAt channel) 0 - framework.neutralPhaseFunctionValue channel framework.zeroEnergy = (framework.waveNumberSquared energy - framework.waveNumberSquared framework.zeroEnergy) * (framework.energyDependentRangeValue channel energy / 2) def boundComparisonMode (framework : EffectiveRangeFramework T) (channel : T.Channel) : NeutralBoundState.RadialMode where inverseLength := framework.bindingWaveNumber channel decayingAmplitude := 1 growingAmplitude := 0 theorem bound_radial_comparison_has_nonvacuous_decaying_mode (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (radial : framework.BoundStateRadialComparisonAt channel energy) : (framework.boundComparisonMode channel).NonvacuousBoundMode := (framework.boundComparisonMode channel).no_growing_component_realizes_bound_mode radial.1 (by exact one_ne_zero) rfl theorem bound_comparison_retains_normalization_and_actual_origin_derivative (framework : EffectiveRangeFramework T) (channel : T.Channel) : framework.boundComparisonWaveValueAt channel 0 = 1 ∧ deriv (framework.boundComparisonWaveValueAt channel) 0 = -framework.bindingWaveNumber channel := NeutralBoundState.decaying_factor_origin_data _ theorem bound_radial_comparison_has_negative_wave_number_square (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (radial : framework.BoundStateRadialComparisonAt channel energy) : framework.waveNumberSquared energy < 0 := by rw [radial.2.1] exact neg_neg_of_pos (sq_pos_of_pos radial.1) /-- Physical Review p. 40, Eq. (19), first equality: after selecting the deuteron bound state, the reciprocal triplet scattering length `alpha` equals `gamma - (1 / 2) gamma^2 rho(0, -epsilon)`. The later replacement of the energy-dependent range by `r0` remains a separate controlled approximation. -/ def tripletBoundStateRelationCalculatedAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) : Prop := framework.deuteronBoundStateAt channel energy regime ∧ framework.reciprocalScatteringLength channel = framework.bindingWaveNumber channel - (1 / 2 : Real) * framework.bindingWaveNumber channel ^ 2 * framework.energyDependentRangeValue channel energy theorem bound_comparison_identity_derives_equation_nineteen (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) (bound : framework.deuteronBoundStateAt channel energy regime) (radial : framework.BoundStateRadialComparisonAt channel energy) : framework.tripletBoundStateRelationCalculatedAt channel energy regime := by have identity := radial.2.2.2.2 rw [(framework.bound_comparison_retains_normalization_and_actual_origin_derivative channel).2, radial.2.1, radial.2.2.1, radial.2.2.2.1] at identity refine ⟨bound, ?_⟩ nlinarith [identity] theorem equation_nineteen_exposes_the_range_replacement_residual (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) (relation : framework.tripletBoundStateRelationCalculatedAt channel energy regime) : NeutralBoundState.effectiveRangeResidual (framework.reciprocalScatteringLength channel) (framework.effectiveRangeValue channel) (framework.bindingWaveNumber channel) = framework.bindingWaveNumber channel ^ 2 / 2 * (framework.energyDependentRangeValue channel energy - framework.effectiveRangeValue channel) := by apply NeutralBoundState.exact_range_replacement_has_explicit_residual nlinarith [relation.2] /-- Bethe's second form of Eq. (19) follows algebraically only after an explicit replacement of the bound-energy range function by the effective range. This theorem does not establish that approximation; it exposes exactly what it would license. -/ theorem equation_nineteen_range_replacement_yields_effective_range_form (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) (relation : framework.tripletBoundStateRelationCalculatedAt channel energy regime) (replacement : framework.energyDependentRangeValue channel energy = framework.effectiveRangeValue channel) : framework.reciprocalScatteringLength channel = framework.bindingWaveNumber channel * (1 - (1 / 2 : Real) * framework.bindingWaveNumber channel * framework.effectiveRangeValue channel) := by rw [relation.2, replacement] ring /-- The literal squared records are joined to the paper's equation-(19) calculation through the actual reciprocal triplet length. The coherent sign and the bound-energy-to-zero-energy replacement budget remain explicit. This does not turn the empirical central records into exact measurements. -/ theorem equation_nineteen_and_signed_intensity_bound_the_triplet_range_error (framework : EffectiveRangeFramework T) (lengths : PhysicsLogic.Papers.BlattJackson1949.ThresholdExtraction.Lengths) (budget : Real) (branch : PhysicsLogic.Papers.BlattJackson1949.ThresholdExtraction.PhysicalSignBranch lengths) (negative : PhysicsLogic.Papers.BlattJackson1949.ThresholdExtraction.coherentAmplitude lengths ≤ 0) (lengthIdentification : framework.reciprocalScatteringLength framework.neutronProtonTriplet = lengths.triplet⁻¹) (radial : framework.BoundStateRadialComparisonAt framework.neutronProtonTriplet framework.deuteronBoundEnergy) (relation : framework.tripletBoundStateRelationCalculatedAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime) (replacement : |framework.energyDependentRangeValue framework.neutronProtonTriplet framework.deuteronBoundEnergy - framework.effectiveRangeValue framework.neutronProtonTriplet| ≤ budget) : |NeutralBoundState.extractedRange (IntensityExtraction.negativeBranchTriplet (IntensityExtraction.intensityRecords.recordAt () lengths))⁻¹ (framework.bindingWaveNumber framework.neutronProtonTriplet) - framework.effectiveRangeValue framework.neutronProtonTriplet| ≤ budget := by rw [IntensityExtraction.selected_intensity_recovers_the_bound_energy_range lengths (framework.bindingWaveNumber framework.neutronProtonTriplet) (framework.energyDependentRangeValue framework.neutronProtonTriplet framework.deuteronBoundEnergy) branch negative radial.1 (by rw [← lengthIdentification, relation.2]; ring)] exact replacement def TripletBoundStateSetup (framework : EffectiveRangeFramework T) : Prop := framework.deuteronBoundStateAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.tensorForceExtensionDeferredAt framework.nuclearRegime def TripletEmpiricalExtractionSetup (framework : EffectiveRangeFramework T) : Prop := framework.deuteronBindingDatumMeasuredAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.lowEnergyScatteringDatumMeasuredAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.nuclearRegime def TripletExtractionSetup (framework : EffectiveRangeFramework T) : Prop := framework.TripletBoundStateSetup ∧ framework.TripletEmpiricalExtractionSetup def TripletBoundStateRelationCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralEffectiveRangeLaw → framework.TripletBoundStateSetup → framework.BoundStateRadialComparisonAt framework.neutronProtonTriplet framework.deuteronBoundEnergy ∧ framework.tripletBoundStateRelationControlledAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime def TripletParameterExtractionCalculation (framework : EffectiveRangeFramework T) : Prop := framework.TripletExtractionSetup → framework.tripletBoundStateRelationCalculatedAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime → framework.tripletBoundStateRelationControlledAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime → framework.effectiveRangeExtractedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime ∧ framework.reportedTripletEffectiveRangeQualifiedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime def TripletExtractionCalculation (framework : EffectiveRangeFramework T) : Prop := framework.TripletBoundStateRelationCalculation ∧ framework.TripletParameterExtractionCalculation def SingletRangeDataLimitation (framework : EffectiveRangeFramework T) : Prop := ¬framework.singletRangeAccuratelyDeterminedFromNeutronProtonDataAt framework.neutronProtonExperiment framework.neutronProtonSinglet framework.nuclearRegime def SingletRangeBorrowingBridge (framework : EffectiveRangeFramework T) : Prop := framework.SingletRangeDataLimitation → framework.approximateSingletForceEqualityUsedAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.effectiveRangeBorrowedFromToAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime def SingletRangeAssessment (framework : EffectiveRangeFramework T) : Prop := framework.SingletRangeDataLimitation ∧ framework.approximateSingletForceEqualityUsedAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.effectiveRangeBorrowedFromToAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime theorem limited_neutron_proton_singlet_data_retain_borrowed_range_assumption (framework : EffectiveRangeFramework T) (limitation : framework.SingletRangeDataLimitation) (borrowing : framework.SingletRangeBorrowingBridge) : framework.SingletRangeAssessment := ⟨limitation, borrowing limitation⟩ theorem singlet_range_assessment_retains_force_equality_and_borrowed_range (framework : EffectiveRangeFramework T) (assessment : framework.SingletRangeAssessment) : framework.approximateSingletForceEqualityUsedAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.effectiveRangeBorrowedFromToAt framework.protonProtonSinglet framework.neutronProtonSinglet framework.nuclearRegime := assessment.2 def EstablishedTripletExtraction (framework : EffectiveRangeFramework T) : Prop := framework.TripletExtractionSetup ∧ framework.tripletBoundStateRelationCalculatedAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.tripletBoundStateRelationControlledAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.effectiveRangeExtractedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime ∧ framework.reportedTripletEffectiveRangeQualifiedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime ∧ framework.BoundStateRadialComparisonAt framework.neutronProtonTriplet framework.deuteronBoundEnergy theorem deuteron_and_scattering_data_extract_triplet_effective_range (framework : EffectiveRangeFramework T) (setup : framework.TripletExtractionSetup) (law : framework.EstablishedNeutralEffectiveRangeLaw) (calculation : framework.TripletExtractionCalculation) : framework.EstablishedTripletExtraction := by have radial := calculation.1 law setup.1 have relation := framework.bound_comparison_identity_derives_equation_nineteen _ _ _ setup.1.1 radial.1 rcases calculation.2 setup relation radial.2 with ⟨extraction, qualified⟩ exact ⟨setup, relation, radial.2, extraction, qualified, radial.1⟩ theorem triplet_extraction_retains_actual_bound_state_asymptotics (framework : EffectiveRangeFramework T) (established : framework.EstablishedTripletExtraction) : (framework.boundComparisonMode framework.neutronProtonTriplet).NonvacuousBoundMode ∧ framework.waveNumberSquared framework.deuteronBoundEnergy < 0 := ⟨framework.bound_radial_comparison_has_nonvacuous_decaying_mode _ _ established.2.2.2.2.2, framework.bound_radial_comparison_has_negative_wave_number_square _ _ established.2.2.2.2.2⟩ theorem established_triplet_extraction_exposes_complete_route (framework : EffectiveRangeFramework T) (established : framework.EstablishedTripletExtraction) : framework.TripletExtractionCalculation := by rcases established with ⟨_setup, _relation, controlled, extracted, qualified, radial⟩ exact ⟨fun _law _boundState => ⟨radial, controlled⟩, fun _setup _relation _controlled => ⟨extracted, qualified⟩⟩ /-- Bethe's extracted triplet result retains the bound-state-specific control of equation (19), including the qualified replacement of the range function at the deuteron energy. It is not inferred from positive-energy scattering accuracy. Primary-source anchor: Physical Review pp. 40-41, equations (19) and (27), including the stated shape-dependent correction to the extracted range. -/ theorem established_triplet_extraction_retains_bound_state_relation_control (framework : EffectiveRangeFramework T) (established : framework.EstablishedTripletExtraction) : framework.tripletBoundStateRelationControlledAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime := established.2.2.1 noncomputable def coulombRadialData (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : CoulombComparison.Data where bohrRadius := (framework.coulombProtonParameters channel).bohrRadius momentum := framework.waveNumberValue energy phaseShift := framework.coulombPhaseShiftValue channel energy zeroIntercept := -(framework.coulombProtonParameters channel).bohrRadius * framework.reciprocalScatteringLength channel referenceBasis := framework.coulombReferenceBasis channel energy nuclearPotential := framework.neutralScaledPotentialValueAt framework.protonProtonNuclearPotential actual index := if index = 0 then framework.radialWaveValueAt framework.coulombZeroEnergyWave else framework.radialWaveValueAt framework.coulombActualWave comparison index := if index = 0 then framework.radialWaveValueAt framework.coulombZeroEnergyComparisonWave else framework.radialWaveValueAt framework.coulombComparisonWave noncomputable def coulombModifiedPhaseFunctionValue (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Real := CoulombComparison.modifiedPhase (framework.coulombProtonParameters channel).bohrRadius (framework.waveNumberValue energy) (framework.coulombPhaseShiftValue channel energy) noncomputable def coulombSourceFunctionValue (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Real := CoulombComparison.sourceF (framework.coulombProtonParameters channel).bohrRadius (framework.waveNumberValue energy) (framework.coulombPhaseShiftValue channel energy) def coulombPotentialAddedAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (potential : T.Potential) (regime : T.Regime) : Prop := regime = framework.nuclearRegime ∧ ∀ radius : Real, 0 < radius → framework.neutralScaledPotentialValueAt potential radius = (framework.coulombProtonParameters channel).scaledCoulombPotential radius def protonBohrRadiusLargeComparedWithNuclearRangeAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (regime : T.Regime) : Prop := regime = framework.nuclearRegime ∧ 0 < framework.coulombNuclearRangeValue channel ∧ 0 < framework.coulombHierarchyTolerance channel ∧ framework.coulombHierarchyTolerance channel < 1 ∧ framework.coulombNuclearRangeValue channel ≤ framework.coulombHierarchyTolerance channel * (framework.coulombProtonParameters channel).bohrRadius def coulombInteriorWaveReplacementControlledAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (regime : T.Regime) : Prop := regime = framework.nuclearRegime ∧ (framework.coulombRadialData channel energy).EnergyReplacementAt (framework.coulombEnergyRangeToleranceAt channel energy) def ExactCoulombComparisonIdentityAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (firstEnergy secondEnergy : T.Energy) : Prop := framework.coulombBoundaryDifference channel firstEnergy secondEnergy = framework.coulombWaveNumberDifference firstEnergy secondEnergy * framework.coulombOverlapIntegral channel firstEnergy secondEnergy def CoulombEffectiveRangeLawAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) : Prop := RadialComparison.Approximation.PhaseApproximationAt (framework.coulombModifiedPhaseFunctionValue channel energy) (framework.reciprocalScatteringLength channel) (framework.effectiveRangeValue channel) (framework.waveNumberSquared energy) (framework.coulombEnergyRangeToleranceAt channel energy) def CoulombComparisonSetup (framework : EffectiveRangeFramework T) : Prop := let channel := framework.protonProtonSinglet let data := framework.coulombRadialData channel framework.selectedLowEnergy framework.sWaveChannelAt channel framework.nuclearRegime ∧ framework.finiteRangeNuclearPotentialAt channel framework.protonProtonNuclearPotential framework.nuclearRegime ∧ (framework.coulombProtonParameters channel).PositiveAt ∧ framework.coulombPotentialAddedAt channel framework.coulombPotential framework.nuclearRegime ∧ framework.protonBohrRadiusLargeComparedWithNuclearRangeAt channel framework.nuclearRegime ∧ data.PhysicalDomainAt ∧ data.PositiveRadiusEquationsAt ∧ data.ExteriorMatchingAt ∧ (framework.waveNumberValue framework.zeroEnergy = 0 ∧ framework.waveNumberSquared framework.zeroEnergy = 0) ∧ framework.waveNumberSquared framework.selectedLowEnergy = data.momentum ^ 2 theorem the_charged_scattering_point_is_distinct_from_its_zero_energy_reference (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) : framework.selectedLowEnergy ≠ framework.zeroEnergy := by intro same have positive := setup.2.2.2.2.2.1.2.1 change 0 < framework.waveNumberValue framework.selectedLowEnergy at positive rw [same, setup.2.2.2.2.2.2.2.2.1.1] at positive exact lt_irrefl _ positive def CoulombValueRepresentationAt (framework : EffectiveRangeFramework T) : Prop := let channel := framework.protonProtonSinglet let energy := framework.selectedLowEnergy let data := framework.coulombRadialData channel energy framework.coulombBoundaryDifference channel framework.zeroEnergy energy = data.phaseCoefficient 1 - data.phaseCoefficient 0 ∧ framework.coulombWaveNumberDifference framework.zeroEnergy energy = data.momentum ^ 2 ∧ framework.coulombOverlapIntegral channel framework.zeroEnergy energy = data.radialIntegrals.overlapIntegral ∧ framework.energyDependentRangeValue channel energy = data.energyRange ∧ framework.effectiveRangeValue channel = data.zeroRange def CoulombComparisonInputsAt (framework : EffectiveRangeFramework T) : Prop := (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).OriginExpansionAt ∧ (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).IntegratedComparisonAt ∧ framework.CoulombValueRepresentationAt ∧ (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).SourceBasisAt ∧ (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).SourceCombinationAt def CoulombComparisonCalculation (framework : EffectiveRangeFramework T) : Prop := framework.CoulombComparisonSetup → framework.CoulombComparisonInputsAt def CoulombRangeReplacementCalculation (framework : EffectiveRangeFramework T) : Prop := framework.CoulombComparisonSetup → (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).EnergyReplacementAt (framework.coulombEnergyRangeToleranceAt framework.protonProtonSinglet framework.selectedLowEnergy) theorem the_charged_data_retain_the_zero_energy_intercept_definition (framework : EffectiveRangeFramework T) (channel : T.Channel) (energy : T.Energy) (positive : 0 < (framework.coulombProtonParameters channel).bohrRadius) : (framework.coulombRadialData channel energy).inverseLength = framework.reciprocalScatteringLength channel := by unfold CoulombComparison.Data.inverseLength coulombRadialData dsimp field_simp def CoulombSourceFormulaReadoutAt (framework : EffectiveRangeFramework T) : Prop := let channel := framework.protonProtonSinglet let energy := framework.selectedLowEnergy let data := framework.coulombRadialData channel energy let parameter := CoulombComparison.eta data.bohrRadius data.momentum data.PhysicalDomainAt ∧ (0 < CoulombComparison.normalization parameter ∧ CoulombComparison.normalization parameter ^ 2 = CoulombComparison.penetrationSquared parameter) ∧ framework.coulombModifiedPhaseFunctionValue channel energy = CoulombComparison.sourceG parameter / data.bohrRadius + CoulombComparison.penetrationSquared parameter * data.momentum * (Real.cos data.phaseShift / Real.sin data.phaseShift) ∧ Tendsto (fun radius => deriv (data.comparison 1) radius - deriv (data.comparison 0) radius) (nhdsWithin 0 (Ioi 0)) (nhds (framework.coulombModifiedPhaseFunctionValue channel energy + framework.reciprocalScatteringLength channel)) ∧ framework.coulombSourceFunctionValue channel energy = data.bohrRadius * (-framework.reciprocalScatteringLength channel + framework.waveNumberSquared energy * framework.energyDependentRangeValue channel energy / 2) ∧ data.RelativePhaseReadoutAt theorem actual_coulomb_comparison_inputs_derive_the_exact_boundary_identity (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) (calculation : framework.CoulombComparisonCalculation) : framework.ExactCoulombComparisonIdentityAt framework.protonProtonSinglet framework.zeroEnergy framework.selectedLowEnergy := by obtain ⟨expansion, comparison, representation, _basis, _combination⟩ := calculation setup let data := framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy have limit := data.the_same_radius_logarithm_cancels_before_the_origin_limit expansion have identity := tendsto_nhds_unique limit comparison.2 unfold ExactCoulombComparisonIdentityAt rw [representation.1, representation.2.1, representation.2.2.1] exact identity theorem actual_coulomb_comparison_inputs_recover_the_printed_source_function (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) (calculation : framework.CoulombComparisonCalculation) : framework.CoulombSourceFormulaReadoutAt := by obtain ⟨expansion, comparison, representation, basis, combination⟩ := calculation setup rcases setup with ⟨_channel, _range, _parameters, _potential, _hierarchy, domain, _equations, matching, _zero, square⟩ let data := framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy have inverse := framework.the_charged_data_retain_the_zero_energy_intercept_definition framework.protonProtonSinglet framework.selectedLowEnergy domain.1 have parameterPositive : 0 < CoulombComparison.eta data.bohrRadius data.momentum := one_div_pos.mpr (mul_pos domain.2.1 domain.1) refine ⟨domain, CoulombComparison.equation_forty_three_has_the_actual_positive_normalization _ parameterPositive, CoulombComparison.the_dimensionless_source_function_has_the_printed_coulomb_coefficient _ _ _ domain.1 domain.2.1, ?_, ?_, data.the_actual_coulomb_basis_identifies_the_relative_nuclear_phase domain basis combination matching⟩ · have limit := data.the_same_radius_logarithm_cancels_before_the_origin_limit expansion have coefficients : data.phaseCoefficient 1 - data.phaseCoefficient 0 = framework.coulombModifiedPhaseFunctionValue framework.protonProtonSinglet framework.selectedLowEnergy + data.inverseLength := by simp [CoulombComparison.Data.phaseCoefficient, CoulombComparison.Data.inverseLength, coulombModifiedPhaseFunctionValue, data, coulombRadialData] ring rw [coefficients, inverse] at limit exact limit · have identity := data.actual_derivative_comparison_derives_the_charged_range_identity expansion comparison rw [inverse, ← representation.2.2.2.1, ← square] at identity change CoulombComparison.sourceF data.bohrRadius data.momentum data.phaseShift = _ calc _ = data.bohrRadius * CoulombComparison.modifiedPhase data.bohrRadius data.momentum data.phaseShift := (mul_div_cancel₀ _ domain.1.ne').symm _ = _ := congrArg (data.bohrRadius * ·) identity def EstablishedCoulombComparison (framework : EffectiveRangeFramework T) : Prop := framework.CoulombComparisonSetup ∧ framework.CoulombComparisonInputsAt ∧ framework.ExactCoulombComparisonIdentityAt framework.protonProtonSinglet framework.zeroEnergy framework.selectedLowEnergy ∧ framework.CoulombSourceFormulaReadoutAt theorem the_coulomb_source_formula_is_established_before_range_replacement (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) (calculation : framework.CoulombComparisonCalculation) : framework.EstablishedCoulombComparison := ⟨setup, calculation setup, framework.actual_coulomb_comparison_inputs_derive_the_exact_boundary_identity setup calculation, framework.actual_coulomb_comparison_inputs_recover_the_printed_source_function setup calculation⟩ def CoulombIdentificationBridge (framework : EffectiveRangeFramework T) : Prop := framework.CoulombEffectiveRangeLawAt framework.protonProtonSinglet framework.selectedLowEnergy → framework.coulombPhaseFunctionMatchesEffectiveRangeLawAt framework.protonProtonSinglet framework.selectedLowEnergy framework.nuclearRegime def EstablishedCoulombEffectiveRangeLaw (framework : EffectiveRangeFramework T) : Prop := framework.CoulombComparisonSetup ∧ framework.ExactCoulombComparisonIdentityAt framework.protonProtonSinglet framework.zeroEnergy framework.selectedLowEnergy ∧ framework.coulombInteriorWaveReplacementControlledAt framework.protonProtonSinglet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.CoulombEffectiveRangeLawAt framework.protonProtonSinglet framework.selectedLowEnergy ∧ framework.coulombPhaseFunctionMatchesEffectiveRangeLawAt framework.protonProtonSinglet framework.selectedLowEnergy framework.nuclearRegime ∧ framework.CoulombSourceFormulaReadoutAt theorem coulomb_comparison_yields_modified_effective_range_law (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) (calculation : framework.CoulombComparisonCalculation) (replacement : framework.CoulombRangeReplacementCalculation) (identification : framework.CoulombIdentificationBridge) : framework.EstablishedCoulombEffectiveRangeLaw := by obtain ⟨expansion, comparison, representation, _basis, _combination⟩ := calculation setup have control := replacement setup have domain := setup.2.2.2.2.2.1 have square := setup.2.2.2.2.2.2.2.2.2 have inverse := framework.the_charged_data_retain_the_zero_energy_intercept_definition framework.protonProtonSinglet framework.selectedLowEnergy domain.1 let data := framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy have bound := data.the_charged_range_replacement_controls_the_phase_instead_of_making_it_exact _ expansion comparison control rw [inverse, ← representation.2.2.2.2, ← square] at bound have law : framework.CoulombEffectiveRangeLawAt framework.protonProtonSinglet framework.selectedLowEnergy := bound exact ⟨setup, framework.actual_coulomb_comparison_inputs_derive_the_exact_boundary_identity setup calculation, ⟨rfl, control⟩, law, identification law, framework.actual_coulomb_comparison_inputs_recover_the_printed_source_function setup calculation⟩ theorem established_coulomb_comparison_and_range_control_yield_the_modified_law (framework : EffectiveRangeFramework T) (comparison : framework.EstablishedCoulombComparison) (replacement : framework.CoulombRangeReplacementCalculation) (identification : framework.CoulombIdentificationBridge) : framework.EstablishedCoulombEffectiveRangeLaw := framework.coulomb_comparison_yields_modified_effective_range_law comparison.1 (fun _ => comparison.2.1) replacement identification def CoulombNeutralizationCalculation (framework : EffectiveRangeFramework T) : Prop := framework.CoulombComparisonSetup → (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).NeutralizationControlAt (framework.radialWaveValueAt framework.neutralizedProtonWave) (framework.radialWaveValueAt framework.neutralizedProtonComparisonWave) (framework.coulombNeutralizationToleranceAt framework.protonProtonSinglet) ∧ framework.effectiveRangeValue framework.neutralCounterpartOfProtonProton = CoulombComparison.Data.neutralRange (framework.radialWaveValueAt framework.neutralizedProtonWave) (framework.radialWaveValueAt framework.neutralizedProtonComparisonWave) def EstablishedCoulombNeutralization (framework : EffectiveRangeFramework T) : Prop := let channel := framework.protonProtonSinglet framework.CoulombComparisonSetup ∧ RadialComparison.Approximation.RangeReplacementAt (framework.effectiveRangeValue channel) (framework.effectiveRangeValue framework.neutralCounterpartOfProtonProton) (framework.coulombNeutralizationToleranceAt channel) ∧ RadialComparison.Approximation.PhaseApproximationAt (framework.coulombModifiedPhaseFunctionValue channel framework.selectedLowEnergy) (framework.reciprocalScatteringLength channel) (framework.effectiveRangeValue framework.neutralCounterpartOfProtonProton) (framework.waveNumberSquared framework.selectedLowEnergy) (framework.coulombEnergyRangeToleranceAt channel framework.selectedLowEnergy + framework.coulombNeutralizationToleranceAt channel) theorem the_neutralized_range_requires_its_own_coulomb_removal_calculation (framework : EffectiveRangeFramework T) (setup : framework.CoulombComparisonSetup) (calculation : framework.CoulombComparisonCalculation) (replacement : framework.CoulombRangeReplacementCalculation) (neutralization : framework.CoulombNeutralizationCalculation) : framework.EstablishedCoulombNeutralization := by obtain ⟨expansion, comparison, representation, _basis, _combination⟩ := calculation setup obtain ⟨neutralControl, neutralValue⟩ := neutralization setup let data := framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy have range := data.neutralizing_the_same_nuclear_potential_has_its_own_range_error _ _ _ neutralControl have phase := data.energy_replacement_and_coulomb_removal_have_separate_error_budgets _ _ _ _ expansion comparison (replacement setup) neutralControl have inverse := framework.the_charged_data_retain_the_zero_energy_intercept_definition framework.protonProtonSinglet framework.selectedLowEnergy setup.2.2.2.2.2.1.1 rw [← representation.2.2.2.2, ← neutralValue] at range rw [inverse, ← neutralValue, ← setup.2.2.2.2.2.2.2.2.2] at phase exact ⟨setup, range, phase⟩ theorem the_charged_law_and_independent_neutralization_control_give_the_combined_error (framework : EffectiveRangeFramework T) (comparison : framework.EstablishedCoulombComparison) (law : framework.EstablishedCoulombEffectiveRangeLaw) (neutralization : framework.CoulombNeutralizationCalculation) : framework.EstablishedCoulombNeutralization := framework.the_neutralized_range_requires_its_own_coulomb_removal_calculation comparison.1 (fun _ => comparison.2.1) (fun _ => law.2.2.1.2) neutralization noncomputable def coulombThresholdData (framework : EffectiveRangeFramework T) : CoulombComparison.ThresholdData where bohrRadius := (framework.coulombProtonParameters framework.protonProtonSinglet).bohrRadius phaseShift parameter := framework.coulombPhaseShiftValue framework.protonProtonSinglet (framework.coulombEnergyAtEta parameter) def CoulombThresholdSetup (framework : EffectiveRangeFramework T) : Prop := (framework.coulombProtonParameters framework.protonProtonSinglet).PositiveAt ∧ ∀ᶠ parameter in atTop, framework.coulombThresholdData.PhysicalAt parameter ∧ framework.waveNumberValue (framework.coulombEnergyAtEta parameter) = framework.coulombThresholdData.momentum parameter ∧ framework.coulombThresholdData.ScatteringRealizationAt (framework.neutralScaledPotentialValueAt framework.protonProtonNuclearPotential) parameter def CoulombThresholdRegularity (framework : EffectiveRangeFramework T) : Prop := framework.coulombThresholdData.NonresonantInterceptAt def zeroEnergyCoulombBarrierSuppressesNuclearScatteringAt (framework : EffectiveRangeFramework T) (channel : T.Channel) (regime : T.Regime) : Prop := channel = framework.protonProtonSinglet ∧ regime = framework.nuclearRegime ∧ Tendsto framework.coulombThresholdData.nuclearPartialWaveStrength atTop (nhds 0) def EstablishedCoulombThreshold (framework : EffectiveRangeFramework T) : Prop := framework.CoulombThresholdSetup ∧ Tendsto (fun parameter => framework.waveNumberValue (framework.coulombEnergyAtEta parameter)) atTop (nhds 0) ∧ Tendsto CoulombComparison.penetrationSquared atTop (nhds 0) ∧ framework.zeroEnergyCoulombBarrierSuppressesNuclearScatteringAt framework.protonProtonSinglet framework.nuclearRegime ∧ (∀ᶠ parameter in atTop, framework.coulombThresholdData.nuclearPartialWaveStrength parameter = Real.sin (framework.coulombPhaseShiftValue framework.protonProtonSinglet (framework.coulombEnergyAtEta parameter)) ^ 2 / framework.waveNumberValue (framework.coulombEnergyAtEta parameter) ^ 2) ∧ ∀ᶠ parameter in atTop, framework.coulombThresholdData.RealizedRelativePhaseAt (framework.neutralScaledPotentialValueAt framework.protonProtonNuclearPotential) parameter theorem the_nonresonant_threshold_route_suppresses_only_the_nuclear_partial_wave (framework : EffectiveRangeFramework T) (setup : framework.CoulombThresholdSetup) (regularity : framework.CoulombThresholdRegularity) : framework.EstablishedCoulombThreshold := by have radiusPositive := CoulombComparison.ProtonParameters.positive_proton_parameters_give_a_positive_bohr_radius (framework.coulombProtonParameters framework.protonProtonSinglet) setup.1 have gap := framework.coulombThresholdData.a_noncancelling_source_intercept_supplies_the_uniform_gap regularity have suppression := framework.coulombThresholdData.the_nonresonant_source_gap_makes_the_nuclear_contribution_vanish radiusPositive gap have momentum := framework.coulombThresholdData.large_coulomb_parameter_is_an_actual_zero_momentum_limit radiusPositive have physicalMomentum : Tendsto (fun parameter => framework.waveNumberValue (framework.coulombEnergyAtEta parameter)) atTop (nhds 0) := by apply momentum.congr' filter_upwards [setup.2] with parameter actual exact actual.2.1.symm refine ⟨setup, physicalMomentum, CoulombComparison.the_repulsive_penetration_factor_vanishes_at_large_eta, ⟨rfl, rfl, suppression⟩, ?_, ?_⟩ · filter_upwards [setup.2] with parameter actual rw [actual.2.1] exact framework.coulombThresholdData.the_nuclear_partial_wave_strength_is_sine_squared_over_momentum_squared parameter actual.1 · filter_upwards [setup.2] with parameter actual exact framework.coulombThresholdData.a_realized_threshold_point_has_the_actual_relative_coulomb_phase _ parameter actual.1 actual.2.2 def protonEmpiricalData (framework : EffectiveRangeFramework T) : CoulombEmpiricalFit.Data T.Experiment T.Energy where parameters := framework.coulombProtonParameters framework.protonProtonSinglet laboratoryEnergy := framework.laboratoryEnergyValue momentum := framework.waveNumberValue study := framework.protonEmpiricalStudy def discrepantHighEnergyDatum (framework : EffectiveRangeFramework T) : T.Experiment × T.Energy := (framework.protonProtonHighEnergyExperiment, framework.selectedHighEnergy) def compatibleHighEnergyDatum (framework : EffectiveRangeFramework T) : T.Experiment × T.Energy := (framework.protonProtonCompatibleHighEnergyExperiment, framework.selectedCompatibleHighEnergy) def ProtonProtonEmpiricalSetup (framework : EffectiveRangeFramework T) : Prop := framework.protonEmpiricalData.SampleSetup ∧ ∀ point ∈ framework.protonEmpiricalStudy.calibrationSample ∪ framework.protonEmpiricalStudy.validationSample, framework.phaseShiftDataExtractedAt point.1 framework.protonProtonSinglet framework.nuclearRegime ∧ framework.lowEnergyRelativeToForceRangeAt point.2 framework.protonProtonNuclearPotential framework.nuclearRegime /-- The numerical fit evaluation is input; conversion to a range estimate is derived using (4) and (51). No exact integral-defined range is supplied here. -/ noncomputable def ProtonProtonFitCalculation (framework : EffectiveRangeFramework T) : Prop := framework.protonEmpiricalData.FitEvaluation ∧ framework.protonEmpiricalData.ReportedRangeCompatible framework.reportedProtonProtonEffectiveRange /-- Dearnley's upward departure and Wilson's error-compatible comparison are different measurements, both above the selected low-energy sample. The potential-direction interpretation and excluded P-wave tensor explanation are distinct physical inputs, not consequences of the residual algebra. -/ noncomputable def HighEnergyAssessment (framework : EffectiveRangeFramework T) : Prop := let data := framework.protonEmpiricalData data.ComparisonSetupAt framework.discrepantHighEnergyDatum ∧ data.ComparisonSetupAt framework.compatibleHighEnergyDatum ∧ framework.protonProtonHighEnergyExperiment ≠ framework.protonProtonCompatibleHighEnergyExperiment ∧ |data.residual framework.compatibleHighEnergyDatum| ≤ data.study.plotUncertainty framework.protonProtonCompatibleHighEnergyExperiment framework.selectedCompatibleHighEnergy ∧ data.study.plotUncertainty framework.protonProtonHighEnergyExperiment framework.selectedHighEnergy < data.residual framework.discrepantHighEnergyDatum ∧ 0 < data.study.squareWellHighEnergyDeviation ∧ data.study.squareWellHighEnergyDeviation < data.residual framework.discrepantHighEnergyDatum ∧ framework.highEnergyDeviationPointsTowardConcentratedPotentialAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime ∧ ¬framework.tensorForceEffectExplainsHighEnergyDiscrepancyAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime ∧ ¬framework.highEnergyDiscrepancyExplainedAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime noncomputable def EstablishedProtonProtonEmpiricalResult (framework : EffectiveRangeFramework T) : Prop := framework.ProtonProtonEmpiricalSetup ∧ framework.EstablishedCoulombEffectiveRangeLaw ∧ framework.protonEmpiricalData.FiniteSampleRangeResult ∧ framework.protonEmpiricalData.ReportedRangeCompatible framework.reportedProtonProtonEffectiveRange ∧ framework.HighEnergyAssessment theorem proton_data_support_low_energy_line_but_leave_high_energy_discrepancy (framework : EffectiveRangeFramework T) (setup : framework.ProtonProtonEmpiricalSetup) (law : framework.EstablishedCoulombEffectiveRangeLaw) (fit : framework.ProtonProtonFitCalculation) (highEnergy : framework.HighEnergyAssessment) : framework.EstablishedProtonProtonEmpiricalResult := by exact ⟨setup, law, framework.protonEmpiricalData.calibrated_finite_samples_give_range_estimates_and_actual_phase_residuals setup.1 fit.1, fit.2, highEnergy⟩ theorem established_proton_result_retains_finite_data_and_the_derived_range_fit (framework : EffectiveRangeFramework T) (result : framework.EstablishedProtonProtonEmpiricalResult) : framework.protonEmpiricalData.FiniteSampleRangeResult := result.2.2.1 theorem established_proton_result_distinguishes_the_two_high_energy_measurements (framework : EffectiveRangeFramework T) (result : framework.EstablishedProtonProtonEmpiricalResult) : let data := framework.protonEmpiricalData data.ComparisonSetupAt framework.discrepantHighEnergyDatum ∧ data.ComparisonSetupAt framework.compatibleHighEnergyDatum ∧ framework.protonProtonHighEnergyExperiment ≠ framework.protonProtonCompatibleHighEnergyExperiment ∧ |data.residual framework.compatibleHighEnergyDatum| ≤ data.study.plotUncertainty framework.protonProtonCompatibleHighEnergyExperiment framework.selectedCompatibleHighEnergy ∧ ¬(|data.residual framework.discrepantHighEnergyDatum| ≤ data.study.plotUncertainty framework.protonProtonHighEnergyExperiment framework.selectedHighEnergy) := by obtain ⟨discrepant, compatible, distinct, withinError, outsideError, _remaining⟩ := result.2.2.2.2 exact ⟨discrepant, compatible, distinct, withinError, not_le_of_gt (lt_of_lt_of_le outsideError (le_abs_self _))⟩ theorem established_proton_result_propagates_slope_and_rounding_uncertainties (framework : EffectiveRangeFramework T) (result : framework.EstablishedProtonProtonEmpiricalResult) (candidateSlope : Real) (controlled : |candidateSlope - framework.protonEmpiricalStudy.fittedSlope| ≤ framework.protonEmpiricalStudy.slopeUncertainty) : |framework.protonEmpiricalData.rangeConversion * candidateSlope - framework.reportedProtonProtonEffectiveRange| ≤ framework.protonEmpiricalData.rangeUncertainty + framework.protonEmpiricalStudy.rangeRoundingAllowance := framework.protonEmpiricalData.a_reported_range_retains_separate_slope_and_rounding_errors result.1.1.1 _ candidateSlope result.2.2.2.1 controlled theorem established_proton_result_retains_detailed_high_energy_diagnostics (framework : EffectiveRangeFramework T) (result : framework.EstablishedProtonProtonEmpiricalResult) : 0 < framework.protonEmpiricalData.residual framework.discrepantHighEnergyDatum ∧ 0 < framework.protonEmpiricalStudy.squareWellHighEnergyDeviation ∧ framework.protonEmpiricalStudy.squareWellHighEnergyDeviation < framework.protonEmpiricalData.residual framework.discrepantHighEnergyDatum ∧ framework.highEnergyDeviationPointsTowardConcentratedPotentialAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime ∧ ¬framework.tensorForceEffectExplainsHighEnergyDiscrepancyAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime ∧ ¬framework.highEnergyDiscrepancyExplainedAt framework.protonProtonHighEnergyExperiment framework.protonProtonSinglet framework.nuclearRegime := by obtain ⟨_discrepant, _compatible, _distinct, _withinError, _outsideError, squarePositive, exceeds, direction, tensorExcluded, unexplained⟩ := result.2.2.2.2 exact ⟨lt_trans squarePositive exceeds, squarePositive, exceeds, direction, tensorExcluded, unexplained⟩ noncomputable section def chargeRadialData (framework : EffectiveRangeFramework T) : CoulombChargeComparison.Data where bohrRadius := (framework.coulombProtonParameters framework.protonProtonSinglet).bohrRadius potential := framework.neutralScaledPotentialValueAt framework.protonProtonNuclearPotential neutralWave := framework.radialWaveValueAt framework.neutralizedProtonWave chargedWave := framework.radialWaveValueAt framework.coulombZeroEnergyWave chargedComparison := framework.radialWaveValueAt framework.coulombZeroEnergyComparisonWave neutralReciprocalLength := framework.reciprocalScatteringLength framework.neutralCounterpartOfProtonProton def chargeNeutralChannel (framework : EffectiveRangeFramework T) : CoulombChargeComparison.NeutralChannel where potential := framework.chargeRadialData.potential wave := framework.chargeRadialData.neutralWave reciprocalLength := framework.chargeRadialData.neutralReciprocalLength /-- The neutron-proton singlet is not the triplet/deuteron channel used in the earlier neutral calculation. -/ def neutronSingletChannel (framework : EffectiveRangeFramework T) : CoulombChargeComparison.NeutralChannel where potential := framework.chargeStudy.neutronPotential.value wave := framework.chargeStudy.neutronWave reciprocalLength := framework.reciprocalScatteringLength framework.neutronProtonSinglet def otherShapeChannel (framework : EffectiveRangeFramework T) (index : Fin 2) : CoulombChargeComparison.NeutralChannel where potential := (framework.chargeStudy.otherPotential index).value wave := framework.chargeStudy.otherWave index reciprocalLength := framework.chargeStudy.otherReciprocalLength index def chargeSourceEstimate (framework : EffectiveRangeFramework T) : CoulombChargeComparison.SourceEstimate where bohrRadius := framework.chargeRadialData.bohrRadius cutoff := framework.chargeStudy.radiusReference.estimate intercept := framework.protonEmpiricalStudy.fittedIntercept def chargeTrueIntercept (framework : EffectiveRangeFramework T) : Real := (framework.coulombRadialData framework.protonProtonSinglet framework.selectedLowEnergy).zeroIntercept def equivalentNeutralReciprocalLengthFromProtonData (framework : EffectiveRangeFramework T) : Real := framework.chargeSourceEstimate.firstOrderLength def chargeValueError (framework : EffectiveRangeFramework T) : Real := framework.chargeStudy.waveValueError + framework.chargeSourceEstimate.valueFitFactor * framework.chargeStudy.interceptError def chargeSlopeError (framework : EffectiveRangeFramework T) : Real := framework.chargeStudy.waveSlopeError + framework.chargeSourceEstimate.slopeFitFactor * framework.chargeStudy.interceptError def chargeReciprocalError (framework : EffectiveRangeFramework T) : Real := framework.chargeStudy.radiusSensitivity * framework.chargeStudy.radiusError + framework.chargeSourceEstimate.point.errorBound framework.chargeSourceEstimate.cutoff framework.chargeValueError framework.chargeSlopeError framework.chargeStudy.denominatorFloor + |framework.chargeSourceEstimate.remainder| def ChargeComparisonSetup (framework : EffectiveRangeFramework T) : Prop := framework.chargeRadialData.SamePotentialZeroEnergyAt ∧ framework.chargeNeutralChannel.AdmissibleAt ∧ framework.neutronSingletChannel.AdmissibleAt ∧ framework.chargeStudy.protonPotential.PhysicalAt ∧ framework.chargeStudy.neutronPotential.PhysicalAt ∧ framework.chargeStudy.radiusReference.PhysicalAt ∧ (framework.chargeStudy.protonPotential.shape = framework.chargeStudy.radiusReference.shape.nuclearShape ∧ (framework.chargeStudy.radiusReference.shape = .squareWell -> framework.chargeStudy.protonPotential.range = framework.chargeStudy.radiusReference.intrinsicRange)) ∧ (∀ radius : Real, 0 < radius -> framework.chargeRadialData.potential radius = framework.chargeStudy.protonPotential.value radius) ∧ framework.sWaveChannelAt framework.protonProtonSinglet framework.nuclearRegime ∧ framework.sWaveChannelAt framework.neutronProtonSinglet framework.nuclearRegime ∧ framework.waveNumberValue framework.zeroEnergy = 0 ∧ framework.waveNumberSquared framework.zeroEnergy = 0 def ChargeWeightedInputsAt (framework : EffectiveRangeFramework T) : Prop := framework.chargeRadialData.FiniteWeightedIdentitiesAt framework.chargeStudy.exactRadius ∧ framework.chargeRadialData.WeightedBalanceAt framework.chargeStudy.exactRadius ∧ Tendsto framework.chargeRadialData.boundaryDifference atTop (nhds 0) ∧ framework.chargeRadialData.chargedComparison framework.chargeStudy.exactRadius ≠ 0 ∧ framework.chargeRadialData.neutralComparison framework.chargeStudy.exactRadius ≠ 0 def ChargeWeightedCalculation (framework : EffectiveRangeFramework T) : Prop := framework.ChargeComparisonSetup -> framework.ChargeWeightedInputsAt def EstablishedChargeWeightedComparison (framework : EffectiveRangeFramework T) : Prop := framework.ChargeComparisonSetup ∧ framework.ChargeWeightedInputsAt ∧ framework.chargeRadialData.LogarithmicSlopesAgreeAt framework.chargeStudy.exactRadius ∧ framework.chargeRadialData.neutralReciprocalLength = framework.chargeRadialData.equivalentReciprocalLength framework.chargeStudy.exactRadius theorem the_weighted_charge_comparison_precedes_the_empirical_readout (framework : EffectiveRangeFramework T) (setup : framework.ChargeComparisonSetup) (calculation : framework.ChargeWeightedCalculation) : framework.EstablishedChargeWeightedComparison := by have inputs := calculation setup have zero := framework.chargeRadialData.weighted_balance_and_the_actual_boundary_limit_give_zero_comparison_wronskian setup.1 framework.chargeStudy.exactRadius inputs.1 inputs.2.1 inputs.2.2.1 exact ⟨setup, inputs, framework.chargeRadialData.a_zero_wronskian_gives_logarithmic_slope_agreement_only_at_nonzero_values framework.chargeStudy.exactRadius zero inputs.2.2.2.2 inputs.2.2.2.1, framework.chargeRadialData.the_linear_comparison_determines_the_equivalent_neutral_length framework.chargeStudy.exactRadius zero inputs.2.2.2.1⟩ def ChargeZeroEnergySourceAt (framework : EffectiveRangeFramework T) : Prop := Tendsto (fun radius => deriv framework.chargeRadialData.chargedComparison radius - (CoulombComparison.commonLogDerivative framework.chargeRadialData.bohrRadius radius + framework.chargeTrueIntercept / framework.chargeRadialData.bohrRadius)) (nhdsWithin 0 (Ioi 0)) (nhds 0) theorem the_charge_readout_uses_the_same_zero_energy_coulomb_source (framework : EffectiveRangeFramework T) (comparison : framework.EstablishedCoulombComparison) : framework.ChargeZeroEnergySourceAt := by have zero := comparison.2.1.1 (0 : Fin 2) simpa [ChargeZeroEnergySourceAt, CoulombComparison.Data.originRemainder, CoulombComparison.Data.commonLogDerivative, CoulombComparison.Data.phaseCoefficient, chargeRadialData, chargeTrueIntercept, coulombRadialData] using zero /-- These quantitative bounds are explicit sufficient reconstruction inputs. The paper does not itself certify all of their numerical budgets. -/ def ChargeReadoutInputsAt (framework : EffectiveRangeFramework T) : Prop := let study := framework.chargeStudy let estimate := framework.chargeSourceEstimate let actual := framework.chargeRadialData.pointAt estimate.cutoff let trueEstimate : CoulombChargeComparison.SourceEstimate := {estimate with intercept := framework.chargeTrueIntercept} study.radiusReference.SourceSeriesAt framework.chargeRadialData.neutralReciprocalLength ∧ framework.chargeRadialData.LogRadiusControlAt study.radiusLower study.radiusUpper study.radiusSensitivity ∧ study.exactRadius ∈ Icc study.radiusLower study.radiusUpper ∧ estimate.cutoff ∈ Icc study.radiusLower study.radiusUpper ∧ |Real.log study.exactRadius - Real.log estimate.cutoff| ≤ study.radiusError ∧ |framework.chargeTrueIntercept - estimate.intercept| ≤ study.interceptError ∧ 0 ≤ study.waveValueError ∧ 0 ≤ study.waveSlopeError ∧ |actual.value - trueEstimate.point.value| ≤ study.waveValueError ∧ |actual.slope - trueEstimate.point.slope| ≤ study.waveSlopeError ∧ 0 < study.denominatorFloor ∧ study.denominatorFloor + framework.chargeValueError + |estimate.cutoff| * framework.chargeSlopeError ≤ |estimate.point.denominator estimate.cutoff| def ChargeReadoutCalculation (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedChargeWeightedComparison -> framework.EstablishedCoulombComparison -> framework.EstablishedProtonProtonEmpiricalResult -> framework.ChargeReadoutInputsAt def ControlledChargeEstimateAt (framework : EffectiveRangeFramework T) : Prop := |framework.chargeRadialData.neutralReciprocalLength - framework.equivalentNeutralReciprocalLengthFromProtonData| ≤ framework.chargeReciprocalError def EstablishedChargeEstimate (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedChargeWeightedComparison ∧ framework.ChargeZeroEnergySourceAt ∧ framework.ChargeReadoutInputsAt ∧ framework.ControlledChargeEstimateAt theorem the_charge_estimate_retains_radius_fit_wave_and_truncation_errors (framework : EffectiveRangeFramework T) (weighted : framework.EstablishedChargeWeightedComparison) (coulomb : framework.EstablishedCoulombComparison) (proton : framework.EstablishedProtonProtonEmpiricalResult) (calculation : framework.ChargeReadoutCalculation) : framework.EstablishedChargeEstimate := by have inputs := calculation weighted coulomb proton rcases inputs with ⟨series, regular, exactMember, estimatedMember, radiusControl, fitControl, valueNonnegative, slopeNonnegative, valueControl, slopeControl, floorPositive, margin⟩ let estimate := framework.chargeSourceEstimate let actual := framework.chargeRadialData.pointAt estimate.cutoff have fitNonnegative := (abs_nonneg _).trans fitControl have pointControl := estimate.expansion_and_intercept_errors_are_added_before_the_inverse_readout actual framework.chargeTrueIntercept framework.chargeStudy.interceptError framework.chargeStudy.waveValueError framework.chargeStudy.waveSlopeError fitControl valueControl slopeControl have control : actual.ControlledAt estimate.point estimate.cutoff framework.chargeValueError framework.chargeSlopeError framework.chargeStudy.denominatorFloor := ⟨add_nonneg valueNonnegative (mul_nonneg (abs_nonneg _) fitNonnegative), add_nonneg slopeNonnegative (mul_nonneg (abs_nonneg _) fitNonnegative), floorPositive, pointControl.1, pointControl.2, margin⟩ have readout := estimate.the_controlled_wave_readout_retains_the_first_order_remainder actual framework.chargeValueError framework.chargeSlopeError framework.chargeStudy.denominatorFloor weighted.1.1.1 control have radius := framework.chargeRadialData.a_controlled_log_radius_error_has_its_own_reciprocal_length_error framework.chargeStudy.radiusLower framework.chargeStudy.radiusUpper framework.chargeStudy.radiusSensitivity framework.chargeStudy.exactRadius estimate.cutoff framework.chargeStudy.radiusError regular exactMember estimatedMember radiusControl refine ⟨weighted, framework.the_charge_readout_uses_the_same_zero_energy_coulomb_source coulomb, calculation weighted coulomb proton, ?_⟩ unfold ControlledChargeEstimateAt rw [weighted.2.2.2] have triangle := abs_sub_le (framework.chargeRadialData.equivalentReciprocalLength framework.chargeStudy.exactRadius) (framework.chargeRadialData.equivalentReciprocalLength estimate.cutoff) estimate.firstOrderLength change |framework.chargeRadialData.equivalentReciprocalLength estimate.cutoff - estimate.firstOrderLength| ≤ _ at readout dsimp [equivalentNeutralReciprocalLengthFromProtonData, chargeReciprocalError] linarith def ChargeDataControlAt (framework : EffectiveRangeFramework T) : Prop := let study := framework.chargeStudy |framework.neutronSingletChannel.reciprocalLength - framework.measuredNeutronProtonSingletReciprocalLength| ≤ study.neutronMeasurementError ∧ framework.chargeReciprocalError + study.neutronMeasurementError < |framework.equivalentNeutralReciprocalLengthFromProtonData - framework.measuredNeutronProtonSingletReciprocalLength| ∧ (0 < study.naturalInverseRange ∧ study.naturalInverseRange = 1 / study.protonPotential.range) ∧ 0 < study.smallGapFraction ∧ study.smallGapFraction ≤ 1 / 20 ∧ |framework.equivalentNeutralReciprocalLengthFromProtonData - framework.measuredNeutronProtonSingletReciprocalLength| + framework.chargeReciprocalError + study.neutronMeasurementError ≤ study.smallGapFraction * study.naturalInverseRange def ChargeComparisonCalculation (framework : EffectiveRangeFramework T) : Prop := framework.ChargeComparisonSetup -> framework.EstablishedProtonProtonEmpiricalResult -> framework.ChargeDataControlAt /-- The cited depth calculation is separate from scattering-length separation. Its common-range-and-shape premise remains conditional, not negated. -/ def ChargeDependenceInterpretation (framework : EffectiveRangeFramework T) : Prop := CoulombChargeComparison.NeutralChannel.SamePotentialReadoutUniqueness ∧ 0 ≤ framework.chargeStudy.depthTolerance ∧ framework.chargeStudy.depthTolerance ≤ 3 / 100 ∧ (framework.SingletRangeAssessment -> framework.ChargeDataControlAt -> framework.chargeStudy.protonPotential.SameRangeAndShapeAt framework.chargeStudy.neutronPotential -> |framework.chargeStudy.protonPotential.depth - framework.chargeStudy.neutronPotential.depth| ≤ framework.chargeStudy.depthTolerance * framework.chargeStudy.neutronPotential.depth) def EstablishedChargeComparison (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedChargeEstimate ∧ framework.SingletRangeAssessment ∧ framework.ChargeDataControlAt ∧ framework.chargeNeutralChannel.reciprocalLength ≠ framework.neutronSingletChannel.reciprocalLength ∧ |framework.chargeNeutralChannel.reciprocalLength - framework.neutronSingletChannel.reciprocalLength| ≤ framework.chargeStudy.smallGapFraction * framework.chargeStudy.naturalInverseRange ∧ (¬∀ radius : Real, 0 < radius -> framework.chargeStudy.protonPotential.value radius = framework.chargeStudy.neutronPotential.value radius) ∧ (framework.chargeStudy.protonPotential.SameRangeAndShapeAt framework.chargeStudy.neutronPotential -> framework.chargeStudy.protonPotential.RelativeDifferenceAt framework.chargeStudy.neutronPotential framework.chargeStudy.depthTolerance) theorem proton_neutron_comparison_finds_small_but_definite_force_difference (framework : EffectiveRangeFramework T) (estimate : framework.EstablishedChargeEstimate) (protonResult : framework.EstablishedProtonProtonEmpiricalResult) (singletAssessment : framework.SingletRangeAssessment) (calculation : framework.ChargeComparisonCalculation) (interpretation : framework.ChargeDependenceInterpretation) : framework.EstablishedChargeComparison := by have controls := calculation estimate.1.1 protonResult have different := CoulombChargeComparison.estimate_and_measurement_errors_require_a_strict_separation_margin _ _ _ _ _ _ estimate.2.2.2 controls.1 controls.2.1 have small := CoulombChargeComparison.an_observed_length_difference_and_both_errors_bound_the_true_difference _ _ _ _ _ _ estimate.2.2.2 controls.1 rcases estimate.1.1 with ⟨physical, neutral, neutron, protonPhysical, neutronPhysical, radiusPhysical, shape, potential, channels⟩ have forceDifferent := CoulombChargeComparison.NeutralChannel.different_actual_scattering_lengths_exclude_equal_nuclear_potentials framework.chargeNeutralChannel framework.neutronSingletChannel neutral neutron interpretation.1 different refine ⟨estimate, singletAssessment, controls, different, small.trans controls.2.2.2.2.2, ?_, ?_⟩ · intro equal apply forceDifferent intro radius positive exact (potential radius positive).trans (equal radius positive) · intro common exact framework.chargeStudy.protonPotential.a_depth_comparison_controls_the_actual_potential_only_with_common_range_and_shape framework.chargeStudy.neutronPotential neutronPhysical framework.chargeStudy.depthTolerance interpretation.2.1 common (interpretation.2.2.2 singletAssessment controls common) theorem established_charge_comparison_retains_robustness_and_conditions (framework : EffectiveRangeFramework T) (comparison : framework.EstablishedChargeComparison) : framework.ControlledChargeEstimateAt ∧ framework.ChargeDataControlAt ∧ (¬∀ radius : Real, 0 < radius -> framework.chargeStudy.protonPotential.value radius = framework.chargeStudy.neutronPotential.value radius) ∧ (framework.chargeStudy.protonPotential.SameRangeAndShapeAt framework.chargeStudy.neutronPotential -> framework.chargeStudy.protonPotential.RelativeDifferenceAt framework.chargeStudy.neutronPotential framework.chargeStudy.depthTolerance) := ⟨comparison.1.2.2.2, comparison.2.2.1, comparison.2.2.2.2.2⟩ /-- The two unevaluated profiles are exponential and Gaussian. The original bracketing expectation precedes the finite-scattering-length corrections. -/ def ChargeShapeExpectation (framework : EffectiveRangeFramework T) : Prop := 0 < framework.chargeStudy.inverseLengthUnit ∧ framework.measuredNeutronProtonSingletReciprocalLength = framework.chargeStudy.inverseLengthUnit * CoulombChargeComparison.ReportedComparison.neutronSinglet ∧ (∀ index : Fin 2, CoulombChargeComparison.ReportedComparison.InSourceShapeBracket (framework.chargeStudy.otherShapeEstimate index / framework.chargeStudy.inverseLengthUnit)) ∧ ∀ index : Fin 2, (framework.chargeStudy.otherPotential index).PhysicalAt ∧ (framework.chargeStudy.otherPotential index).shape = if index = 0 then .exponential else .gaussian def ChargeShapeErrorBudgetAt (framework : EffectiveRangeFramework T) : Prop := |framework.neutronSingletChannel.reciprocalLength - framework.measuredNeutronProtonSingletReciprocalLength| ≤ framework.chargeStudy.neutronMeasurementError ∧ ∀ index : Fin 2, 0 ≤ framework.chargeStudy.otherShapeError index ∧ framework.chargeStudy.otherShapeError index + framework.chargeStudy.neutronMeasurementError < framework.chargeStudy.inverseLengthUnit * (96 / 1000) def EstablishedChargeShapeAssessment (framework : EffectiveRangeFramework T) : Prop := framework.ChargeShapeExpectation ∧ framework.ChargeShapeErrorBudgetAt ∧ ∀ index : Fin 2, (framework.otherShapeChannel index).AdmissibleAt -> |(framework.otherShapeChannel index).reciprocalLength - framework.chargeStudy.otherShapeEstimate index| ≤ framework.chargeStudy.otherShapeError index -> (framework.otherShapeChannel index).reciprocalLength ≠ framework.neutronSingletChannel.reciprocalLength ∧ (framework.neutronSingletChannel.AdmissibleAt -> CoulombChargeComparison.NeutralChannel.SamePotentialReadoutUniqueness -> ¬∀ radius : Real, 0 < radius -> (framework.chargeStudy.otherPotential index).value radius = framework.chargeStudy.neutronPotential.value radius) theorem extrapolating_to_other_shapes_retains_the_author_expectation_and_error_budget (framework : EffectiveRangeFramework T) (expectation : framework.ChargeShapeExpectation) (errors : framework.ChargeShapeErrorBudgetAt) : framework.EstablishedChargeShapeAssessment := by refine ⟨expectation, errors, ?_⟩ intro index admissible calibration have gap := CoulombChargeComparison.ReportedComparison.the_source_shape_bracket_has_a_gap_before_finite_length_corrections _ (expectation.2.2.1 index) have scaled := mul_le_mul_of_nonneg_left gap.1 expectation.1.le have identity : |framework.chargeStudy.otherShapeEstimate index - framework.measuredNeutronProtonSingletReciprocalLength| = framework.chargeStudy.inverseLengthUnit * |framework.chargeStudy.otherShapeEstimate index / framework.chargeStudy.inverseLengthUnit - CoulombChargeComparison.ReportedComparison.neutronSinglet| := by rw [expectation.2.1] have factor : framework.chargeStudy.otherShapeEstimate index - framework.chargeStudy.inverseLengthUnit * CoulombChargeComparison.ReportedComparison.neutronSinglet = framework.chargeStudy.inverseLengthUnit * (framework.chargeStudy.otherShapeEstimate index / framework.chargeStudy.inverseLengthUnit - CoulombChargeComparison.ReportedComparison.neutronSinglet) := by field_simp [expectation.1.ne'] rw [factor, abs_mul, abs_of_pos expectation.1] have different := CoulombChargeComparison.estimate_and_measurement_errors_require_a_strict_separation_margin _ _ _ _ _ _ calibration errors.1 (by rw [identity]; exact lt_of_lt_of_le (errors.2 index).2 scaled) refine ⟨different, ?_⟩ intro neutronAdmissible uniqueness exact CoulombChargeComparison.NeutralChannel.different_actual_scattering_lengths_exclude_equal_nuclear_potentials (framework.otherShapeChannel index) framework.neutronSingletChannel admissible neutronAdmissible uniqueness different end def PaperScopeQualifications (framework : EffectiveRangeFramework T) : Prop := framework.tensorForceExtensionDeferredAt framework.nuclearRegime ∧ framework.deuteronPhotoeffectExtensionDeferredAt framework.nuclearRegime /-- Paper-local realization of the repeated low-energy effective-range inference. Bethe's exact comparison identity and its wavefunction integrals remain local; only their controlled low-energy output is shared. -/ def toLowEnergyEffectiveRangeContext (framework : EffectiveRangeFramework T) : LowEnergyEffectiveRangeContext T.Channel T.Energy T.Regime Unit where selectedChannel := framework.neutronProtonTriplet selectedZeroEnergy := framework.zeroEnergy selectedEnergy := framework.selectedLowEnergy selectedRegime := framework.nuclearRegime selectedTwoParameterLaw := () validity := { validAt := fun channelEnergy regime => channelEnergy.1 = framework.neutronProtonTriplet ∧ regime = framework.nuclearRegime ∧ framework.lowEnergyRelativeToForceRangeAt channelEnergy.2 framework.neutronProtonPotential regime } neutralSWaveChannelAt := framework.sWaveChannelAt shortRangeInteractionAt := fun channel regime => framework.finiteRangeNuclearPotentialAt channel framework.neutronProtonPotential regime lowEnergyRelativeToInteractionRangeAt := fun channel energy regime => channel = framework.neutronProtonTriplet ∧ framework.lowEnergyRelativeToForceRangeAt energy framework.neutronProtonPotential regime zeroEnergyReferenceControlledAt := fun channel zero energy regime => zero = framework.zeroEnergy ∧ framework.zeroEnergyInteriorReplacementControlledAt channel energy regime scatteringLengthDefinedAt := fun channel regime => regime = framework.nuclearRegime ∧ framework.NeutralZeroEnergyRelationAt channel framework.selectedLowEnergy effectiveRangeDefinedAt := fun channel regime => regime = framework.nuclearRegime ∧ framework.zeroEnergyInteriorReplacementControlledAt channel framework.selectedLowEnergy regime twoParameterPhaseLawObtainedAt := fun _ channel energy regime => framework.NeutralEffectiveRangeLawAt channel energy ∧ framework.phaseFunctionMatchesEffectiveRangeLawAt channel energy regime higherOrderCorrectionCalculatedAt := framework.higherOrderShapeExpansionCalculatedAt higherOrderCorrectionSmallAt := fun channel energy regime => framework.shapeCoefficientSmallAt channel energy regime ∧ framework.effectiveRangeApproximationAccurateAt channel energy regime detailedInteractionShapeResolvedAt := fun channel _energy regime => framework.potentialShapeResolvedByPhaseDataAt framework.neutronProtonExperiment channel regime def effectiveRangeReductionModel (framework : EffectiveRangeFramework T) : EffectiveRangeReductionCalculationModel T.Channel T.Energy T.Regime Unit := framework.toLowEnergyEffectiveRangeContext.selectedModel theorem effective_range_reduction_model_retains_paper_semantics (framework : EffectiveRangeFramework T) : framework.toLowEnergyEffectiveRangeContext |>.SelectedEffectiveRangeReductionSemanticsAt framework.effectiveRangeReductionModel := rfl def toLowEnergyEffectiveRangeInterpretation (framework : EffectiveRangeFramework T) : EffectiveRangeReductionInterpretation (EffectiveRangeFramework T) T.Channel T.Channel T.Energy T.Regime Unit where theoryUsesEffectiveRangeModel := fun theory model => theory = framework ∧ model = framework.effectiveRangeReductionModel effectiveRangeModelRepresentsWorld := fun model world => model = framework.effectiveRangeReductionModel ∧ world = model.channel ∧ framework.sWaveChannelAt world model.regime ∧ framework.finiteRangeNuclearPotentialAt world framework.neutronProtonPotential model.regime theoryClaim := fun theory model claim => theory = framework ∧ framework.toLowEnergyEffectiveRangeContext.SharedClaimHoldsAt model claim physicalClaim := fun world model claim => world = model.channel ∧ framework.toLowEnergyEffectiveRangeContext.SharedClaimHoldsAt model claim /-- Bethe's paper-local pre-calculation setup for the shared reduction. It fixes a neutral S-wave channel with a finite-range nuclear potential at the selected low energy, but assumes no comparison identity, zero-energy replacement, effective-range law, higher-order estimate, or shape conclusion. -/ def SharedLowEnergyEffectiveRangeGroundingSetup (framework : EffectiveRangeFramework T) : Prop := framework.sWaveChannelAt framework.neutronProtonTriplet framework.nuclearRegime ∧ framework.finiteRangeNuclearPotentialAt framework.neutronProtonTriplet framework.neutronProtonPotential framework.nuclearRegime ∧ framework.lowEnergyRelativeToForceRangeAt framework.selectedLowEnergy framework.neutronProtonPotential framework.nuclearRegime theorem shared_grounding_setup_selects_low_energy_effective_range_setup (framework : EffectiveRangeFramework T) (setup : framework.SharedLowEnergyEffectiveRangeGroundingSetup) : framework.toLowEnergyEffectiveRangeContext |>.SelectedLowEnergyEffectiveRangeSetupAt framework.effectiveRangeReductionModel := by rcases setup with ⟨sWave, finiteRange, lowEnergy⟩ exact ⟨rfl, ⟨⟨rfl, rfl, lowEnergy⟩, sWave, finiteRange, ⟨rfl, lowEnergy⟩⟩⟩ /-- The shared setup recovers the neutral S-wave, finite-range, and low-energy premises that Bethe's reduction genuinely shares with Blatt-Jackson. The radial-wave and comparison-wave facts remain in the paper-local neutral result, because the shared component does not claim to reconstruct them. -/ theorem shared_low_energy_setup_recovers_neutral_reduction_inputs (framework : EffectiveRangeFramework T) (neutral : framework.EstablishedNeutralComparison) (sharedSetup : framework.effectiveRangeReductionModel.LowEnergySetup) : framework.EstablishedNeutralComparison ∧ framework.EffectiveRangeApproximationSetup := by rcases neutral with ⟨neutralSetup, identity, zeroRelation⟩ rcases neutralSetup with ⟨_storedNeutral, _storedShortRange, actualWave, zeroWave, actualMatch, zeroMatch, actualNormalized, zeroNormalized⟩ rcases sharedSetup with ⟨_valid, sharedNeutral, sharedShortRange, sharedLowEnergy⟩ exact ⟨⟨⟨sharedNeutral, sharedShortRange, actualWave, zeroWave, actualMatch, zeroMatch, actualNormalized, zeroNormalized⟩, identity, zeroRelation⟩, sharedLowEnergy.2⟩ /-- The embedded shared parent reduction can be replayed back into Bethe's paper-local effective-range result. The shared certificate supplies the selected setup, controlled reference, and phase-law output without storing a second proof-carrying comparison route in the completed result. -/ theorem shared_established_two_parameter_law_recovers_neutral_effective_range_law (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (sharedLaw : framework.toLowEnergyEffectiveRangeContext |>.EstablishedTwoParameterEffectiveRangeLawAt framework.effectiveRangeReductionModel) : framework.EstablishedNeutralEffectiveRangeLaw := by rcases law with ⟨neutral, _cachedApproximation, _cachedReplacement, _cachedLaw, _cachedPhaseMatch⟩ have sharedSetup := sharedLaw.2.1 have replayInputs := framework.shared_low_energy_setup_recovers_neutral_reduction_inputs neutral sharedSetup rcases sharedLaw.2.2.1 with ⟨_zeroEnergy, replacement⟩ rcases sharedLaw.2.2.2.2.2 with ⟨phaseLaw, sharedPhaseMatches⟩ exact ⟨replayInputs.1, replayInputs.2, replacement, phaseLaw, sharedPhaseMatches⟩ /-- Bethe's established order-`k^2` law supplies the shared parent needed by the deuteron extraction before Section IV's later shape-correction analysis. -/ theorem neutral_effective_range_law_establishes_shared_two_parameter_law (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) : framework.toLowEnergyEffectiveRangeContext |>.EstablishedTwoParameterEffectiveRangeLawAt framework.effectiveRangeReductionModel := by rcases law with ⟨neutral, approximation, replacement, phaseLaw, phaseMatches⟩ exact ⟨rfl, ⟨⟨rfl, rfl, approximation⟩, neutral.1.1, neutral.1.2.1, ⟨rfl, approximation⟩⟩, ⟨rfl, replacement⟩, ⟨rfl, neutral.2.2.1⟩, ⟨rfl, replacement⟩, ⟨phaseLaw, phaseMatches⟩⟩ /-- Raw paper premises that realize Bethe's comparison-identity derivation. The token records a derivation route, not merely its two-parameter output. -/ def BetheEffectiveRangeDerivationObtains (framework : EffectiveRangeFramework T) : BetheEffectiveRangeDerivation → Prop | .comparisonIdentityAndInteriorReplacement => framework.NeutralComparisonSetup ∧ framework.NeutralComparisonCalculation ∧ framework.NeutralRadialFormulaCalculation ∧ framework.EffectiveRangeApproximationSetup ∧ framework.EffectiveRangeRouteCalculation ∧ framework.EffectiveRangeIdentificationBridge ∧ framework.HigherOrderCorrectionCalculation ∧ framework.CurvatureDiagnosticInterpretation ∧ framework.ShapeSensitivityInterpretation theorem neutral_effective_range_routes_make_shared_route_applicable (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.toLowEnergyEffectiveRangeContext |>.EffectiveRangeReductionRouteApplicableAt framework.effectiveRangeReductionModel := by let model := framework.effectiveRangeReductionModel rcases law with ⟨neutral, localApproximation, replacement, phaseLaw, phaseMatches⟩ rcases accuracy with ⟨_accuracyLaw, expansion, shapeSmall, accurate, _cachedCurvatureScope, _cachedDiscriminator, shapeUnresolved, _cachedSquareWellRange, _cachedLongTailRange, _cachedSingleChannelScope⟩ have selected : framework.toLowEnergyEffectiveRangeContext |>.SelectedEffectiveRangeReductionSemanticsAt model := framework.effective_range_reduction_model_retains_paper_semantics have setup : model.LowEnergySetup := by exact ⟨⟨rfl, rfl, localApproximation⟩, neutral.1.1, neutral.1.2.1, ⟨rfl, localApproximation⟩⟩ refine ⟨selected, setup, ?_, ?_, ?_⟩ · intro sharedSetup have replayInputs := framework.shared_low_energy_setup_recovers_neutral_reduction_inputs neutral sharedSetup exact ⟨⟨rfl, replacement⟩, ⟨rfl, replayInputs.1.2.2.1⟩⟩ · intro sharedSetup reference _scatteringLength rcases reference with ⟨_zeroEnergy, referenceReplacement⟩ exact ⟨⟨rfl, referenceReplacement⟩, ⟨phaseLaw, phaseMatches⟩⟩ · intro _sharedSetup _sharedLaw exact ⟨expansion, ⟨shapeSmall, accurate⟩, shapeUnresolved⟩ /- Source: original PDF pp. 39-43, equations (10)-(16). Bethe first derives the exact comparison identity, then controls replacement of the interior wave by its zero-energy form, and finally assesses the small shape-sensitive term. -/ theorem bethe_source_inputs_make_shared_reduction_applicable (framework : EffectiveRangeFramework T) (comparisonSetup : framework.NeutralComparisonSetup) (comparisonCalculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) (approximationSetup : framework.EffectiveRangeApproximationSetup) (routeCalculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) (higherCalculation : framework.HigherOrderCorrectionCalculation) (diagnostic : framework.CurvatureDiagnosticInterpretation) (shapeInterpretation : framework.ShapeSensitivityInterpretation) : framework.toLowEnergyEffectiveRangeContext |>.EffectiveRangeReductionRouteApplicableAt framework.effectiveRangeReductionModel := by have neutral := framework.radial_comparison_yields_exact_neutral_identity comparisonSetup comparisonCalculation formulaCalculation have law := framework.controlled_zero_energy_replacement_yields_effective_range_law neutral approximationSetup routeCalculation identification have accuracy := framework.small_shape_correction_supports_accuracy_not_shape_determination law higherCalculation diagnostic shapeInterpretation exact framework.neutral_effective_range_routes_make_shared_route_applicable law accuracy /-- Bethe's raw comparison-identity inputs structurally explain the selected controlled phase behavior without consuming an established endpoint or derivational-reduction wrapper. -/ theorem bethe_source_inputs_realize_structural_effective_range_reduction_explanation (framework : EffectiveRangeFramework T) (comparisonSetup : framework.NeutralComparisonSetup) (comparisonCalculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) (approximationSetup : framework.EffectiveRangeApproximationSetup) (routeCalculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) (higherCalculation : framework.HigherOrderCorrectionCalculation) (diagnostic : framework.CurvatureDiagnosticInterpretation) (shapeInterpretation : framework.ShapeSensitivityInterpretation) : framework.toLowEnergyEffectiveRangeContext |>.DirectStructuralEffectiveRangeReductionExplanationAt framework.effectiveRangeReductionModel := framework.toLowEnergyEffectiveRangeContext |>.applicable_route_realizes_structural_effective_range_reduction_explanation (framework.bethe_source_inputs_make_shared_reduction_applicable comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification higherCalculation diagnostic shapeInterpretation) /-- Bethe's typed comparison-and-replacement source reconstructs the raw shared route rather than storing an established reduction or ordinary explanation. -/ theorem bethe_source_derivation_makes_shared_reduction_applicable (framework : EffectiveRangeFramework T) (source : framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityAndInteriorReplacement) : framework.toLowEnergyEffectiveRangeContext |>.EffectiveRangeReductionRouteApplicableAt framework.effectiveRangeReductionModel := by rcases source with ⟨comparisonSetup, comparisonCalculation, formulaCalculation, approximationSetup, routeCalculation, identification, higherCalculation, diagnostic, shapeInterpretation⟩ exact framework.bethe_source_inputs_make_shared_reduction_applicable comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification higherCalculation diagnostic shapeInterpretation /-- Bethe's typed comparison-and-replacement source realizes the stricter source-sensitive structural explanation without identifying it with Blatt-Jackson's stationary-functional route. -/ theorem bethe_source_inputs_realize_source_structural_effective_range_reduction_explanation (framework : EffectiveRangeFramework T) (source : framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityAndInteriorReplacement) : framework.toLowEnergyEffectiveRangeContext |>.DirectSourceStructuralEffectiveRangeReductionExplanationAt framework.effectiveRangeReductionModel .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains := by apply framework.toLowEnergyEffectiveRangeContext |>.source_derivation_and_applicable_route_realize_source_structural_effective_range_reduction_explanation framework.effectiveRangeReductionModel .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains · exact source · exact framework.bethe_source_derivation_makes_shared_reduction_applicable source /-- The raw exact-comparison route realizes a source-sensitive shared reduction. No established shared reduction is a premise. -/ theorem bethe_source_inputs_realize_source_effective_range_derivational_reduction (framework : EffectiveRangeFramework T) (comparisonSetup : framework.NeutralComparisonSetup) (comparisonCalculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) (approximationSetup : framework.EffectiveRangeApproximationSetup) (routeCalculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) (higherCalculation : framework.HigherOrderCorrectionCalculation) (diagnostic : framework.CurvatureDiagnosticInterpretation) (shapeInterpretation : framework.ShapeSensitivityInterpretation) : framework.effectiveRangeReductionModel |>.DirectSourceEffectiveRangeDerivationalReductionAt .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains := by have applicable := framework.bethe_source_inputs_make_shared_reduction_applicable comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification higherCalculation diagnostic shapeInterpretation exact framework.effectiveRangeReductionModel |>.source_derivation_and_technical_route_realize_effective_range_derivational_reduction .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains ⟨comparisonSetup, comparisonCalculation, formulaCalculation, approximationSetup, routeCalculation, identification, higherCalculation, diagnostic, shapeInterpretation⟩ applicable.2 /- Source: original PDF pp. 38-41, equations (10)-(16) and the higher-order discussion. Bethe's exact comparison identity, zero-energy replacement, and small-correction calculation directly realize the shared derivational reduction without recovering the detailed interaction shape. -/ theorem neutral_effective_range_routes_realize_derivational_reduction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.effectiveRangeReductionModel |>.DirectEffectiveRangeDerivationalReductionAt := framework.toLowEnergyEffectiveRangeContext |>.applicable_route_realizes_effective_range_derivational_reduction (framework.neutral_effective_range_routes_make_shared_route_applicable law accuracy) theorem neutral_effective_range_routes_establish_shared_reduction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.toLowEnergyEffectiveRangeContext |>.EstablishedEffectiveRangeReductionAt framework.effectiveRangeReductionModel := framework.toLowEnergyEffectiveRangeContext |>.applicable_route_establishes_effective_range_reduction (framework.neutral_effective_range_routes_make_shared_route_applicable law accuracy) /- Source: original PDF pp. 38-41, especially equations (7), (11), and (19). The selected neutral S-wave route produces the controlled two-parameter law while retaining the small higher-order correction and unresolved shape. -/ theorem neutral_effective_range_routes_exhibit_nonvacuous_shared_reduction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.effectiveRangeReductionModel |>.NonvacuousEffectiveRangeReductionAt := framework.toLowEnergyEffectiveRangeContext |>.established_reduction_exhibits_nonvacuous_effective_range_reduction (framework.neutral_effective_range_routes_establish_shared_reduction law accuracy) /- Source: original PDF pp. 38-41. Bethe's exact comparison identity, zero-energy interior replacement, and calculated small shape correction make the selected two-parameter law a controlled finite truncation in the nuclear low-energy regime. No empirical-adequacy or potential-shape claim is added. -/ theorem neutral_effective_range_routes_realize_controlled_truncation (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.effectiveRangeReductionModel |>.toEffectiveRangeTruncationAssessmentContext.ControlledAt framework.effectiveRangeReductionModel.twoParameterLaw framework.effectiveRangeReductionModel.regime := framework.toLowEnergyEffectiveRangeContext |>.established_effective_range_reduction_realizes_controlled_truncation (framework.neutral_effective_range_routes_establish_shared_reduction law accuracy) theorem established_bethe_reduction_realizes_every_shared_claim (framework : EffectiveRangeFramework T) (established : framework.toLowEnergyEffectiveRangeContext |>.EstablishedEffectiveRangeReductionAt framework.effectiveRangeReductionModel) : ∀ claim, framework.toLowEnergyEffectiveRangeContext |>.SharedClaimHoldsAt framework.effectiveRangeReductionModel claim := framework.toLowEnergyEffectiveRangeContext |>.established_reduction_realizes_every_shared_claim established /-- Ground the named low-energy model in Bethe's neutral S-wave, finite-range setting from Sections I-II, pp. 38-40. This step uses neither the comparison identity nor the controlled two-parameter and higher-order calculations. -/ theorem bethe_effective_range_model_inputs_establish_shared_grounding (framework : EffectiveRangeFramework T) (setup : framework.SharedLowEnergyEffectiveRangeGroundingSetup) : framework.toLowEnergyEffectiveRangeContext |>.TheoryModelGroundingAt framework.toLowEnergyEffectiveRangeInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeReductionModel := by apply framework.toLowEnergyEffectiveRangeContext |>.theory_model_inputs_establish_grounding framework.toLowEnergyEffectiveRangeInterpretation · exact framework |>.shared_grounding_setup_selects_low_energy_effective_range_setup setup · exact ⟨rfl, rfl⟩ · exact ⟨rfl, rfl, setup.1, setup.2.1⟩ · intro _claim modelClaim exact ⟨rfl, modelClaim⟩ · intro _claim modelClaim exact ⟨rfl, modelClaim⟩ theorem neutral_effective_range_routes_establish_grounded_shared_reduction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (accuracy : framework.EstablishedAccuracyAndShapeScope) : framework.toLowEnergyEffectiveRangeContext |>.TheoryModelGroundedEffectiveRangeReductionAt framework.toLowEnergyEffectiveRangeInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeReductionModel := by have established := framework.neutral_effective_range_routes_establish_shared_reduction law accuracy have neutralSetup := law.1.1 have localApproximation := law.2.1 exact framework.toLowEnergyEffectiveRangeContext |>.established_result_and_grounding_establish_grounded_result framework.toLowEnergyEffectiveRangeInterpretation established (framework.bethe_effective_range_model_inputs_establish_shared_grounding ⟨neutralSetup.1, neutralSetup.2.1, localApproximation⟩) theorem grounded_bethe_reduction_transfers_every_shared_claim (framework : EffectiveRangeFramework T) (grounded : framework.toLowEnergyEffectiveRangeContext |>.TheoryModelGroundedEffectiveRangeReductionAt framework.toLowEnergyEffectiveRangeInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeReductionModel) : ∀ claim, (framework.toLowEnergyEffectiveRangeContext.toTheoryModelContext framework.toLowEnergyEffectiveRangeInterpretation).theoryEntails (LowEnergyEffectiveRangeContext.effectiveRangeTheoryAt framework framework.effectiveRangeReductionModel) claim () ∧ (framework.toLowEnergyEffectiveRangeContext.toTheoryModelContext framework.toLowEnergyEffectiveRangeInterpretation).trueIn (LowEnergyEffectiveRangeContext.effectiveRangeWorldAt framework.neutronProtonTriplet framework.effectiveRangeReductionModel) claim () := framework.toLowEnergyEffectiveRangeContext |>.grounded_reduction_transfers_all_claims_to_theory_and_world framework.toLowEnergyEffectiveRangeInterpretation grounded /-- Paper-local realization of the repeated bound-state extraction inference. Bethe's comparison-wave derivation of the bound-state relation remains local; the shared component begins with its controlled output and the measured binding and scattering inputs on pp. 40-41, especially the relation in equation (19) and the extracted value in equation (27). -/ def toEffectiveRangeBoundStateExtractionContext (framework : EffectiveRangeFramework T) : EffectiveRangeBoundStateExtractionContext T.Channel T.Energy T.Regime Unit T.Experiment Real where reduction := framework.toLowEnergyEffectiveRangeContext selectedBoundStateEnergy := framework.deuteronBoundEnergy selectedExperiment := framework.neutronProtonExperiment selectedExtractedParameter := framework.reportedTripletEffectiveRange boundStateAt := framework.deuteronBoundStateAt uncoupledSWaveApproximationAt := fun _channel _energy regime => framework.tensorForceExtensionDeferredAt regime boundStateRelationCalculatedAt := framework.tripletBoundStateRelationCalculatedAt boundStateRelationControlledAt := framework.tripletBoundStateRelationControlledAt bindingDatumMeasuredAt := framework.deuteronBindingDatumMeasuredAt lowEnergyScatteringDatumMeasuredAt := fun experiment channel _selectedEnergy regime => framework.lowEnergyScatteringDatumMeasuredAt experiment channel regime parameterExtractedAt := framework.effectiveRangeExtractedAt parameterEstimateQualifiedAt := framework.reportedTripletEffectiveRangeQualifiedAt def effectiveRangeBoundStateExtractionModel (framework : EffectiveRangeFramework T) : EffectiveRangeBoundStateExtractionModel T.Channel T.Energy T.Regime Unit T.Experiment Real := framework.toEffectiveRangeBoundStateExtractionContext.selectedModel theorem effective_range_bound_state_extraction_model_retains_paper_semantics (framework : EffectiveRangeFramework T) : framework.toEffectiveRangeBoundStateExtractionContext |>.SelectedEffectiveRangeBoundStateExtractionSemanticsAt framework.effectiveRangeBoundStateExtractionModel := rfl def toEffectiveRangeBoundStateExtractionInterpretation (framework : EffectiveRangeFramework T) : EffectiveRangeBoundStateExtractionInterpretation (EffectiveRangeFramework T) T.Channel T.Channel T.Energy T.Regime Unit T.Experiment Real where theoryUsesExtractionModel := fun theory model => theory = framework ∧ model = framework.effectiveRangeBoundStateExtractionModel extractionModelRepresentsWorld := fun model world => model = framework.effectiveRangeBoundStateExtractionModel ∧ world = model.reduction.channel ∧ framework.sWaveChannelAt world model.reduction.regime ∧ framework.finiteRangeNuclearPotentialAt world framework.neutronProtonPotential model.reduction.regime theoryClaim := fun theory model claim => theory = framework ∧ (framework.toEffectiveRangeBoundStateExtractionContext |>.SharedClaimHoldsAt model claim) physicalClaim := fun world model claim => world = model.reduction.channel ∧ (framework.toEffectiveRangeBoundStateExtractionContext |>.SharedClaimHoldsAt model claim) /-- Bethe's pre-output setup for the shared bound-state extraction. The parent order-`k^2` law is already established, and the selected deuteron bound state, deferred tensor-force scope, plus binding and scattering data are available. No equation-(19) relation calculation, control output, extracted range, or qualification of that estimate is assumed. -/ def SharedBoundStateExtractionGroundingSetup (framework : EffectiveRangeFramework T) : Prop := (framework.toLowEnergyEffectiveRangeContext |>.EstablishedTwoParameterEffectiveRangeLawAt framework.effectiveRangeReductionModel) ∧ framework.TripletExtractionSetup theorem shared_bound_state_grounding_setup_selects_extraction_setup (framework : EffectiveRangeFramework T) (setup : framework.SharedBoundStateExtractionGroundingSetup) : framework.toEffectiveRangeBoundStateExtractionContext |>.SelectedEffectiveRangeBoundStateExtractionSetupAt framework.effectiveRangeBoundStateExtractionModel := by exact ⟨rfl, ⟨setup.1, setup.2.1.1, setup.2.1.2⟩, setup.2.2⟩ /-- Raw paper premises interpreting Bethe's bound-state extraction token. They retain the comparison-wave construction, controlled order-`k^2` reduction, deuteron/data setup, relation calculation, and empirical extraction as separate contracts rather than storing an established shared endpoint. -/ def BetheBoundStateExtractionDerivationObtains (framework : EffectiveRangeFramework T) : BetheBoundStateExtractionDerivation → Prop | .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction => framework.NeutralComparisonSetup ∧ framework.NeutralComparisonCalculation ∧ framework.NeutralRadialFormulaCalculation ∧ framework.EffectiveRangeApproximationSetup ∧ framework.EffectiveRangeRouteCalculation ∧ framework.EffectiveRangeIdentificationBridge ∧ framework.TripletExtractionSetup ∧ framework.TripletBoundStateRelationCalculation ∧ framework.TripletParameterExtractionCalculation theorem triplet_routes_make_shared_bound_state_extraction_applicable (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.TripletExtractionSetup) (calculation : framework.TripletExtractionCalculation) : framework.toEffectiveRangeBoundStateExtractionContext |>.EffectiveRangeBoundStateExtractionRouteApplicableAt framework.effectiveRangeBoundStateExtractionModel := by let context := framework.toEffectiveRangeBoundStateExtractionContext let model := framework.effectiveRangeBoundStateExtractionModel have selected : context.SelectedEffectiveRangeBoundStateExtractionSemanticsAt model := framework |>.effective_range_bound_state_extraction_model_retains_paper_semantics have parentLaw := framework.neutral_effective_range_law_establishes_shared_two_parameter_law law have boundSetup : context.BoundStateSetupAt model := ⟨parentLaw, setup.1.1, setup.1.2⟩ refine context.setup_calculations_and_data_make_route_applicable selected boundSetup ?_ ?_ ?_ · intro sharedBoundSetup have replayedLaw := framework |>.shared_established_two_parameter_law_recovers_neutral_effective_range_law law sharedBoundSetup.1 have radial := calculation.1 replayedLaw ⟨sharedBoundSetup.2.1, sharedBoundSetup.2.2⟩ exact ⟨framework.bound_comparison_identity_derives_equation_nineteen _ _ _ sharedBoundSetup.2.1 radial.1, radial.2⟩ · exact ⟨setup.2.1, setup.2.2⟩ · intro sharedBoundSetup relation controlled data have localSetup : framework.TripletExtractionSetup := ⟨sharedBoundSetup.2, data⟩ exact calculation.2 localSetup relation controlled /- Source: original PDF pp. 39-41, especially equations (7), (11), (16), and (19)-(27). The comparison identity and controlled interior replacement first produce the order-`k^2` law. Taking the second comparison state to be the deuteron ground state then yields the controlled relation, and the measured binding and low-energy scattering data determine the qualified triplet range. -/ theorem bethe_bound_state_source_inputs_make_shared_extraction_applicable (framework : EffectiveRangeFramework T) (comparisonSetup : framework.NeutralComparisonSetup) (comparisonCalculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) (approximationSetup : framework.EffectiveRangeApproximationSetup) (routeCalculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) (tripletSetup : framework.TripletExtractionSetup) (relationCalculation : framework.TripletBoundStateRelationCalculation) (parameterCalculation : framework.TripletParameterExtractionCalculation) : framework.toEffectiveRangeBoundStateExtractionContext |>.EffectiveRangeBoundStateExtractionRouteApplicableAt framework.effectiveRangeBoundStateExtractionModel := by have neutral := framework.radial_comparison_yields_exact_neutral_identity comparisonSetup comparisonCalculation formulaCalculation have law := framework.controlled_zero_energy_replacement_yields_effective_range_law neutral approximationSetup routeCalculation identification exact framework.triplet_routes_make_shared_bound_state_extraction_applicable law tripletSetup ⟨relationCalculation, parameterCalculation⟩ /-- Bethe's raw comparison/ground-state/data route realizes the source-sensitive shared explanation. No established shared extraction, nonvacuous endpoint, ordinary explanation, or evidence-support endpoint is a premise. -/ theorem bethe_bound_state_source_inputs_realize_source_structural_extraction_explanation (framework : EffectiveRangeFramework T) (comparisonSetup : framework.NeutralComparisonSetup) (comparisonCalculation : framework.NeutralComparisonCalculation) (formulaCalculation : framework.NeutralRadialFormulaCalculation) (approximationSetup : framework.EffectiveRangeApproximationSetup) (routeCalculation : framework.EffectiveRangeRouteCalculation) (identification : framework.EffectiveRangeIdentificationBridge) (tripletSetup : framework.TripletExtractionSetup) (relationCalculation : framework.TripletBoundStateRelationCalculation) (parameterCalculation : framework.TripletParameterExtractionCalculation) : framework.toEffectiveRangeBoundStateExtractionContext |>.SourceStructuralEffectiveRangeBoundStateExtractionExplanationAt framework.effectiveRangeBoundStateExtractionModel .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction framework.BetheBoundStateExtractionDerivationObtains := by have applicable := framework.bethe_bound_state_source_inputs_make_shared_extraction_applicable comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification tripletSetup relationCalculation parameterCalculation exact framework.toEffectiveRangeBoundStateExtractionContext |>.source_derivation_and_applicable_route_realize_structural_effective_range_bound_state_extraction_explanation .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction framework.BetheBoundStateExtractionDerivationObtains ⟨comparisonSetup, comparisonCalculation, formulaCalculation, approximationSetup, routeCalculation, identification, tripletSetup, relationCalculation, parameterCalculation⟩ applicable /-- The joining source keeps Bethe's two independently controlled histories, the printed comparison-wave/range formulas, deuteron ground-state specialization, both measured evidence inputs, and the explicitly qualified triplet estimate. -/ def betheEffectiveRangeBoundStateHandoffDerivationObtains (framework : EffectiveRangeFramework T) : BetheEffectiveRangeBoundStateHandoffDerivation -> Prop | .radialComparisonGroundStateSpecializationControlledRangeAndTripletEvidence => framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityAndInteriorReplacement ∧ framework.BetheBoundStateExtractionDerivationObtains .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction ∧ framework.NeutralRadialFormulaReadoutAt ∧ framework.TripletBoundStateSetup ∧ framework.TripletEmpiricalExtractionSetup ∧ framework.tripletBoundStateRelationCalculatedAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.tripletBoundStateRelationControlledAt framework.neutronProtonTriplet framework.deuteronBoundEnergy framework.nuclearRegime ∧ framework.effectiveRangeExtractedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime ∧ framework.reportedTripletEffectiveRangeQualifiedAt framework.neutronProtonExperiment framework.neutronProtonTriplet framework.reportedTripletEffectiveRange framework.nuclearRegime /-- Bethe's complete comparison-to-deuteron composition requires the separate higher-order reduction source in addition to the distinct empirical extraction source; neither source manufactures the other's missing premises. -/ theorem bethe_comparison_ground_state_and_triplet_evidence_realize_source_sensitive_bound_state_extraction (framework : EffectiveRangeFramework T) (reductionSource : framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityAndInteriorReplacement) (extractionSource : framework.BetheBoundStateExtractionDerivationObtains .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction) : framework.toEffectiveRangeBoundStateExtractionContext |>.SourceSensitiveEffectiveRangeBoundStateExtractionAt framework.effectiveRangeBoundStateExtractionModel .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction framework.BetheBoundStateExtractionDerivationObtains .radialComparisonGroundStateSpecializationControlledRangeAndTripletEvidence framework.betheEffectiveRangeBoundStateHandoffDerivationObtains := by rcases extractionSource with ⟨comparisonSetup, comparisonCalculation, formulaCalculation, approximationSetup, routeCalculation, identification, tripletSetup, relationCalculation, parameterCalculation⟩ have extractionRealized : framework.BetheBoundStateExtractionDerivationObtains .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction := ⟨comparisonSetup, comparisonCalculation, formulaCalculation, approximationSetup, routeCalculation, identification, tripletSetup, relationCalculation, parameterCalculation⟩ have route := framework.bethe_bound_state_source_inputs_make_shared_extraction_applicable comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification tripletSetup relationCalculation parameterCalculation have established := framework.toEffectiveRangeBoundStateExtractionContext |>.applicable_route_establishes_effective_range_bound_state_extraction route have reductionExplanation : framework.toEffectiveRangeBoundStateExtractionContext.reduction |>.DirectSourceStructuralEffectiveRangeReductionExplanationAt framework.effectiveRangeBoundStateExtractionModel.reduction .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains := by change framework.toLowEnergyEffectiveRangeContext |>.DirectSourceStructuralEffectiveRangeReductionExplanationAt framework.effectiveRangeReductionModel .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains exact framework |>.bethe_source_inputs_realize_source_structural_effective_range_reduction_explanation reductionSource have extractionExplanation := framework |>.bethe_bound_state_source_inputs_realize_source_structural_extraction_explanation comparisonSetup comparisonCalculation formulaCalculation approximationSetup routeCalculation identification tripletSetup relationCalculation parameterCalculation rcases established.2 with ⟨parentLaw, boundState, uncoupled, boundRelation, controlledRelation, bindingDatum, scatteringDatum, extractedParameter, qualifiedEstimate⟩ have extracted : framework.effectiveRangeBoundStateExtractionModel |>.NonvacuousEffectiveRangeBoundStateExtractionAt := ⟨parentLaw, boundState, uncoupled, boundRelation, controlledRelation, bindingDatum, scatteringDatum, extractedParameter, qualifiedEstimate⟩ have handoff : framework.betheEffectiveRangeBoundStateHandoffDerivationObtains .radialComparisonGroundStateSpecializationControlledRangeAndTripletEvidence := ⟨reductionSource, extractionRealized, framework.lower_radial_inputs_derive_the_source_formula_readout comparisonSetup (formulaCalculation comparisonSetup), tripletSetup.1, tripletSetup.2, boundRelation, controlledRelation, extractedParameter, qualifiedEstimate⟩ exact framework.toEffectiveRangeBoundStateExtractionContext |>.reduction_extraction_and_handoff_sources_realize_source_sensitive_bound_state_extraction .comparisonIdentityAndInteriorReplacement framework.BetheEffectiveRangeDerivationObtains .comparisonIdentityGroundStateSpecializationAndEmpiricalExtraction framework.BetheBoundStateExtractionDerivationObtains .radialComparisonGroundStateSpecializationControlledRangeAndTripletEvidence framework.betheEffectiveRangeBoundStateHandoffDerivationObtains framework.effective_range_bound_state_extraction_model_retains_paper_semantics extracted reductionExplanation extractionExplanation handoff theorem triplet_routes_establish_shared_bound_state_extraction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.TripletExtractionSetup) (calculation : framework.TripletExtractionCalculation) : framework.toEffectiveRangeBoundStateExtractionContext |>.EstablishedEffectiveRangeBoundStateExtractionAt framework.effectiveRangeBoundStateExtractionModel := framework.toEffectiveRangeBoundStateExtractionContext |>.applicable_route_establishes_effective_range_bound_state_extraction (framework |>.triplet_routes_make_shared_bound_state_extraction_applicable law setup calculation) /- Source: original PDF pp. 40-41, equations (19)-(27). The deuteron binding datum and low-energy scattering data enter the controlled bound-state relation before the triplet effective range is extracted; the interaction shape remains unresolved. -/ theorem triplet_routes_exhibit_nonvacuous_shared_bound_state_extraction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.TripletExtractionSetup) (calculation : framework.TripletExtractionCalculation) : framework.effectiveRangeBoundStateExtractionModel |>.NonvacuousEffectiveRangeBoundStateExtractionAt := framework.toEffectiveRangeBoundStateExtractionContext |>.established_extraction_exhibits_nonvacuous_bound_state_extraction (framework.triplet_routes_establish_shared_bound_state_extraction law setup calculation) /-- Bethe's measured binding and scattering package supports the selected qualified triplet effective-range estimate only through the controlled equation (19) bound-state relation and equation (27) extraction. -/ theorem triplet_routes_realize_qualified_parameter_evidence_support (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.TripletExtractionSetup) (calculation : framework.TripletExtractionCalculation) : framework.effectiveRangeBoundStateExtractionModel |>.QualifiedParameterEvidenceSupportAt := framework.toEffectiveRangeBoundStateExtractionContext |>.established_extraction_realizes_qualified_parameter_evidence_support (framework.triplet_routes_establish_shared_bound_state_extraction law setup calculation) theorem established_bethe_bound_state_extraction_realizes_every_shared_claim (framework : EffectiveRangeFramework T) (established : framework.toEffectiveRangeBoundStateExtractionContext |>.EstablishedEffectiveRangeBoundStateExtractionAt framework.effectiveRangeBoundStateExtractionModel) : ∀ claim, framework.toEffectiveRangeBoundStateExtractionContext |>.SharedClaimHoldsAt framework.effectiveRangeBoundStateExtractionModel claim := framework.toEffectiveRangeBoundStateExtractionContext |>.established_extraction_realizes_every_shared_claim established /-- Ground the named extraction model from the established parent two-parameter law and Bethe's selected deuteron, deferred tensor-force scope, binding datum, and low-energy scattering datum on pp. 40-41. This step uses neither the equation (19) relation calculation and control output nor the parameter extraction and qualification in equation (27). -/ theorem bethe_bound_state_model_inputs_establish_shared_grounding (framework : EffectiveRangeFramework T) (setup : framework.SharedBoundStateExtractionGroundingSetup) : framework.toEffectiveRangeBoundStateExtractionContext |>.TheoryModelGroundingAt framework.toEffectiveRangeBoundStateExtractionInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeBoundStateExtractionModel := by apply framework.toEffectiveRangeBoundStateExtractionContext |>.theory_model_inputs_establish_grounding framework.toEffectiveRangeBoundStateExtractionInterpretation · exact framework |>.shared_bound_state_grounding_setup_selects_extraction_setup setup · exact ⟨rfl, rfl⟩ · exact ⟨rfl, rfl, setup.1.2.1.2.1, setup.1.2.1.2.2.1⟩ · intro _claim modelClaim exact ⟨rfl, modelClaim⟩ · intro _claim modelClaim exact ⟨rfl, modelClaim⟩ theorem triplet_routes_establish_grounded_shared_bound_state_extraction (framework : EffectiveRangeFramework T) (law : framework.EstablishedNeutralEffectiveRangeLaw) (setup : framework.TripletExtractionSetup) (calculation : framework.TripletExtractionCalculation) : framework.toEffectiveRangeBoundStateExtractionContext |>.TheoryModelGroundedEffectiveRangeBoundStateExtractionAt framework.toEffectiveRangeBoundStateExtractionInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeBoundStateExtractionModel := by have established := framework.triplet_routes_establish_shared_bound_state_extraction law setup calculation have parentLaw := framework.neutral_effective_range_law_establishes_shared_two_parameter_law law exact framework.toEffectiveRangeBoundStateExtractionContext |>.established_extraction_and_grounding_establish_grounded_result framework.toEffectiveRangeBoundStateExtractionInterpretation established (framework |>.bethe_bound_state_model_inputs_establish_shared_grounding ⟨parentLaw, setup⟩) theorem grounded_bethe_bound_state_extraction_transfers_every_shared_claim (framework : EffectiveRangeFramework T) (grounded : framework.toEffectiveRangeBoundStateExtractionContext |>.TheoryModelGroundedEffectiveRangeBoundStateExtractionAt framework.toEffectiveRangeBoundStateExtractionInterpretation framework framework.neutronProtonTriplet framework.effectiveRangeBoundStateExtractionModel) : ∀ claim, (framework.toEffectiveRangeBoundStateExtractionContext |>.toTheoryModelContext framework.toEffectiveRangeBoundStateExtractionInterpretation |>.theoryEntails (EffectiveRangeBoundStateExtractionContext.extractionTheoryAt framework framework.effectiveRangeBoundStateExtractionModel) claim ()) ∧ (framework.toEffectiveRangeBoundStateExtractionContext |>.toTheoryModelContext framework.toEffectiveRangeBoundStateExtractionInterpretation |>.trueIn (EffectiveRangeBoundStateExtractionContext.extractionWorldAt framework.neutronProtonTriplet framework.effectiveRangeBoundStateExtractionModel) claim ()) := framework.toEffectiveRangeBoundStateExtractionContext |>.grounded_extraction_transfers_all_claims_to_theory_and_world framework.toEffectiveRangeBoundStateExtractionInterpretation grounded def CompleteScopedResult (framework : EffectiveRangeFramework T) : Prop := framework.EstablishedNeutralComparison ∧ framework.EstablishedNeutralEffectiveRangeLaw ∧ framework.EstablishedNeutralCrossSectionAssessment ∧ framework.EstablishedAccuracyAndShapeScope ∧ framework.EstablishedTripletExtraction ∧ framework.SingletRangeAssessment ∧ framework.EstablishedCoulombEffectiveRangeLaw ∧ framework.EstablishedCoulombNeutralization ∧ framework.EstablishedCoulombThreshold ∧ framework.EstablishedProtonProtonEmpiricalResult ∧ framework.EstablishedChargeComparison ∧ framework.EstablishedChargeShapeAssessment ∧ framework.PaperScopeQualifications theorem independent_routes_establish_complete_scoped_result (framework : EffectiveRangeFramework T) (neutral : framework.EstablishedNeutralComparison) (law : framework.EstablishedNeutralEffectiveRangeLaw) (crossSection : framework.EstablishedNeutralCrossSectionAssessment) (accuracy : framework.EstablishedAccuracyAndShapeScope) (triplet : framework.EstablishedTripletExtraction) (singlet : framework.SingletRangeAssessment) (coulomb : framework.EstablishedCoulombEffectiveRangeLaw) (neutralization : framework.EstablishedCoulombNeutralization) (threshold : framework.EstablishedCoulombThreshold) (proton : framework.EstablishedProtonProtonEmpiricalResult) (comparison : framework.EstablishedChargeComparison) (shapes : framework.EstablishedChargeShapeAssessment) (scope : framework.PaperScopeQualifications) : framework.CompleteScopedResult := ⟨neutral, law, crossSection, accuracy, triplet, singlet, coulomb, neutralization, threshold, proton, comparison, shapes, scope⟩ namespace Countermodels /-- Reduced selected-energy readout. The sine and cosine are retained as physical values constrained by the trigonometric identity; this allows exact rational countermodels without obscuring the source-level phase semantics. -/ structure ReducedWavePhaseCrossSectionReadout where waveNumberValue : Real waveNumberSquaredValue : Real phaseSineValue : Real phaseCosineValue : Real phaseFunctionValue : Real selectedCrossSectionValue : Real def ReducedWavePhaseCrossSectionReadout.HasPositiveScatteringDomain (readout : ReducedWavePhaseCrossSectionReadout) : Prop := 0 < readout.waveNumberSquaredValue ∧ 0 < readout.selectedCrossSectionValue ∧ readout.phaseSineValue ≠ 0 ∧ readout.phaseSineValue ^ 2 + readout.phaseCosineValue ^ 2 = 1 def ReducedWavePhaseCrossSectionReadout.RetainsDenominatorCrossSectionFormula (readout : ReducedWavePhaseCrossSectionReadout) : Prop := readout.selectedCrossSectionValue = (4 * Real.pi) / (readout.waveNumberSquaredValue + readout.phaseFunctionValue ^ 2) def ReducedWavePhaseCrossSectionReadout.HasPhysicalWaveSquare (readout : ReducedWavePhaseCrossSectionReadout) : Prop := readout.waveNumberSquaredValue = readout.waveNumberValue ^ 2 def ReducedWavePhaseCrossSectionReadout.HasPhysicalPhaseFunction (readout : ReducedWavePhaseCrossSectionReadout) : Prop := readout.phaseFunctionValue = readout.waveNumberValue * (readout.phaseCosineValue / readout.phaseSineValue) def ReducedWavePhaseCrossSectionReadout.RetainsSineSquaredCrossSectionFormula (readout : ReducedWavePhaseCrossSectionReadout) : Prop := readout.selectedCrossSectionValue = (4 * Real.pi * readout.phaseSineValue ^ 2) / readout.waveNumberSquaredValue noncomputable def inconsistentWaveSquareWithExactDenominatorFormula : ReducedWavePhaseCrossSectionReadout := { waveNumberValue := 1 waveNumberSquaredValue := 2 phaseSineValue := 3 / 5 phaseCosineValue := 4 / 5 phaseFunctionValue := 4 / 3 selectedCrossSectionValue := (18 / 17) * Real.pi } /-- Even an exact denominator formula with a physical `k cot delta` readout does not recover Bethe's sine-squared formula if the purported `k^2` is not the square of the same selected wave number. -/ theorem exact_phase_function_without_wave_square_does_not_supply_sine_squared_formula : (inconsistentWaveSquareWithExactDenominatorFormula.HasPositiveScatteringDomain ∧ inconsistentWaveSquareWithExactDenominatorFormula.RetainsDenominatorCrossSectionFormula ∧ inconsistentWaveSquareWithExactDenominatorFormula.HasPhysicalPhaseFunction) ∧ ¬inconsistentWaveSquareWithExactDenominatorFormula.HasPhysicalWaveSquare ∧ ¬inconsistentWaveSquareWithExactDenominatorFormula.RetainsSineSquaredCrossSectionFormula := by constructor · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.HasPositiveScatteringDomain, inconsistentWaveSquareWithExactDenominatorFormula, Real.pi_pos] rfl · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.RetainsDenominatorCrossSectionFormula, inconsistentWaveSquareWithExactDenominatorFormula] ring · norm_num [ReducedWavePhaseCrossSectionReadout.HasPhysicalPhaseFunction, inconsistentWaveSquareWithExactDenominatorFormula] · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.HasPhysicalWaveSquare, inconsistentWaveSquareWithExactDenominatorFormula] · intro sineFormula norm_num [ReducedWavePhaseCrossSectionReadout.RetainsSineSquaredCrossSectionFormula, inconsistentWaveSquareWithExactDenominatorFormula] at sineFormula nlinarith [Real.pi_pos] noncomputable def inconsistentPhaseFunctionWithExactDenominatorFormula : ReducedWavePhaseCrossSectionReadout := { waveNumberValue := 1 waveNumberSquaredValue := 1 phaseSineValue := 3 / 5 phaseCosineValue := 4 / 5 phaseFunctionValue := 0 selectedCrossSectionValue := 4 * Real.pi } /-- An exact positive-domain denominator formula with genuine `k^2` still does not recover the sine-squared cross section when its named phase function is unrelated to the selected physical `k cot delta`. -/ theorem exact_wave_square_without_phase_readout_does_not_supply_sine_squared_formula : (inconsistentPhaseFunctionWithExactDenominatorFormula.HasPositiveScatteringDomain ∧ inconsistentPhaseFunctionWithExactDenominatorFormula.RetainsDenominatorCrossSectionFormula ∧ inconsistentPhaseFunctionWithExactDenominatorFormula.HasPhysicalWaveSquare) ∧ ¬inconsistentPhaseFunctionWithExactDenominatorFormula.HasPhysicalPhaseFunction ∧ ¬inconsistentPhaseFunctionWithExactDenominatorFormula.RetainsSineSquaredCrossSectionFormula := by constructor · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.HasPositiveScatteringDomain, inconsistentPhaseFunctionWithExactDenominatorFormula, Real.pi_pos] rfl · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.RetainsDenominatorCrossSectionFormula, inconsistentPhaseFunctionWithExactDenominatorFormula] · norm_num [ReducedWavePhaseCrossSectionReadout.HasPhysicalWaveSquare, inconsistentPhaseFunctionWithExactDenominatorFormula] · constructor · norm_num [ReducedWavePhaseCrossSectionReadout.HasPhysicalPhaseFunction, inconsistentPhaseFunctionWithExactDenominatorFormula] · intro sineFormula norm_num [ReducedWavePhaseCrossSectionReadout.RetainsSineSquaredCrossSectionFormula, inconsistentPhaseFunctionWithExactDenominatorFormula] at sineFormula structure ReducedEquationSeventeenCrossSectionModel where waveNumberSquaredValue : Real phaseFunctionValue : Real selectedCrossSectionValue : Real def hasNamedNeutralCrossSectionCalculation (model : ReducedEquationSeventeenCrossSectionModel) : Prop := 0 < model.waveNumberSquaredValue /\ 0 ≤ model.selectedCrossSectionValue def retainsEquationSeventeenCrossSectionValue (model : ReducedEquationSeventeenCrossSectionModel) : Prop := model.selectedCrossSectionValue = (4 * Real.pi) / (model.waveNumberSquaredValue + model.phaseFunctionValue ^ 2) def hasPositiveWaveNumberAndCrossSection (model : ReducedEquationSeventeenCrossSectionModel) : Prop := 0 < model.waveNumberSquaredValue ∧ 0 < model.selectedCrossSectionValue def saturatesNeutralUnitarityMaximum (model : ReducedEquationSeventeenCrossSectionModel) : Prop := model.selectedCrossSectionValue = (4 * Real.pi) / model.waveNumberSquaredValue def zeroWaveNumberEquationSeventeenModel : ReducedEquationSeventeenCrossSectionModel := { waveNumberSquaredValue := 0 phaseFunctionValue := 0 selectedCrossSectionValue := 0 } /-- Lean's totalized zero division makes the displayed equation true at `k^2 = 0` without giving a physical positive cross section or domain. -/ theorem equation_seventeen_without_positive_wave_number_is_not_physical : retainsEquationSeventeenCrossSectionValue zeroWaveNumberEquationSeventeenModel ∧ ¬hasPositiveWaveNumberAndCrossSection zeroWaveNumberEquationSeventeenModel := by norm_num [retainsEquationSeventeenCrossSectionValue, hasPositiveWaveNumberAndCrossSection, zeroWaveNumberEquationSeventeenModel] noncomputable def nonzeroPhaseBelowUnitarityMaximumModel : ReducedEquationSeventeenCrossSectionModel := { waveNumberSquaredValue := 1 phaseFunctionValue := 1 selectedCrossSectionValue := 2 * Real.pi } /-- A positive cross section satisfying the exact printed equation does not reach the permitted maximum unless the actual phase function vanishes. -/ theorem equation_seventeen_without_zero_phase_does_not_reach_maximum : (hasPositiveWaveNumberAndCrossSection nonzeroPhaseBelowUnitarityMaximumModel ∧ retainsEquationSeventeenCrossSectionValue nonzeroPhaseBelowUnitarityMaximumModel) ∧ ¬saturatesNeutralUnitarityMaximum nonzeroPhaseBelowUnitarityMaximumModel := by constructor · constructor · norm_num [hasPositiveWaveNumberAndCrossSection, nonzeroPhaseBelowUnitarityMaximumModel, Real.pi_pos] · norm_num [retainsEquationSeventeenCrossSectionValue, nonzeroPhaseBelowUnitarityMaximumModel] ring · intro maximum norm_num [saturatesNeutralUnitarityMaximum, nonzeroPhaseBelowUnitarityMaximumModel] at maximum def wrongEquationSeventeenCrossSectionModel : ReducedEquationSeventeenCrossSectionModel := { waveNumberSquaredValue := 1 phaseFunctionValue := 0 selectedCrossSectionValue := 0 } theorem named_neutral_cross_section_does_not_supply_equation_seventeen_formula : hasNamedNeutralCrossSectionCalculation wrongEquationSeventeenCrossSectionModel ∧ ¬retainsEquationSeventeenCrossSectionValue wrongEquationSeventeenCrossSectionModel := by norm_num [hasNamedNeutralCrossSectionCalculation, retainsEquationSeventeenCrossSectionValue, wrongEquationSeventeenCrossSectionModel, Real.pi_ne_zero] structure ReducedBoundStateReadout where bindingWaveNumberValue : Real boundEnergyValue : Real reciprocalScatteringLengthValue : Real energyDependentRangeValue : Real def ReducedBoundStateReadout.HasSelectedBoundState (readout : ReducedBoundStateReadout) : Prop := 0 < readout.bindingWaveNumberValue /\ readout.boundEnergyValue = -readout.bindingWaveNumberValue ^ 2 def ReducedBoundStateReadout.RetainsEquationNineteen (readout : ReducedBoundStateReadout) : Prop := readout.reciprocalScatteringLengthValue = readout.bindingWaveNumberValue - (1 / 2 : Real) * readout.bindingWaveNumberValue ^ 2 * readout.energyDependentRangeValue def boundStateWithoutEquationNineteen : ReducedBoundStateReadout where bindingWaveNumberValue := 1 boundEnergyValue := -1 reciprocalScatteringLengthValue := 0 energyDependentRangeValue := 0 theorem bound_state_label_does_not_supply_equation_nineteen : boundStateWithoutEquationNineteen.HasSelectedBoundState ∧ ¬boundStateWithoutEquationNineteen.RetainsEquationNineteen := by norm_num [ReducedBoundStateReadout.HasSelectedBoundState, ReducedBoundStateReadout.RetainsEquationNineteen, boundStateWithoutEquationNineteen] structure ReducedComparisonReadout where waveNumberSquaredValue : Real reciprocalScatteringLengthValue : Real energyDependentRangeValue : Real zeroEnergyEffectiveRangeValue : Real phaseFunctionValue : Real replacementToleranceValue : Real def ReducedComparisonReadout.ExactComparisonIdentity (readout : ReducedComparisonReadout) : Prop := 0 < readout.waveNumberSquaredValue /\ readout.phaseFunctionValue = -readout.reciprocalScatteringLengthValue + (1 / 2 : Real) * readout.waveNumberSquaredValue * readout.energyDependentRangeValue def ReducedComparisonReadout.ControlledLowEnergyReplacement (readout : ReducedComparisonReadout) : Prop := 0 < readout.replacementToleranceValue /\ abs (readout.energyDependentRangeValue - readout.zeroEnergyEffectiveRangeValue) ≤ readout.replacementToleranceValue def exactComparisonWithoutReplacement : ReducedComparisonReadout where waveNumberSquaredValue := 1 reciprocalScatteringLengthValue := 0 energyDependentRangeValue := 2 zeroEnergyEffectiveRangeValue := 0 phaseFunctionValue := 1 replacementToleranceValue := 1 theorem exact_comparison_identity_does_not_supply_low_energy_replacement : exactComparisonWithoutReplacement.ExactComparisonIdentity ∧ ¬exactComparisonWithoutReplacement.ControlledLowEnergyReplacement := by norm_num [ReducedComparisonReadout.ExactComparisonIdentity, ReducedComparisonReadout.ControlledLowEnergyReplacement, exactComparisonWithoutReplacement] structure ReducedShapeResolutionReadout where effectiveRangeValue : Real lowEnergyResidualValue : Real experimentalToleranceValue : Real squareWellPredictionValue : Real longTailPredictionValue : Real def ReducedShapeResolutionReadout.AccurateTwoParameterLaw (readout : ReducedShapeResolutionReadout) : Prop := 0 < readout.effectiveRangeValue /\ 0 < readout.experimentalToleranceValue /\ abs readout.lowEnergyResidualValue ≤ readout.experimentalToleranceValue def ReducedShapeResolutionReadout.PotentialShapeResolved (readout : ReducedShapeResolutionReadout) : Prop := readout.experimentalToleranceValue < abs (readout.squareWellPredictionValue - readout.longTailPredictionValue) noncomputable def accurateLawWithoutShapeResolution : ReducedShapeResolutionReadout where effectiveRangeValue := 1 lowEnergyResidualValue := 0 experimentalToleranceValue := 1 squareWellPredictionValue := 0 longTailPredictionValue := 1 / 2 theorem accurate_two_parameter_law_does_not_determine_potential_shape : accurateLawWithoutShapeResolution.AccurateTwoParameterLaw ∧ ¬accurateLawWithoutShapeResolution.PotentialShapeResolved := by norm_num [ReducedShapeResolutionReadout.AccurateTwoParameterLaw, ReducedShapeResolutionReadout.PotentialShapeResolved, accurateLawWithoutShapeResolution] structure ReducedSingletQualificationReadout where protonEffectiveRangeValue : Real neutronProtonSingletRangeValue : Real protonChargeCalculationResidualValue : Real singletRangeToleranceValue : Real def ReducedSingletQualificationReadout.ProtonChargeCalculation (readout : ReducedSingletQualificationReadout) : Prop := 0 < readout.protonEffectiveRangeValue /\ readout.protonChargeCalculationResidualValue = 0 def ReducedSingletQualificationReadout.SingletRangeQualified (readout : ReducedSingletQualificationReadout) : Prop := 0 < readout.singletRangeToleranceValue /\ abs (readout.neutronProtonSingletRangeValue - readout.protonEffectiveRangeValue) ≤ readout.singletRangeToleranceValue def protonCalculationWithoutSingletQualification : ReducedSingletQualificationReadout where protonEffectiveRangeValue := 2 neutronProtonSingletRangeValue := 4 protonChargeCalculationResidualValue := 0 singletRangeToleranceValue := 1 theorem proton_charge_calculation_does_not_supply_singlet_range_qualification : protonCalculationWithoutSingletQualification.ProtonChargeCalculation ∧ ¬protonCalculationWithoutSingletQualification.SingletRangeQualified := by norm_num [ReducedSingletQualificationReadout.ProtonChargeCalculation, ReducedSingletQualificationReadout.SingletRangeQualified, protonCalculationWithoutSingletQualification, abs_of_pos] change (1 : Real) < abs (2 : Real) norm_num structure ReducedBorrowedRangeReadout where protonForceStrengthValue : Real neutronProtonForceStrengthValue : Real forceDifferenceToleranceValue : Real protonEffectiveRangeValue : Real neutronProtonSingletRangeValue : Real def ReducedBorrowedRangeReadout.ApproximateSingletForceEquality (readout : ReducedBorrowedRangeReadout) : Prop := 0 < readout.forceDifferenceToleranceValue /\ abs (readout.neutronProtonForceStrengthValue - readout.protonForceStrengthValue) ≤ readout.forceDifferenceToleranceValue def ReducedBorrowedRangeReadout.BorrowedRange (readout : ReducedBorrowedRangeReadout) : Prop := readout.neutronProtonSingletRangeValue = readout.protonEffectiveRangeValue noncomputable def approximateForceEqualityWithoutBorrowedRange : ReducedBorrowedRangeReadout where protonForceStrengthValue := 1 neutronProtonForceStrengthValue := 3 / 2 forceDifferenceToleranceValue := 1 protonEffectiveRangeValue := 2 neutronProtonSingletRangeValue := 3 theorem approximate_singlet_force_equality_does_not_supply_borrowed_range : approximateForceEqualityWithoutBorrowedRange.ApproximateSingletForceEquality ∧ ¬approximateForceEqualityWithoutBorrowedRange.BorrowedRange := by norm_num [ReducedBorrowedRangeReadout.ApproximateSingletForceEquality, ReducedBorrowedRangeReadout.BorrowedRange, approximateForceEqualityWithoutBorrowedRange] theorem approximate_charge_independence_does_not_establish_exact_equality : CoulombChargeComparison.PotentialParameters.slightlyShallowerSquare.RelativeDifferenceAt CoulombChargeComparison.PotentialParameters.shortSquare (3 / 100) ∧ ¬∀ radius : Real, 0 < radius -> CoulombChargeComparison.PotentialParameters.slightlyShallowerSquare.value radius = CoulombChargeComparison.PotentialParameters.shortSquare.value radius := by have witness := CoulombChargeComparison.PotentialParameters.a_common_shape_realizes_nonzero_but_controlled_potential_difference exact ⟨witness.2.2.2.1, fun equal => witness.2.2.2.2 (equal (1 / 2) (by norm_num))⟩ structure ReducedPhaseCrossSectionReadout where waveNumberSquaredValue : Real reciprocalScatteringLengthValue : Real effectiveRangeValue : Real phaseFunctionValue : Real selectedCrossSectionValue : Real def ReducedPhaseCrossSectionReadout.PhaseLawAvailable (readout : ReducedPhaseCrossSectionReadout) : Prop := 0 < readout.waveNumberSquaredValue /\ readout.phaseFunctionValue = -readout.reciprocalScatteringLengthValue + (1 / 2 : Real) * readout.waveNumberSquaredValue * readout.effectiveRangeValue def ReducedPhaseCrossSectionReadout.ObservableCrossSectionCalculationAvailable (readout : ReducedPhaseCrossSectionReadout) : Prop := readout.selectedCrossSectionValue = (4 * Real.pi) / (readout.waveNumberSquaredValue + readout.phaseFunctionValue ^ 2) def phaseLawWithoutCrossSection : ReducedPhaseCrossSectionReadout where waveNumberSquaredValue := 1 reciprocalScatteringLengthValue := 1 effectiveRangeValue := 2 phaseFunctionValue := 0 selectedCrossSectionValue := 0 theorem a_phase_law_does_not_supply_the_observable_cross_section_calculation : phaseLawWithoutCrossSection.PhaseLawAvailable ∧ ¬phaseLawWithoutCrossSection.ObservableCrossSectionCalculationAvailable := by norm_num [ReducedPhaseCrossSectionReadout.PhaseLawAvailable, ReducedPhaseCrossSectionReadout.ObservableCrossSectionCalculationAvailable, phaseLawWithoutCrossSection, Real.pi_ne_zero] structure ReducedUnitarityTruncationReadout where waveNumberSquaredValue : Real selectedCrossSectionValue : Real effectiveRangeValue : Real truncationToleranceValue : Real def ReducedUnitarityTruncationReadout.UnitarityBoundRetained (readout : ReducedUnitarityTruncationReadout) : Prop := 0 < readout.waveNumberSquaredValue /\ 0 ≤ readout.selectedCrossSectionValue /\ readout.selectedCrossSectionValue ≤ (4 * Real.pi) / readout.waveNumberSquaredValue def ReducedUnitarityTruncationReadout.TwoParameterTruncationControlled (readout : ReducedUnitarityTruncationReadout) : Prop := 0 < readout.truncationToleranceValue /\ readout.waveNumberSquaredValue * readout.effectiveRangeValue ^ 2 ≤ readout.truncationToleranceValue def unitarityBoundWithoutControlledTruncation : ReducedUnitarityTruncationReadout where waveNumberSquaredValue := 1 selectedCrossSectionValue := 0 effectiveRangeValue := 2 truncationToleranceValue := 1 theorem a_unitarity_bound_does_not_license_the_low_order_truncation_at_its_maximum : unitarityBoundWithoutControlledTruncation.UnitarityBoundRetained ∧ ¬unitarityBoundWithoutControlledTruncation.TwoParameterTruncationControlled := by constructor · norm_num [ReducedUnitarityTruncationReadout.UnitarityBoundRetained, unitarityBoundWithoutControlledTruncation] positivity · norm_num [ReducedUnitarityTruncationReadout.TwoParameterTruncationControlled, unitarityBoundWithoutControlledTruncation] structure ReducedCrossChannelShapeReadout where tripletIntrinsicRangeValue : Real singletIntrinsicRangeValue : Real intrinsicRangeToleranceValue : Real singleChannelCurvatureValue : Real curvatureUncertaintyValue : Real def ReducedCrossChannelShapeReadout.PermitsCommonIntrinsicRange (readout : ReducedCrossChannelShapeReadout) : Prop := 0 < readout.intrinsicRangeToleranceValue /\ abs (readout.tripletIntrinsicRangeValue - readout.singletIntrinsicRangeValue) ≤ readout.intrinsicRangeToleranceValue def ReducedCrossChannelShapeReadout.SelectedBySingleChannelEnergyDependence (readout : ReducedCrossChannelShapeReadout) : Prop := readout.curvatureUncertaintyValue < abs readout.singleChannelCurvatureValue noncomputable def commonRangeWithoutSingleChannelShape : ReducedCrossChannelShapeReadout where tripletIntrinsicRangeValue := 2 singletIntrinsicRangeValue := 2 intrinsicRangeToleranceValue := 1 singleChannelCurvatureValue := 1 / 2 curvatureUncertaintyValue := 1 theorem cross_channel_range_compatibility_does_not_select_a_shape_from_one_channel : commonRangeWithoutSingleChannelShape.PermitsCommonIntrinsicRange ∧ ¬commonRangeWithoutSingleChannelShape.SelectedBySingleChannelEnergyDependence := by norm_num [ReducedCrossChannelShapeReadout.PermitsCommonIntrinsicRange, ReducedCrossChannelShapeReadout.SelectedBySingleChannelEnergyDependence, commonRangeWithoutSingleChannelShape] structure ReducedHighEnergyDiagnosticReadout where observedDeviationValue : Real squareWellDeviationValue : Real tensorExpectedDeviationValue : Real unexplainedResidualValue : Real def ReducedHighEnergyDiagnosticReadout.ObservedDirection (readout : ReducedHighEnergyDiagnosticReadout) : Prop := 0 < readout.observedDeviationValue def ReducedHighEnergyDiagnosticReadout.ExceedsSquareWell (readout : ReducedHighEnergyDiagnosticReadout) : Prop := 0 < readout.squareWellDeviationValue /\ readout.squareWellDeviationValue < readout.observedDeviationValue def ReducedHighEnergyDiagnosticReadout.TensorExplanationExcluded (readout : ReducedHighEnergyDiagnosticReadout) : Prop := readout.observedDeviationValue * readout.tensorExpectedDeviationValue < 0 def ReducedHighEnergyDiagnosticReadout.DiscrepancyExplained (readout : ReducedHighEnergyDiagnosticReadout) : Prop := readout.unexplainedResidualValue = 0 def unexplainedHighEnergyDiagnostic : ReducedHighEnergyDiagnosticReadout where observedDeviationValue := 4 squareWellDeviationValue := 1 tensorExpectedDeviationValue := -1 unexplainedResidualValue := 1 theorem detailed_high_energy_diagnostics_can_leave_the_discrepancy_unexplained : unexplainedHighEnergyDiagnostic.ObservedDirection ∧ unexplainedHighEnergyDiagnostic.ExceedsSquareWell ∧ unexplainedHighEnergyDiagnostic.TensorExplanationExcluded ∧ ¬unexplainedHighEnergyDiagnostic.DiscrepancyExplained := by norm_num [ReducedHighEnergyDiagnosticReadout.ObservedDirection, ReducedHighEnergyDiagnosticReadout.ExceedsSquareWell, ReducedHighEnergyDiagnosticReadout.TensorExplanationExcluded, ReducedHighEnergyDiagnosticReadout.DiscrepancyExplained, unexplainedHighEnergyDiagnostic] end Countermodels end EffectiveRangeFramework end PhysicsLogic.Papers.Bethe1949