openAI-math-dataset / lean /OAI /Analysis /CoulombIonization /FieldAnalysis /LocalFieldBootstrapBarrier.lean
| import Mathlib | |
| import OAI.Analysis.CoulombIonization.RadialBounds.LocalHistoryWeightsBarrier | |
| namespace OAI | |
| noncomputable section | |
| namespace CoulombAtom | |
| open MeasureTheory Filter | |
| open scoped Topology BigOperators ContDiff | |
| section Work_LocalFieldBootstrap_barrier_scope | |
| open Set Metric | |
| lemma localHistory_field_bound {E₀ E : CoreObservationEnsemble} {y₀ : Space} {a Z lam : ℝ} | |
| {ha : 0 < a} (hsep : 12*a ≤ ‖y₀‖) (hm : E₀.mass = 1) (hZ : 0 ≤ Z) (hlam : 0 < lam) | |
| {n : ℕ} (hE : CoreLocalHistory E₀ y₀ a ha n E) (y : Space) | |
| (hy : y ∈ closedBall y₀ (localHistoryReach a n)) : | |
| E.fieldMoment Z lam y ≤ 2*packetFieldConstant^2*((1/a^4+1/a)^2+max (E₀.excess Z lam) 0/a+ | |
| 256*localHistoryCostScale a (E₀.countMoment y₀ (8*a)) (localFieldEnvelope E₀ y₀ a ha Z lam)/a)* | |
| ((n:ℝ)+2)^16 := by | |
| let u := localHistoryRadius a n | |
| have hu := localHistoryRadius_pos ha n | |
| let hr : 0 ≤ 2*u := by dsimp [u]; positivity | |
| let p := coreFirstRadialCut y hr hu | |
| let hp := coreFirstRadialCut_partition y hr hu | |
| have hn := CoreLocalHistory.center_nuclear_separation (ha := ha) hsep y hy | |
| have hu' := localHistoryRadius_le ha n | |
| have hv (x : Space) (hx : x ∈ ball y (2*u)) : (p 0).value x = 0 := | |
| coreFirstRadialCut_core_zero y hr hu x (by simpa only [radialPatchCore,mem_ofPred_eq,not_le,mem_ball,dist_eq_norm] using hx) | |
| have hd (x : Space) (hx : x ∈ ball y (2*u)) (d : Fin 3) : lineDeriv ℝ (p 0).value x (spaceDirections d) = 0 := | |
| coreFirstRadialCut_core_deriv_zero y hr hu x (by simpa only [radialPatchCore,mem_ofPred_eq,not_le,mem_ball,dist_eq_norm] using hx) d | |
| have hf := E.fieldMoment_le_observe_excess p hp y hu (by linarith) hv hd hZ hlam | |
| rw [hE.mass,hm,mul_one] at hf | |
| have he := localHistory_excess_bound hsep hm hZ hlam.le (CoreLocalHistory.observe hE y hy) | |
| have hc := localHistoryCostScale_nonneg a (E₀.countMoment y₀ (8*a)) | |
| (localFieldEnvelope_nonneg E₀ y₀ ha hsep hm hZ hlam.le) | |
| have he' : (E.observe p hp).excess Z lam ≤ max (E₀.excess Z lam) 0+ | |
| localHistoryCostScale a (E₀.countMoment y₀ (8*a)) (localFieldEnvelope E₀ y₀ a ha Z lam)* | |
| ((n:ℝ)+1)*((n:ℝ)+3)^8 := by | |
| simpa only [Nat.cast_add,Nat.cast_one,add_assoc,show (1:ℝ)+2 = 3 by norm_num] using | |
| he.trans (add_le_add (le_max_left (E₀.excess Z lam) 0) le_rfl) | |
| have hediv := (div_le_div_of_nonneg_right he' hu.le).trans | |
| (localHistoryRadius_energy ha (le_max_right _ _) hc n) | |
| have hall := mul_le_mul_of_nonneg_left (add_le_add (localHistoryRadius_packet ha n) hediv) | |
| (by positivity : 0 ≤ 2*packetFieldConstant^2) | |
| apply hf.trans | |
| convert hall using 1 | |
| ring | |
| lemma localFieldEnvelope_quadratic (E₀ : CoreObservationEnsemble) (y₀ : Space) {a Z lam : ℝ} | |
| (ha : 0 < a) (hsep : 12*a ≤ ‖y₀‖) (hm : E₀.mass = 1) (hZ : 0 ≤ Z) (hlam : 0 < lam) : | |
| (localFieldEnvelope E₀ y₀ a ha Z lam)^2 ≤ | |
| 2*packetFieldConstant^2*((1/a^4+1/a)^2+max (E₀.excess Z lam) 0/a+ | |
| 256*localizationIMSConstant*Real.sqrt (E₀.countMoment y₀ (8*a))/a^3)+ | |
| (4096*packetFieldConstant^2*Real.sqrt (E₀.countMoment y₀ (8*a))/a)* | |
| localFieldEnvelope E₀ y₀ a ha Z lam := by | |
| let H := localFieldEnvelope E₀ y₀ a ha Z lam | |
| let C := localHistoryCostScale a (E₀.countMoment y₀ (8*a)) H | |
| let G := 2*packetFieldConstant^2*((1/a^4+1/a)^2+max (E₀.excess Z lam) 0/a+256*C/a) | |
| have hH : 0 ≤ H := localFieldEnvelope_nonneg E₀ y₀ ha hsep hm hZ hlam.le | |
| have hC : 0 ≤ C := localHistoryCostScale_nonneg _ _ hH | |
| have hG : 0 ≤ G := by dsimp [G]; positivity | |
| have hb (t : ℝ) (ht : t ∈ localHistoryFieldValues E₀ y₀ a ha Z lam) : t ≤ Real.sqrt G := by | |
| obtain ⟨n,E,hE,y,hy,rfl⟩ := ht | |
| have hh := localHistory_field_bound hsep hm hZ hlam hE y hy | |
| have hsq : (Real.sqrt (E.fieldMoment Z lam y)/((n:ℝ)+2)^8)^2 ≤ G := by | |
| rw [div_pow,Real.sq_sqrt (E.fieldMoment_nonneg Z lam y),←pow_mul] | |
| apply (div_le_iff₀ (by positivity)).2 | |
| exact hh | |
| exact (Real.le_sqrt (by positivity) hG).2 hsq | |
| have hu : H ≤ Real.sqrt G := csSup_le (localHistoryFieldValues_nonempty E₀ y₀ ha Z lam) hb | |
| have hs := pow_le_pow_left₀ hH hu 2 | |
| rw [Real.sq_sqrt hG] at hs | |
| convert hs using 1 | |
| dsimp [G,C,H,localHistoryCostScale] | |
| field_simp [ha.ne'] | |
| ring | |
| theorem ensemble_local_field_estimate (E₀ : CoreObservationEnsemble) (y₀ : Space) {a Z lam : ℝ} | |
| (ha : 0 < a) (hsep : 12*a ≤ ‖y₀‖) (hm : E₀.mass = 1) (hZ : 0 ≤ Z) (hlam : 0 < lam) : | |
| E₀.fieldMoment Z lam y₀ ≤ 65536*( | |
| 4*packetFieldConstant^2*((1/a^4+1/a)^2+max (E₀.excess Z lam) 0/a+ | |
| 256*localizationIMSConstant*Real.sqrt (E₀.countMoment y₀ (8*a))/a^3)+ | |
| (4096*packetFieldConstant^2*Real.sqrt (E₀.countMoment y₀ (8*a))/a)^2) := by | |
| let H := localFieldEnvelope E₀ y₀ a ha Z lam | |
| let A := 2*packetFieldConstant^2*((1/a^4+1/a)^2+max (E₀.excess Z lam) 0/a+ | |
| 256*localizationIMSConstant*Real.sqrt (E₀.countMoment y₀ (8*a))/a^3) | |
| let D := 4096*packetFieldConstant^2*Real.sqrt (E₀.countMoment y₀ (8*a))/a | |
| have hs : H^2 ≤ A+D*H := localFieldEnvelope_quadratic E₀ y₀ ha hsep hm hZ hlam | |
| have hs' : H^2 ≤ 2*A+D^2 := by nlinarith [sq_nonneg (H-D)] | |
| have hh := localFieldEnvelope_bound hsep hm hZ hlam.le (CoreLocalHistory.initial (E₀ := E₀) (y₀ := y₀) (a := a) (ha := ha)) y₀ | |
| (by simp [localHistoryReach]) | |
| norm_num at hh | |
| have hsq := pow_le_pow_left₀ (Real.sqrt_nonneg _) hh 2 | |
| rw [Real.sq_sqrt (E₀.fieldMoment_nonneg Z lam y₀)] at hsq | |
| have hfinal := hsq.trans (show (localFieldEnvelope E₀ y₀ a ha Z lam*256)^2 ≤ 65536*(2*A+D^2) by nlinarith [hs']) | |
| convert hfinal using 1 | |
| dsimp [A,D] | |
| ring | |
| end Work_LocalFieldBootstrap_barrier_scope | |
| def localFieldScale (a D B : ℝ) : ℝ := | |
| (1/a^4+1/a)^2+1/a^4+D/a+B/a^2 | |
| def localFieldUniversalConstant : ℝ := 65536*(4*packetFieldConstant^2+ | |
| 512*packetFieldConstant^2*localizationIMSConstant+(4096*packetFieldConstant^2)^2) | |
| lemma localFieldUniversalConstant_pos : 0 < localFieldUniversalConstant := by | |
| have := packetFieldConstant_pos | |
| have := localizationIMSConstant_nonneg | |
| unfold localFieldUniversalConstant | |
| positivity | |
| lemma localFieldScale_nonneg {a D B : ℝ} (ha : 0 < a) (hD : 0 ≤ D) (hB : 0 ≤ B) : | |
| 0 ≤ localFieldScale a D B := by unfold localFieldScale; positivity | |
| lemma sqrt_count_reciprocal_young {a B : ℝ} (_ha : 0 < a) (hB : 0 ≤ B) : | |
| 2*Real.sqrt B/a^3 ≤ 1/a^4+B/a^2 := by | |
| have he : (Real.sqrt B/a)^2 = B/a^2 := by rw [div_pow,Real.sq_sqrt hB] | |
| have hp : (1/a^2)^2 = (1:ℝ)/a^4 := by ring | |
| calc | |
| 2*Real.sqrt B/a^3 = 2*(Real.sqrt B/a)*(1/a^2) := by ring | |
| _ ≤ (Real.sqrt B/a)^2+(1/a^2)^2 := by nlinarith [sq_nonneg (Real.sqrt B/a-1/a^2)] | |
| _ = _ := by rw [he,hp]; ring | |
| lemma localFieldScale_mono {a D D' B B' : ℝ} (ha : 0 < a) (hD : D ≤ D') (hB : B ≤ B') : | |
| localFieldScale a D B ≤ localFieldScale a D' B' := by | |
| unfold localFieldScale | |
| exact add_le_add (add_le_add le_rfl (div_le_div_of_nonneg_right hD ha.le)) | |
| (div_le_div_of_nonneg_right hB (sq_nonneg a)) | |
| lemma field_explicit_bound_le_scale {a D B : ℝ} (ha : 0 < a) (hD : 0 ≤ D) (hB : 0 ≤ B) : | |
| 65536*(4*packetFieldConstant^2*((1/a^4+1/a)^2+D/a+ | |
| 256*localizationIMSConstant*Real.sqrt B/a^3)+ | |
| (4096*packetFieldConstant^2*Real.sqrt B/a)^2) ≤ | |
| localFieldUniversalConstant*localFieldScale a D B := by | |
| let S := localFieldScale a D B | |
| have hP : 0 ≤ 1/a^4 := by positivity | |
| have hB' : 0 ≤ B/a^2 := by positivity | |
| have hD' : 0 ≤ D/a := by positivity | |
| have hX : 0 ≤ (1/a^4+1/a)^2 := sq_nonneg _ | |
| have hS1 : (1/a^4+1/a)^2+D/a ≤ S := by dsimp [S,localFieldScale]; linarith | |
| have hS2 : 1/a^4+B/a^2 ≤ S := by dsimp [S,localFieldScale]; linarith | |
| have hS3 : B/a^2 ≤ S := by dsimp [S,localFieldScale]; linarith | |
| have hK := localizationIMSConstant_nonneg | |
| have hy := mul_le_mul_of_nonneg_left (sqrt_count_reciprocal_young ha hB) | |
| (show 0 ≤ 512*packetFieldConstant^2*localizationIMSConstant by positivity) | |
| have hterm : (4096*packetFieldConstant^2*Real.sqrt B/a)^2 = | |
| (4096*packetFieldConstant^2)^2*(B/a^2) := by | |
| rw [div_pow,mul_pow,Real.sq_sqrt hB] | |
| ring | |
| rw [hterm] | |
| have h1 := mul_le_mul_of_nonneg_left hS1 (show 0 ≤ 4*packetFieldConstant^2 by positivity) | |
| have h2 := mul_le_mul_of_nonneg_left hS2 (show 0 ≤ 512*packetFieldConstant^2*localizationIMSConstant by positivity) | |
| have h3 := mul_le_mul_of_nonneg_left hS3 (sq_nonneg (4096*packetFieldConstant^2)) | |
| change _ ≤ 65536*(4*packetFieldConstant^2+ | |
| 512*packetFieldConstant^2*localizationIMSConstant+(4096*packetFieldConstant^2)^2)*S | |
| calc | |
| _ = 65536*(4*packetFieldConstant^2*((1/a^4+1/a)^2+D/a)+ | |
| 512*packetFieldConstant^2*localizationIMSConstant*(2*Real.sqrt B/a^3)+ | |
| (4096*packetFieldConstant^2)^2*(B/a^2)) := by ring | |
| _ ≤ 65536*(4*packetFieldConstant^2*S+ | |
| 512*packetFieldConstant^2*localizationIMSConstant*S+(4096*packetFieldConstant^2)^2*S) := | |
| mul_le_mul_of_nonneg_left (add_le_add (add_le_add h1 (hy.trans h2)) h3) (by norm_num) | |
| _ = _ := by ring | |
| theorem ensemble_local_field_scale (E : CoreObservationEnsemble) (y : Space) {a Z lam : ℝ} | |
| (ha : 0 < a) (hsep : 12*a ≤ ‖y‖) (hm : E.mass = 1) (hZ : 0 ≤ Z) (hlam : 0 < lam) : | |
| E.fieldMoment Z lam y ≤ localFieldUniversalConstant* | |
| localFieldScale a (max (E.excess Z lam) 0) (E.countMoment y (8*a)) := | |
| (ensemble_local_field_estimate E y ha hsep hm hZ hlam).trans | |
| (field_explicit_bound_le_scale ha (le_max_right _ _) (E.countMoment_nonneg y (8*a))) | |
| end CoulombAtom | |
| end | |
| end OAI | |