| import OAI.Dynamics.SmoothObstruction.ShortDerivative |
| import OAI.Dynamics.SmoothObstruction.ExteriorPowers |
|
|
| namespace OAI |
|
|
| section |
|
|
| open Filter Topology |
| open scoped Real |
|
|
| namespace SmoothObstruction.SmoothScales |
|
|
| / |
| `g L ≥ b^(3/4)n` for `g = sqrt b`, `L = ceil(b^(1/4)n)`. -/ |
| lemma gap_scale_lower {b n : ℝ} (hn : 1≤n) (hb : n^(-1/10:ℝ)≤b) : |
| n^(37/40:ℝ)≤b^(3/4:ℝ)*n := by |
| have hnpos : 0<n := by linarith |
| have hh := Real.rpow_le_rpow (Real.rpow_nonneg hnpos.le _) hb |
| (show (0:ℝ)≤3/4 by norm_num) |
| rw [←Real.rpow_mul hnpos.le] at hh |
| calc |
| n^(37/40:ℝ) = n^((-1/10:ℝ)*(3/4)+1) := by norm_num |
| _ = n^((-1/10:ℝ)*(3/4))*n := by rw [Real.rpow_add hnpos,Real.rpow_one] |
| _ ≤ b^(3/4:ℝ)*n := mul_le_mul_of_nonneg_right hh hnpos.le |
|
|
| / |
| gap×short-time exponent. Neither the gap nor the rates need be bounded away |
| from zero. -/ |
| theorem gap_cost_absorption {α : Type*} {l : Filter α} {b n : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) |
| (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| (C : ℝ) {c : ℝ} (hc : 0<c) : |
| Tendsto (fun k => Real.exp (C*b k*n k-c*b k^(3/4:ℝ)*n k)) l (𝓝 0) := by |
| have hn1 : ∀ᶠ k in l,1≤n k := hn.eventually (eventually_ge_atTop 1) |
| have hP : Tendsto (fun k => b k^(3/4:ℝ)*n k) l atTop := by |
| apply tendsto_atTop_mono' l ?_ |
| ((tendsto_rpow_atTop (show (0:ℝ)<37/40 by norm_num)).comp hn) |
| filter_upwards [hn1,hfloor] with k hnk hbk |
| exact gap_scale_lower hnk hbk |
| have hquarter : Tendsto (fun k => b k^(1/4:ℝ)) l (𝓝 0) := by |
| have hh := ((Real.continuous_rpow_const (show (0:ℝ)≤1/4 by norm_num)).tendsto 0).comp hb |
| simpa only [Function.comp_def,Real.zero_rpow (show (1/4:ℝ)≠0 by norm_num)] using hh |
| have hs : ∀ᶠ k in l,C*b k^(1/4:ℝ)≤c/2 := by |
| apply Tendsto.eventually_le_const (show (0:ℝ)<c/2 by linarith) |
| simpa only [mul_zero] using hquarter.const_mul C |
| have hzero := Real.tendsto_exp_neg_atTop_nhds_zero.comp |
| (hP.const_mul_atTop (show 0<c/2 by linarith)) |
| apply squeeze_zero' _ _ hzero |
| · exact Filter.Eventually.of_forall fun k => (Real.exp_pos _).le |
| · filter_upwards [hbpos,hn1,hs] with k hbk hnk hsk |
| apply Real.exp_le_exp.mpr |
| have hbseq : b k^(1/4:ℝ)*b k^(3/4:ℝ)=b k := by |
| rw [←Real.rpow_add hbk] |
| norm_num |
| have hh := mul_le_mul_of_nonneg_right hsk |
| (show 0≤b k^(3/4:ℝ)*n k from mul_nonneg (Real.rpow_nonneg hbk.le _) (by linarith)) |
| have he : (C*b k^(1/4:ℝ))*(b k^(3/4:ℝ)*n k)=C*b k*n k := by |
| calc |
| _ = C*(b k^(1/4:ℝ)*b k^(3/4:ℝ))*n k := by ring |
| _ = _ := by rw [hbseq] |
| rw [he] at hh |
| nlinarith |
| end SmoothObstruction.SmoothScales |
|
|
| namespace SmoothObstruction.SmoothScales |
| open Filter Topology |
| / |
| gauge cost. This is the form needed by the finite leading-minor lower bound. -/ |
| theorem weighted_gap_error {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {c A : ℝ} (hc : 0<c) (hA : 0≤A) (C : ℝ) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤Real.exp (-c*b k^(3/4:ℝ)*n k)) : |
| Tendsto (fun k => A*Real.exp (C*b k*n k)*δ k) l (𝓝 0) := by |
| have hz := (gap_cost_absorption hbpos hb hn hfloor C hc).const_mul A |
| simp only [mul_zero] at hz |
| apply squeeze_zero' _ _ hz |
| · filter_upwards [hδ] with k hk |
| exact mul_nonneg (mul_nonneg hA (Real.exp_pos _).le) hk.1 |
| · filter_upwards [hδ] with k hk |
| calc |
| _ ≤ A*Real.exp (C*b k*n k)*Real.exp (-c*b k^(3/4:ℝ)*n k) := |
| mul_le_mul_of_nonneg_left hk.2 (mul_nonneg hA (Real.exp_pos _).le) |
| _ = A*Real.exp (C*b k*n k-c*b k^(3/4:ℝ)*n k) := by |
| rw [mul_assoc,←Real.exp_add] |
| congr 2 |
| ring |
| end SmoothObstruction.SmoothScales |
| |
| namespace SmoothObstruction.SmoothScales |
| open Filter Topology |
| |
| /-- The literal dimension/gauge cost in the common-fast leading-minor |
| proof is eventually small. Its parameters are fixed before bins and frames |
| are selected, and the good-frame error has the source gap×short-time scale. -/ |
| theorem common_frame_budget {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {c F C N : ℝ} (hc : 0<c) (hF : 0≤F) (hN : 0≤N) |
| (K₀ : ℝ) (p : ℕ) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤Real.exp (-c*b k^(3/4:ℝ)*n k)) : |
| ∀ᶠ k in l, |
| (F*δ k)*(1+((C*(Real.exp (K₀*b k*n k))^p)^2*(C*2^p))* |
| (C*(C^2*(Real.exp (K₀*b k*n k))^(2*p)*N)))≤1/2 := by |
| have hz₁ := weighted_gap_error hbpos hb hn hfloor hc hF 0 hδ |
| have hz₂ := weighted_gap_error hbpos hb hn hfloor hc |
| (show 0≤F*C^6*2^p*N by positivity) ((4*p:ℕ)*K₀) hδ |
| have hz := hz₁.add hz₂ |
| simp only [add_zero] at hz |
| have he (k : α) : |
| (F*δ k)*(1+((C*(Real.exp (K₀*b k*n k))^p)^2*(C*2^p))* |
| (C*(C^2*(Real.exp (K₀*b k*n k))^(2*p)*N)))= |
| F*Real.exp (0*b k*n k)*δ k+ |
| (F*C^6*2^p*N)*Real.exp (((4*p:ℕ):ℝ)*K₀*b k*n k)*δ k := by |
| have hexp : Real.exp (((4*p:ℕ):ℝ)*K₀*b k*n k)= |
| (Real.exp (K₀*b k*n k))^(4*p) := by |
| rw [←Real.exp_nat_mul] |
| congr 1 |
| ring |
| rw [hexp] |
| simp only [zero_mul,Real.exp_zero,mul_one,Nat.mul_comm 2 p,Nat.mul_comm 4 p,pow_mul] |
| ring |
| have hh : Tendsto (fun k => |
| (F*δ k)*(1+((C*(Real.exp (K₀*b k*n k))^p)^2*(C*2^p))* |
| (C*(C^2*(Real.exp (K₀*b k*n k))^(2*p)*N)))) l (𝓝 0) := by |
| apply hz.congr |
| intro k |
| exact (he k).symm |
| exact hh.eventually_le_const (by norm_num : (0:ℝ)<1/2) |
| end SmoothObstruction.SmoothScales |
| |
| namespace SmoothObstruction.SmoothScales |
| open Filter Topology |
| |
| /-- The full-time gap dominates the short-time gap scale and every fixed |
| gauge cost. No uniform positive lower bound on the spectral gap is assumed. -/ |
| theorem weighted_full_gap {α : Type*} {l : Filter α} {b n : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {c A : ℝ} (hc : 0<c) (hA : 0≤A) (C : ℝ) : |
| Tendsto (fun k => A*Real.exp (C*b k*n k)* |
| Real.exp (-c*b k^(1/2:ℝ)*n k)) l (𝓝 0) := by |
| apply weighted_gap_error hbpos hb hn hfloor hc hA C |
| have hb1 := hb.eventually_le_const (by norm_num : (0:ℝ)<1) |
| have hn0 := hn.eventually (eventually_ge_atTop 0) |
| filter_upwards [hbpos,hb1,hn0] with k hbk hb1k hnk |
| refine ⟨(Real.exp_pos _).le,Real.exp_le_exp.mpr ?_⟩ |
| have hh := Real.rpow_le_rpow_of_exponent_ge hbk hb1k |
| (show (1/2:ℝ)≤3/4 by norm_num) |
| have hp := mul_le_mul_of_nonneg_right hh hnk |
| nlinarith |
| |
| /-- The literal finite-gauge Cramer bound tends to zero, uniformly over |
| all common bins satisfying the same scalar data. Fixed constants account |
| for the dimension, endpoint projections and unit wedge norms. -/ |
| theorem common_graph_budget {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {c C N V W : ℝ} (hc : 0<c) (hN : 0≤N) |
| (hV : 0≤V) (hW : 0≤W) (K₀ : ℝ) (p : ℕ) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤Real.exp (-c*b k^(3/4:ℝ)*n k)) : |
| Tendsto (fun k => |
| 2*((C*(Real.exp (K₀*b k*n k))^p)^2*(C*2^p))* |
| ((C*(C*(Real.exp (K₀*b k*n k))^p)^2*N*V)* |
| Real.exp (-2*b k^(1/2:ℝ)*n k)+ |
| (C*(C^2*(Real.exp (K₀*b k*n k))^(2*p)*N))*W*δ k)) l (𝓝 0) := by |
| have hz₁ := weighted_full_gap hbpos hb hn hfloor |
| (by norm_num : (0:ℝ)<2) (show 0≤2*C^6*2^p*N*V by positivity) ((4*p:ℕ)*K₀) |
| have hz₂ := weighted_gap_error hbpos hb hn hfloor hc |
| (show 0≤2*C^6*2^p*N*W by positivity) ((4*p:ℕ)*K₀) hδ |
| have hz := hz₁.add hz₂ |
| simp only [add_zero] at hz |
| apply hz.congr |
| intro k |
| have hexp : Real.exp (((4*p:ℕ):ℝ)*K₀*b k*n k)= |
| (Real.exp (K₀*b k*n k))^(4*p) := by |
| rw [←Real.exp_nat_mul] |
| congr 1 |
| ring |
| rw [hexp] |
| simp only [Nat.mul_comm 2 p,Nat.mul_comm 4 p,pow_mul] |
| ring |
| |
| /-- Relative nonlinear errors preserve the vanishing Cramer bound. -/ |
| theorem perturbed_graph_decay {α : Type*} {l : Filter α} {θ ε : α → ℝ} |
| (hθ : Tendsto θ l (𝓝 0)) (hε : Tendsto ε l (𝓝 0)) : |
| Tendsto (fun k => (θ k+ε k)/(1-ε k)) l (𝓝 0) := by |
| have hh := (hθ.add hε).div (tendsto_const_nhds.sub hε) |
| (by norm_num : (1:ℝ)-0≠0) |
| change Tendsto (fun k => (θ k+ε k)/(1-ε k)) l (𝓝 ((0+0)/(1-0))) at hh |
| norm_num at hh |
| exact hh |
| end SmoothObstruction.SmoothScales |
| |
| namespace SmoothObstruction.SmoothScales |
| open Filter Topology |
| |
| /-- The manuscript's exact natural short length, including its ceiling. -/ |
| lemma ceil_gap_lower {b n : ℝ} (hb : 0<b) : |
| b^(3/4:ℝ)*n≤Real.sqrt b*(Nat.ceil (b^(1/4:ℝ)*n):ℝ) := by |
| calc |
| _ = Real.sqrt b*(b^(1/4:ℝ)*n) := by |
| rw [Real.sqrt_eq_rpow,←mul_assoc,←Real.rpow_add hb] |
| norm_num |
| _ ≤ _ := mul_le_mul_of_nonneg_left (Nat.le_ceil _) (Real.sqrt_nonneg _) |
|
|
| lemma ceil_gap_error {b n c : ℝ} (hb : 0<b) (hc : 0≤c) : |
| Real.exp (-c*Real.sqrt b*(Nat.ceil (b^(1/4:ℝ)*n):ℝ))≤ |
| Real.exp (-c*b^(3/4:ℝ)*n) := by |
| apply Real.exp_le_exp.mpr |
| have hh := mul_le_mul_of_nonneg_left (ceil_gap_lower (n:=n) hb) hc |
| nlinarith |
|
|
| / |
| source's `g = sqrt b` and `L = ceil(b^(1/4)n)`, without dropping the rounding |
| or imposing a positive gap floor. -/ |
| theorem common_frame_budget_short {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {c F C N : ℝ} (hc : 0<c) (hF : 0≤F) (hN : 0≤N) (K₀ : ℝ) (p : ℕ) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤ |
| Real.exp (-c*Real.sqrt (b k)*(Nat.ceil (b k^(1/4:ℝ)*n k):ℝ))) : |
| ∀ᶠ k in l, |
| (F*δ k)*(1+((C*(Real.exp (K₀*b k*n k))^p)^2*(C*2^p))* |
| (C*(C^2*(Real.exp (K₀*b k*n k))^(2*p)*N)))≤1/2 := by |
| apply common_frame_budget hbpos hb hn hfloor hc hF hN K₀ p |
| filter_upwards [hbpos,hδ] with k hbk hdk |
| exact ⟨hdk.1,hdk.2.trans (ceil_gap_error hbk hc.le)⟩ |
| end SmoothObstruction.SmoothScales |
| |
| namespace SmoothObstruction.SmoothScales |
| open Filter Topology |
| |
| /-- Uniformity over every possible common-bin rank, including empty groups. |
| Constants may depend on the rank but are fixed before bins, points and times |
| are chosen. Thus no hidden point-dependent large-scale threshold remains. -/ |
| theorem uniform_common_frame_budget {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| (d : ℕ) {c : ℝ} (hc : 0<c) |
| (F C N K₀ : Fin (d+1) → ℝ) (hF : ∀ p,0≤F p) (hN : ∀ p,0≤N p) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤ |
| Real.exp (-c*Real.sqrt (b k)*(Nat.ceil (b k^(1/4:ℝ)*n k):ℝ))) : |
| ∀ᶠ k in l,∀ p : Fin (d+1), |
| (F p*δ k)*(1+((C p*(Real.exp (K₀ p*b k*n k))^p.val)^2*(C p*2^p.val))* |
| (C p*((C p)^2*(Real.exp (K₀ p*b k*n k))^(2*p.val)*N p)))≤1/2 := by |
| apply Filter.eventually_all.mpr |
| intro p |
| exact common_frame_budget_short hbpos hb hn hfloor hc (hF p) (hN p) (K₀ p) p.val hδ |
| |
| /-- The actual Cramer error is small for all ranks simultaneously. Fixed |
| rank-dependent costs do not change the source's quantifier order. -/ |
| theorem uniform_common_graph_budget {α : Type*} {l : Filter α} {b n δ : α → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| (d : ℕ) {c : ℝ} (hc : 0<c) |
| (C N V W K₀ : Fin (d+1) → ℝ) |
| (hN : ∀ p,0≤N p) (hV : ∀ p,0≤V p) (hW : ∀ p,0≤W p) |
| (hδ : ∀ᶠ k in l,0≤δ k ∧ δ k≤ |
| Real.exp (-c*Real.sqrt (b k)*(Nat.ceil (b k^(1/4:ℝ)*n k):ℝ))) |
| {ε : ℝ} (hε : 0<ε) : |
| ∀ᶠ k in l,∀ p : Fin (d+1), |
| 2*((C p*(Real.exp (K₀ p*b k*n k))^p.val)^2*(C p*2^p.val))* |
| ((C p*(C p*(Real.exp (K₀ p*b k*n k))^p.val)^2*N p*V p)* |
| Real.exp (-2*b k^(1/2:ℝ)*n k)+ |
| (C p*((C p)^2*(Real.exp (K₀ p*b k*n k))^(2*p.val)*N p))*W p*δ k)≤ε := by |
| apply Filter.eventually_all.mpr |
| intro p |
| apply (common_graph_budget hbpos hb hn hfloor hc (hN p) (hV p) (hW p) |
| (K₀ p) p.val ?_).eventually_le_const hε |
| filter_upwards [hbpos,hδ] with k hbk hdk |
| exact ⟨hdk.1,hdk.2.trans (ceil_gap_error hbk hc.le)⟩ |
| end SmoothObstruction.SmoothScales |
|
|
| namespace SmoothObstruction.ExteriorStability |
|
|
| open RelativeProduct |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] |
|
|
| / |
| theorem exterior_segment (p : ℕ) (A : ℕ → E →L[ℝ] E) (s n : ℕ) : |
| exterior p (segment A s n) = segment (fun t => exterior p (A t)) s n := by |
| induction n with |
| | zero => simp |
| | succ n ih => simp only [segment_succ, exterior_mul, ih] |
|
|
| / |
| in the canonical exterior Euclidean operator norm. The one-step constant |
| is uniform over all exterior degrees `p ≤ d`, all products and all lengths. |
| The proof actually does not need `a ≥ 0`, `m ≥ 1`, or `K ≥ 1`; the source |
| assumptions are retained in the final source-specialized statement. -/ |
| theorem relative_exterior_core (d : ℕ) (K : ℝ) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ (p : ℕ), p ≤ d → |
| ∀ (A B : ℕ → E →L[ℝ] E) (m : ℕ) (σ a ε : ℝ), |
| 0 ≤ ε → ε ≤ 1 → |
| (∀ t < m, ‖A t‖ ≤ K) → |
| (∀ t < m, ‖B t - A t‖ ≤ ε) → |
| (∀ s k : ℕ, s + k ≤ m → |
| ‖exterior p (segment A s k)‖ ≤ Real.exp (σ * k + a)) → |
| ‖exterior p (segment B 0 m) - exterior p (segment A 0 m)‖ ≤ |
| Real.exp (σ * m + a) * ((1 + C * ε * Real.exp (a + |σ|)) ^ m - 1) := by |
| obtain ⟨C, hCpos, hC⟩ := exists_uniform_exterior_lipschitz (E := E) d K |
| refine ⟨C, hCpos, ?_⟩ |
| intro p hp A B m σ a ε hε hε₁ hA hBA hseg |
| simp only [exterior_segment] |
| apply norm_difference_le_exp (fun t => exterior p (A t)) |
| (fun t => exterior p (B t)) 0 m σ a (C * ε) (mul_nonneg hCpos hε) |
| · intro t k _ htk |
| simpa only [← exterior_segment, Nat.zero_add] using hseg t k (by omega) |
| · intro t _ ht |
| exact (hC p hp (A t) (B t) (hA t (by omega)) ((hBA t (by omega)).trans hε₁)).trans |
| (mul_le_mul_of_nonneg_left (hBA t (by omega)) hCpos) |
|
|
| / |
| Euclidean operators, hence real matrices in the Euclidean operator norm. -/ |
| theorem relative_exterior (d : ℕ) (_hd : 1 ≤ d) (K : ℝ) (_hK : 1 ≤ K) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ (p : ℕ), p ≤ d → |
| ∀ (m : ℕ), 1 ≤ m → |
| ∀ (A B : ℕ → EuclideanSpace ℝ (Fin d) →L[ℝ] EuclideanSpace ℝ (Fin d)) |
| (σ a ε : ℝ), |
| 0 ≤ a → 0 ≤ ε → ε ≤ 1 → |
| (∀ t < m, ‖A t‖ ≤ K) → |
| (∀ t < m, ‖B t - A t‖ ≤ ε) → |
| (∀ s k : ℕ, s + k ≤ m → |
| ‖exterior p (segment A s k)‖ ≤ Real.exp (σ * k + a)) → |
| ‖exterior p (segment B 0 m) - exterior p (segment A 0 m)‖ ≤ |
| Real.exp (σ * m + a) * ((1 + C * ε * Real.exp (a + |σ|)) ^ m - 1) := by |
| obtain ⟨C, hC, hc⟩ := relative_exterior_core (E := EuclideanSpace ℝ (Fin d)) d K |
| refine ⟨C, hC, fun p hp m _ A B σ a ε _ hε hε₁ hA hBA hseg => ?_⟩ |
| exact hc p hp A B m σ a ε hε hε₁ hA hBA hseg |
|
|
| end SmoothObstruction.ExteriorStability |
|
|
| namespace SmoothObstruction.ExteriorStability |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] |
| @[simp] theorem exterior_zero (A : E →L[ℝ] E) : exterior 0 A = 1 := by |
| apply ContinuousLinearMap.ext |
| intro v |
| apply (exteriorPower.zeroEquiv ℝ E).injective |
| exact congrArg (fun f : (⋀[ℝ]^0 E) →ₗ[ℝ] ℝ => f v) |
| (exteriorPower.zeroEquiv_naturality A.toLinearMap) |
| @[simp] theorem exterior_zero_difference (A B : E →L[ℝ] E) : |
| exterior 0 B - exterior 0 A = 0 := by simp |
| end SmoothObstruction.ExteriorStability |
|
|
| namespace SmoothObstruction.SmoothScales |
| / |
| noncomputable def B (b : ℝ) : ℝ := b ^ (1 / 8 : ℝ) |
|
|
| lemma positive {b : ℝ} (hb : 0 < b) : 0 < B b := Real.rpow_pos_of_pos hb _ |
|
|
| lemma ratio {b : ℝ} (hb : 0 < b) : b / B b = b ^ (7 / 8 : ℝ) := by |
| calc |
| b / B b = b ^ (1 : ℝ) / b ^ (1 / 8 : ℝ) := by simp [B] |
| _ = b ^ ((1 : ℝ) - 1 / 8) := (Real.rpow_sub hb _ _).symm |
| _ = b ^ (7 / 8 : ℝ) := by norm_num |
|
|
| lemma root_sixteen {b : ℝ} (hb : 0 ≤ b) : (B b)^16 = b^2 := by |
| rw [B, ← Real.rpow_natCast, ← Real.rpow_mul hb] |
| norm_num |
|
|
| lemma lower_bound {b n : ℝ} (hn : 1 ≤ n) (hb : n ^ (-1 / 10 : ℝ) ≤ b) : |
| n ^ (79 / 80 : ℝ) ≤ B b * n := by |
| have hnpos : 0 < n := by linarith |
| have h := Real.rpow_le_rpow (Real.rpow_nonneg hnpos.le _) hb (show (0 : ℝ) ≤ 1 / 8 by norm_num) |
| rw [← Real.rpow_mul hnpos.le] at h |
| have h' := mul_le_mul_of_nonneg_right h hnpos.le |
| calc |
| n ^ (79 / 80 : ℝ) = n ^ ((-1 / 10 : ℝ) * (1 / 8)) * n := by |
| calc |
| n ^ (79 / 80 : ℝ) = n ^ ((-1 / 10 : ℝ) * (1 / 8) + 1) := by norm_num |
| _ = n ^ ((-1 / 10 : ℝ) * (1 / 8)) * n := by rw [Real.rpow_add hnpos, Real.rpow_one] |
| _ ≤ B b * n := h' |
|
|
| lemma square_dominates {b n : ℝ} (hn : 1 ≤ n) (hb : n ^ (-1 / 10 : ℝ) ≤ b) : |
| n ≤ (B b * n)^2 := by |
| have hl := lower_bound hn hb |
| have hpos : 0 ≤ n ^ (79 / 80 : ℝ) := Real.rpow_nonneg (by linarith) _ |
| calc |
| n = n ^ (1 : ℝ) := by simp |
| _ ≤ n ^ ((79 / 80 : ℝ) * 2) := Real.rpow_le_rpow_of_exponent_le hn (by norm_num) |
| _ = (n ^ (79 / 80 : ℝ))^2 := by rw [Real.rpow_mul (by linarith), Real.rpow_two] |
| _ ≤ (B b * n)^2 := pow_le_pow_left₀ hpos hl 2 |
|
|
| lemma ratio_tendsto_zero {α : Type*} {l : Filter α} {b : α → ℝ} |
| (hbpos : ∀ᶠ k in l, 0 < b k) (hb : Tendsto b l (𝓝 0)) : |
| Tendsto (fun k => b k / B (b k)) l (𝓝 0) := by |
| have h := ((Real.continuous_rpow_const (show (0 : ℝ) ≤ 7 / 8 by norm_num)).tendsto 0).comp hb |
| simp only [Real.zero_rpow (show (7 / 8 : ℝ) ≠ 0 by norm_num)] at h |
| apply h.congr' |
| filter_upwards [hbpos] with k hk |
| exact (ratio hk).symm |
| |
| /-- Quantitative exponential decay used in the relative-minor transfer. It |
| holds for every fixed real coefficient `C`, including all constants coming |
| from the dimension, charts, and inverse basis bounds. -/ |
| theorem decisive_decay {α : Type*} {l : Filter α} {b n : α → ℝ} |
| (hbpos : ∀ᶠ k in l, 0 < b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) |
| (hfloor : ∀ᶠ k in l, n k ^ (-1 / 10 : ℝ) ≤ b k) (C : ℝ) : |
| Tendsto (fun k => n k * Real.exp (-(3 / 2 : ℝ) * B (b k) * n k + C * b k * n k)) |
| l (𝓝 0) := by |
| have hn1 : ∀ᶠ k in l, 1 ≤ n k := hn.eventually (eventually_ge_atTop 1) |
| have hsmall : ∀ᶠ k in l, C * (b k / B (b k)) ≤ 1 / 2 := by |
| apply Tendsto.eventually_le_const (show (0 : ℝ) < 1 / 2 by norm_num) |
| simpa using (ratio_tendsto_zero hbpos hb).const_mul C |
| have hBn : Tendsto (fun k => B (b k) * n k) l atTop := by |
| apply tendsto_atTop_mono' l ?_ ((tendsto_rpow_atTop (show (0 : ℝ) < 79 / 80 by norm_num)).comp hn) |
| filter_upwards [hn1, hfloor] with k hk hbf |
| exact lower_bound hk hbf |
| have hzero := (Real.tendsto_pow_mul_exp_neg_atTop_nhds_zero 2).comp hBn |
| apply squeeze_zero' _ _ hzero |
| · filter_upwards [hn1] with k hk |
| exact mul_nonneg (by linarith) (Real.exp_pos _).le |
| · filter_upwards [hn1, hfloor, hbpos, hsmall] with k hnk hfk hbk hsk |
| have hB := positive hbk |
| have hCB : C * b k ≤ B (b k) / 2 := by |
| have hh := (div_le_iff₀ hB).mp (show C * b k / B (b k) ≤ 1 / 2 by simpa [mul_div_assoc] using hsk) |
| linarith |
| have hexp : -(3 / 2 : ℝ) * B (b k) * n k + C * b k * n k ≤ -(B (b k) * n k) := by |
| have := mul_le_mul_of_nonneg_right hCB (show 0 ≤ n k by linarith) |
| nlinarith |
| exact mul_le_mul (square_dominates hnk hfk) (Real.exp_le_exp.mpr hexp) |
| (Real.exp_pos _).le (sq_nonneg _) |
| end SmoothObstruction.SmoothScales |
| |
| namespace SmoothObstruction.RelativeAsymptotics |
| lemma exp_sub_one_le (x : ℝ) : Real.exp x - 1 ≤ x * Real.exp x := by |
| have h := mul_le_mul_of_nonneg_right (Real.add_one_le_exp (-x)) (Real.exp_pos x).le |
| rw [← Real.exp_add, neg_add_cancel, Real.exp_zero] at h |
| nlinarith |
| lemma pow_one_add_sub_one_le (x : ℝ) (hx : 0 ≤ x) (n : ℕ) : |
| (1 + x)^n - 1 ≤ n * x * Real.exp (n * x) := by |
| have h : (1 + x)^n ≤ Real.exp (n * x) := by |
| rw [Real.exp_nat_mul] |
| apply pow_le_pow_left₀ (by positivity) |
| simpa [add_comm] using Real.add_one_le_exp x |
| exact (sub_le_sub_right h 1).trans (exp_sub_one_le _) |
| |
| lemma normalized_estimate (x σ a c C ε : ℝ) (m : ℕ) (hC : 0 ≤ C) (hε : 0 ≤ ε) |
| (hx : x ≤ Real.exp (σ * m + a) * ((1 + C * ε * Real.exp (a + |σ|)) ^ m - 1)) : |
| x / Real.exp (σ * m - c) ≤ |
| (C * m * ε * Real.exp (2 * a + c + |σ|)) * |
| Real.exp (C * m * ε * Real.exp (a + |σ|)) := by |
| have hnorm := mul_le_mul_of_nonneg_left |
| (pow_one_add_sub_one_le (C * ε * Real.exp (a + |σ|)) (by positivity) m) |
| (Real.exp_pos (σ * m + a)).le |
| apply (div_le_div_of_nonneg_right (hx.trans hnorm) (Real.exp_pos _).le).trans |
| apply le_of_eq |
| have he : Real.exp (σ * m + a) = Real.exp (σ * m - c) * Real.exp (a + c) := by |
| rw [← Real.exp_add] |
| congr 1 |
| ring |
| rw [he] |
| have he₂ : Real.exp (a + c) * Real.exp (a + |σ|) = Real.exp (2 * a + c + |σ|) := by |
| rw [← Real.exp_add] |
| congr 1 |
| ring |
| have he₃ : (m : ℝ) * (C * ε * Real.exp (a + |σ|)) = C * m * ε * Real.exp (a + |σ|) := by ring |
| rw [he₃] |
| field_simp |
| ring_nf at he₂ ⊢ |
| rw [← he₂] |
| ring |
| |
| /-- The little-oh conclusion of the exterior-product lemma. The hypotheses on |
| `x` are the proved finite estimate, not an asymptotic conclusion. This bound |
| is uniform over all products and all exterior degrees covered by that estimate. -/ |
| theorem uniform_relative_small {α : Type*} {l : Filter α} |
| {b n x σ a ε : α → ℝ} {m : α → ℕ} |
| (hbpos : ∀ᶠ k in l, 0 < b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) |
| (hfloor : ∀ᶠ k in l, n k ^ (-1 / 10 : ℝ) ≤ b k) |
| (C C₀ C₁ C₂ C₃ : ℝ) (hC : 0 ≤ C) (hC₀ : 0 ≤ C₀) |
| (hC₃ : 0 ≤ C₃) |
| (hdata : ∀ᶠ k in l, |
| 0 ≤ x k ∧ 0 ≤ a k ∧ 0 ≤ ε k ∧ (m k : ℝ) ≤ 2 * n k ∧ |
| a k ≤ C₁ * b k * n k ∧ |σ k| ≤ C₂ ∧ |
| ε k ≤ C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B (b k) * n k) ∧ |
| x k ≤ Real.exp (σ k * m k + a k) * |
| ((1 + C * ε k * Real.exp (a k + |σ k|)) ^ m k - 1)) : |
| Tendsto (fun k => x k / Real.exp (σ k * m k - C₀ * b k * n k)) l (𝓝 0) := by |
| let U : α → ℝ := fun k => C * m k * ε k * Real.exp (a k + |σ k|) |
| let D : α → ℝ := fun k => C * m k * ε k * Real.exp (2 * a k + C₀ * b k * n k + |σ k|) |
| let V : α → ℝ := fun k => 2 * C * C₃ * Real.exp C₂ * |
| (n k * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B (b k) * n k + |
| (2 * C₁ + C₀) * b k * n k)) |
| have hn1 : ∀ᶠ k in l, 1 ≤ n k := hn.eventually (eventually_ge_atTop 1) |
| have hV : Tendsto V l (𝓝 0) := by |
| simpa [V] using (SmoothScales.decisive_decay hbpos hb hn hfloor (2 * C₁ + C₀)).const_mul |
| (2 * C * C₃ * Real.exp C₂) |
| have hDnonneg : ∀ᶠ k in l, 0 ≤ D k := by |
| filter_upwards [hdata] with k hk |
| dsimp [D] |
| exact mul_nonneg (mul_nonneg (mul_nonneg hC (Nat.cast_nonneg _)) hk.2.2.1) (Real.exp_pos _).le |
| have hDle : ∀ᶠ k in l, D k ≤ V k := by |
| filter_upwards [hdata, hn1] with k hk hnk |
| rcases hk with ⟨_, _, hε, hm, ha, hσ, hεle, _⟩ |
| have hn0 : 0 ≤ n k := by linarith |
| have hexp : 2 * a k + C₀ * b k * n k + |σ k| ≤ |
| (2 * C₁ + C₀) * b k * n k + C₂ := by nlinarith |
| have hprod : C * m k * ε k ≤ C * (2 * n k) * |
| (C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B (b k) * n k)) := by |
| exact mul_le_mul (mul_le_mul_of_nonneg_left hm hC) hεle hε (by positivity) |
| calc |
| D k ≤ C * (2 * n k) * (C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B (b k) * n k)) * |
| Real.exp ((2 * C₁ + C₀) * b k * n k + C₂) := |
| mul_le_mul hprod (Real.exp_le_exp.mpr hexp) (Real.exp_pos _).le (by positivity) |
| _ = V k := by |
| dsimp [V] |
| rw [Real.exp_add ((2 * C₁ + C₀) * b k * n k) C₂, |
| Real.exp_add (-(3 / 2 : ℝ) * SmoothScales.B (b k) * n k)] |
| ring |
| have hD : Tendsto D l (𝓝 0) := squeeze_zero' hDnonneg hDle hV |
| have hUnonneg : ∀ᶠ k in l, 0 ≤ U k := by |
| filter_upwards [hdata] with k hk |
| dsimp [U] |
| exact mul_nonneg (mul_nonneg (mul_nonneg hC (Nat.cast_nonneg _)) hk.2.2.1) (Real.exp_pos _).le |
| have hUle : ∀ᶠ k in l, U k ≤ D k := by |
| filter_upwards [hdata, hn1, hbpos] with k hk hnk hbk |
| apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) (by |
| exact mul_nonneg (mul_nonneg hC (Nat.cast_nonneg _)) hk.2.2.1) |
| have hbc : 0 ≤ C₀ * b k * n k := mul_nonneg (mul_nonneg hC₀ hbk.le) (by linarith) |
| linarith [hk.2.1] |
| have hU := squeeze_zero' hUnonneg hUle hD |
| have hright : Tendsto (fun k => D k * Real.exp (U k)) l (𝓝 0) := by |
| simpa using hD.mul (Real.continuous_exp.tendsto 0 |>.comp hU) |
| apply squeeze_zero' _ _ hright |
| · filter_upwards [hdata] with k hk |
| exact div_nonneg hk.1 (Real.exp_pos _).le |
| · filter_upwards [hdata] with k hk |
| exact normalized_estimate (x k) (σ k) (a k) (C₀ * b k * n k) C (ε k) (m k) hC |
| hk.2.2.1 hk.2.2.2.2.2.2.2 |
| end SmoothObstruction.RelativeAsymptotics |
|
|
| namespace SmoothObstruction.RelativeAsymptotics |
| open Filter Topology |
|
|
| / |
| exterior errors at a given dyadic scale. -/ |
| noncomputable def envelope (C C₀ C₁ C₂ C₃ b n : ℝ) : ℝ := |
| 2 * C * C₃ * Real.exp C₂ * |
| (n * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B b * n + |
| (2 * C₁ + C₀) * b * n)) |
|
|
| lemma uniform_relative_bound (x σ a ε b n C C₀ C₁ C₂ C₃ : ℝ) (m : ℕ) |
| (hb : 0 ≤ b) (hn : 0 ≤ n) (hC : 0 ≤ C) (hC₀ : 0 ≤ C₀) (hC₃ : 0 ≤ C₃) |
| (ha0 : 0 ≤ a) (hε : 0 ≤ ε) (hm : (m : ℝ) ≤ 2 * n) |
| (ha : a ≤ C₁ * b * n) (hσ : |σ| ≤ C₂) |
| (hεle : ε ≤ C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B b * n)) |
| (hx : x ≤ Real.exp (σ * m + a) * |
| ((1 + C * ε * Real.exp (a + |σ|)) ^ m - 1)) : |
| x / Real.exp (σ * m - C₀ * b * n) ≤ |
| envelope C C₀ C₁ C₂ C₃ b n * Real.exp (envelope C C₀ C₁ C₂ C₃ b n) := by |
| let U := C * m * ε * Real.exp (a + |σ|) |
| let D := C * m * ε * Real.exp (2 * a + C₀ * b * n + |σ|) |
| have hD0 : 0 ≤ D := by dsimp [D]; positivity |
| have hUD : U ≤ D := by |
| apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) (by positivity) |
| have : 0 ≤ C₀ * b * n := by positivity |
| linarith |
| have hDV : D ≤ envelope C C₀ C₁ C₂ C₃ b n := by |
| have hexp : 2 * a + C₀ * b * n + |σ| ≤ |
| (2 * C₁ + C₀) * b * n + C₂ := by nlinarith |
| have hprod : C * m * ε ≤ C * (2 * n) * |
| (C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B b * n)) := |
| mul_le_mul (mul_le_mul_of_nonneg_left hm hC) hεle hε (by positivity) |
| calc |
| D ≤ C * (2 * n) * (C₃ * Real.exp (-(3 / 2 : ℝ) * SmoothScales.B b * n)) * |
| Real.exp ((2 * C₁ + C₀) * b * n + C₂) := |
| mul_le_mul hprod (Real.exp_le_exp.mpr hexp) (Real.exp_pos _).le (by positivity) |
| _ = _ := by |
| dsimp [envelope] |
| rw [Real.exp_add ((2 * C₁ + C₀) * b * n) C₂, |
| Real.exp_add (-(3 / 2 : ℝ) * SmoothScales.B b * n)] |
| ring |
| exact (normalized_estimate x σ a (C₀*b*n) C ε m hC hε hx).trans |
| (mul_le_mul hDV (Real.exp_le_exp.mpr (hUD.trans hDV)) (Real.exp_pos _).le (hD0.trans hDV)) |
|
|
| lemma envelope_tendsto {α : Type*} {l : Filter α} {b n : α → ℝ} |
| (hbpos : ∀ᶠ k in l, 0 < b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) |
| (hfloor : ∀ᶠ k in l, n k ^ (-1 / 10 : ℝ) ≤ b k) |
| (C C₀ C₁ C₂ C₃ : ℝ) : |
| Tendsto (fun k => envelope C C₀ C₁ C₂ C₃ (b k) (n k) * |
| Real.exp (envelope C C₀ C₁ C₂ C₃ (b k) (n k))) l (𝓝 0) := by |
| have hV : Tendsto (fun k => envelope C C₀ C₁ C₂ C₃ (b k) (n k)) l (𝓝 0) := by |
| simpa [envelope] using |
| (SmoothScales.decisive_decay hbpos hb hn hfloor (2 * C₁ + C₀)).const_mul |
| (2 * C * C₃ * Real.exp C₂) |
| simpa using hV.mul (Real.continuous_exp.tendsto 0 |>.comp hV) |
| end SmoothObstruction.RelativeAsymptotics |
|
|
| end |
|
|
| end OAI |
|
|
