| import OAI.MathematicalPhysics.RapidForcing.SchwartzRestriction |
|
|
| namespace OAI |
|
|
| section |
|
|
| open scoped BigOperators Polynomial Topology |
| open Set Filter |
|
|
| namespace RapidForcing |
| namespace EffectiveProfile |
|
|
| abbrev GluePoly := List (ℚ × ℕ) |
|
|
| def glueDiff : GluePoly → GluePoly |
| | [] => [] |
| | (a, n) :: p => (a, n + 2) :: (-(n : ℚ) * a, n + 1) :: glueDiff p |
|
|
| def glueBound : GluePoly → ℚ |
| | [] => 0 |
| | (a, n) :: p => |a| * (n.factorial : ℚ) + glueBound p |
|
|
| noncomputable def monoGlue (n : ℕ) (x : ℝ) : ℝ := x⁻¹ ^ n * expNegInvGlue x |
|
|
| noncomputable def glue : GluePoly → ℝ → ℝ |
| | [], _ => 0 |
| | (a, n) :: p, x => (a : ℝ) * monoGlue n x + glue p x |
|
|
| lemma glueBound_nonneg (p : GluePoly) : 0 ≤ glueBound p := by |
| induction p with |
| | nil => rfl |
| | cons a p ih => rcases a with ⟨a, n⟩; dsimp [glueBound]; positivity |
|
|
| lemma hasDerivAt_monoGlue (n : ℕ) (x : ℝ) : |
| HasDerivAt (monoGlue n) (monoGlue (n + 2) x - n * monoGlue (n + 1) x) x := by |
| have h := expNegInvGlue.hasDerivAt_polynomial_eval_inv_mul ((Polynomial.X : ℝ[X]) ^ n) x |
| simp only [Polynomial.derivative_X_pow, Polynomial.eval_mul, Polynomial.eval_sub, |
| Polynomial.eval_pow, Polynomial.eval_X, Polynomial.eval_C] at h |
| convert! h using 1 |
| · cases n with |
| | zero => simp [monoGlue] |
| | succ n => simp [monoGlue, pow_add]; ring |
|
|
| lemma hasDerivAt_glue (p : GluePoly) (x : ℝ) : |
| HasDerivAt (glue p) (glue (glueDiff p) x) x := by |
| induction p with |
| | nil => exact hasDerivAt_const _ _ |
| | cons a p ih => |
| rcases a with ⟨a, n⟩ |
| change HasDerivAt (fun y => (a : ℝ) * monoGlue n y + glue p y) _ x |
| convert! ((hasDerivAt_monoGlue n x).const_mul (a : ℝ)).add ih using 1 |
| simp [glueDiff, glue]; ring |
|
|
| lemma contDiff_glue (p : GluePoly) : ContDiff ℝ (⊤ : ℕ∞) (glue p) := by |
| induction p with |
| | nil => exact contDiff_const |
| | cons a p ih => |
| rcases a with ⟨a, n⟩ |
| have hm : ContDiff ℝ (⊤ : ℕ∞) (monoGlue n) := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun x => x⁻¹ ^ n * expNegInvGlue x) |
| simpa using |
| expNegInvGlue.contDiff_polynomial_eval_inv_mul ((Polynomial.X : ℝ[X]) ^ n) |
| exact (contDiff_const.mul hm).add ih |
|
|
| lemma pow_mul_exp_neg_le (y : ℝ) (hy : 0 ≤ y) (n : ℕ) : |
| y ^ n * Real.exp (-y) ≤ n.factorial := by |
| have h := mul_le_mul_of_nonneg_right (Real.pow_div_factorial_le_exp y hy n) |
| (Real.exp_pos (-y)).le |
| rw [← Real.exp_add, add_neg_cancel, Real.exp_zero] at h |
| have hn : (0 : ℝ) < n.factorial := by positivity |
| have h' : (y ^ n * Real.exp (-y)) / n.factorial ≤ 1 := by |
| simpa only [mul_div_right_comm] using h |
| simpa only [one_mul] using (div_le_iff₀ hn).mp h' |
|
|
| lemma abs_monoGlue_le (n : ℕ) (x : ℝ) : |monoGlue n x| ≤ (n.factorial : ℝ) := by |
| by_cases hx : x ≤ 0 |
| · simp only [monoGlue, expNegInvGlue.zero_of_nonpos hx, mul_zero, abs_zero] |
| positivity |
| have hi : 0 ≤ x⁻¹ := (inv_pos.mpr (lt_of_not_ge hx)).le |
| simpa only [monoGlue, expNegInvGlue, ite_eq_right hx, |
| abs_of_nonneg (mul_nonneg (pow_nonneg hi n) (Real.exp_pos _).le)] using |
| pow_mul_exp_neg_le x⁻¹ hi n |
|
|
| lemma abs_glue_le (p : GluePoly) (x : ℝ) : |glue p x| ≤ (glueBound p : ℝ) := by |
| induction p with |
| | nil => simp [glue, glueBound] |
| | cons a p ih => |
| rcases a with ⟨a, n⟩ |
| rw [glue] |
| refine (abs_add_le _ _).trans ?_ |
| simpa only [glueBound, Rat.cast_add, Rat.cast_mul, Rat.cast_natCast, Rat.cast_abs, abs_mul] using |
| add_le_add (mul_le_mul_of_nonneg_left (abs_monoGlue_le n x) (abs_nonneg (a : ℝ))) ih |
|
|
| lemma glue_one : glue [(1, 0)] = expNegInvGlue := by |
| ext x |
| simp [glue, monoGlue] |
|
|
| lemma denominator_lower (x : ℝ) : |
| (1 / 16 : ℝ) ≤ expNegInvGlue x + expNegInvGlue (1 - x) := by |
| have he : Real.exp 2 < 16 := by |
| calc |
| Real.exp 2 = Real.exp 1 ^ 2 := by simp [← Real.exp_nat_mul] |
| _ < 3 ^ 2 := pow_lt_pow_left₀ Real.exp_one_lt_three (Real.exp_pos 1).le (by decide) |
| _ < 16 := by norm_num |
| have hb : (1 / 16 : ℝ) ≤ expNegInvGlue (1 / 2) := by |
| norm_num [expNegInvGlue, Real.exp_neg] at ⊢ |
| simpa only [one_div] using (inv_le_inv₀ (by norm_num : (0 : ℝ) < 16) (Real.exp_pos 2)).mpr he.le |
| have hmono := expNegInvGlue.monotone |
| rcases le_total (1 / 2 : ℝ) x with hx | hx |
| · exact hb.trans ((hmono hx).trans (le_add_of_nonneg_right (expNegInvGlue.nonneg _))) |
| · exact hb.trans ((hmono (show (1 / 2 : ℝ) ≤ 1 - x by linarith)).trans |
| (le_add_of_nonneg_left (expNegInvGlue.nonneg _))) |
|
|
| inductive Expr where |
| | const : ℚ → Expr |
| | left : GluePoly → Expr |
| | right : GluePoly → Expr |
| | invDen : ℕ → Expr |
| | add : Expr → Expr → Expr |
| | mul : Expr → Expr → Expr |
|
|
| noncomputable def Expr.value : Expr → ℝ → ℝ |
| | .const q, _ => q |
| | .left p, x => glue p x |
| | .right p, x => glue p (1 - x) |
| | .invDen n, x => (expNegInvGlue x + expNegInvGlue (1 - x))⁻¹ ^ n |
| | .add a b, x => a.value x + b.value x |
| | .mul a b, x => a.value x * b.value x |
|
|
| def Expr.bound : Expr → ℚ |
| | .const q => |q| |
| | .left p => glueBound p |
| | .right p => glueBound p |
| | .invDen n => 16 ^ n |
| | .add a b => a.bound + b.bound |
| | .mul a b => a.bound * b.bound |
|
|
| def Expr.diff : Expr → Expr |
| | .const _ => .const 0 |
| | .left p => .left (glueDiff p) |
| | .right p => .mul (.const (-1)) (.right (glueDiff p)) |
| | .invDen n => .mul (.mul (.const (-(n : ℚ))) |
| (.add (.left (glueDiff [(1, 0)])) (.mul (.const (-1)) (.right (glueDiff [(1, 0)]))))) |
| (.invDen (n + 1)) |
| | .add a b => .add a.diff b.diff |
| | .mul a b => .add (.mul a.diff b) (.mul a b.diff) |
|
|
| lemma Expr.bound_nonneg (e : Expr) : 0 ≤ e.bound := by |
| induction e with |
| | const q => exact abs_nonneg q |
| | left p => exact glueBound_nonneg p |
| | right p => exact glueBound_nonneg p |
| | invDen n => change 0 ≤ (16 : ℚ) ^ n; positivity |
| | add a b ha hb => exact add_nonneg ha hb |
| | mul a b ha hb => exact mul_nonneg ha hb |
|
|
| lemma Expr.abs_value_le (e : Expr) (x : ℝ) : |e.value x| ≤ (e.bound : ℝ) := by |
| induction e with |
| | const q => simp [value, bound] |
| | left p => exact abs_glue_le p x |
| | right p => exact abs_glue_le p (1 - x) |
| | invDen n => |
| have hd := denominator_lower x |
| have hp := Real.smoothTransition.pos_denom x |
| have hi : (expNegInvGlue x + expNegInvGlue (1 - x))⁻¹ ≤ 16 := by |
| simpa using (inv_le_inv₀ hp (by norm_num : (0 : ℝ) < 1 / 16)).2 hd |
| simpa only [value, bound, Rat.cast_pow, Rat.cast_ofNat, |
| abs_of_nonneg (pow_nonneg (inv_nonneg.mpr hp.le) n)] using |
| pow_le_pow_left₀ (inv_nonneg.mpr hp.le) hi n |
| | add a b ha hb => |
| exact (abs_add_le _ _).trans (by simpa [bound] using add_le_add ha hb) |
| | mul a b ha hb => |
| simpa [value, bound, abs_mul] using |
| mul_le_mul ha hb (abs_nonneg _) (by exact_mod_cast a.bound_nonneg) |
|
|
| lemma Expr.hasDerivAt (e : Expr) (x : ℝ) : HasDerivAt e.value (e.diff.value x) x := by |
| induction e with |
| | const q => simpa [diff, value] using hasDerivAt_const x (q : ℝ) |
| | left p => exact hasDerivAt_glue p x |
| | right p => |
| convert! (hasDerivAt_glue p (1 - x)).comp x ((hasDerivAt_id x).const_sub 1) using 1 |
| simp [diff, value, mul_comm] |
| | invDen n => |
| have hl : HasDerivAt expNegInvGlue (glue (glueDiff [(1, 0)]) x) x := by |
| simpa [glue_one, Function.comp_def] using hasDerivAt_glue [(1, 0)] x |
| have hr : HasDerivAt (fun y => expNegInvGlue (1 - y)) |
| (-(glue (glueDiff [(1, 0)]) (1 - x))) x := by |
| simpa [glue_one, Function.comp_def] using (hasDerivAt_glue [(1, 0)] (1 - x)).comp x |
| ((hasDerivAt_id x).const_sub 1) |
| let d : ℝ → ℝ := fun y => expNegInvGlue y + expNegInvGlue (1 - y) |
| let a : ℝ := glue (glueDiff [(1, 0)]) x - glue (glueDiff [(1, 0)]) (1 - x) |
| have hd : HasDerivAt d a x := by |
| convert! hl.add hr using 1 |
| have hp : d x ≠ 0 := (Real.smoothTransition.pos_denom x).ne' |
| have hinv : HasDerivAt (fun y => (d y)⁻¹) (-a * (d x)⁻¹ ^ 2) x := by |
| convert! hd.inv hp using 1 |
| simp [div_eq_mul_inv, inv_pow] |
| have hpow (k : ℕ) : HasDerivAt (fun y => (d y)⁻¹ ^ k) |
| (-(k : ℝ) * a * (d x)⁻¹ ^ (k + 1)) x := by |
| induction k with |
| | zero => simpa using hasDerivAt_const x (1 : ℝ) |
| | succ k ih => |
| convert! ih.mul hinv using 1 |
| simp only [Nat.cast_add, Nat.cast_one, pow_succ]; ring |
| simpa only [diff, value, Rat.cast_neg, Rat.cast_natCast, Rat.cast_one, |
| neg_mul, one_mul, mul_neg, sub_eq_add_neg, d, a] using hpow n |
| | add a b ha hb => exact ha.add hb |
| | mul a b ha hb => exact ha.mul hb |
|
|
| lemma Expr.contDiff (e : Expr) : ContDiff ℝ (⊤ : ℕ∞) e.value := by |
| induction e with |
| | const q => exact contDiff_const |
| | left p => exact contDiff_glue p |
| | right p => exact (contDiff_glue p).comp (contDiff_const.sub contDiff_id) |
| | invDen n => |
| exact ((@expNegInvGlue.contDiff ⊤).add |
| (expNegInvGlue.contDiff.comp (contDiff_const.sub contDiff_id))).inv |
| (fun x => (Real.smoothTransition.pos_denom x).ne') |>.pow n |
| | add a b ha hb => exact ha.add hb |
| | mul a b ha hb => exact ha.mul hb |
|
|
| lemma Expr.lipschitz (e : Expr) : |
| LipschitzWith ⟨(e.diff.bound : ℝ), by exact_mod_cast e.diff.bound_nonneg⟩ e.value := by |
| apply lipschitzWith_of_nnnorm_deriv_le (fun x => (e.hasDerivAt x).differentiableAt) |
| intro x |
| change ‖deriv e.value x‖ ≤ (e.diff.bound : ℝ) |
| rw [(e.hasDerivAt x).deriv, Real.norm_eq_abs] |
| exact e.diff.abs_value_le x |
|
|
| def switchExpr (n : ℕ) : Expr := |
| Expr.diff^[n] (.mul (.left [(1, 0)]) (.invDen 1)) |
|
|
| lemma switchExpr_value (n : ℕ) : |
| (switchExpr n).value = iteratedDeriv n Real.smoothTransition := by |
| induction n with |
| | zero => |
| ext x |
| simp [switchExpr, Expr.value, glue_one, Real.smoothTransition, div_eq_mul_inv] |
| | succ n ih => |
| rw [iteratedDeriv_succ, ← ih] |
| ext x |
| simp only [switchExpr, Function.iterate_succ_apply'] |
| exact ((switchExpr n).hasDerivAt x).deriv.symm |
|
|
| end EffectiveProfile |
| end RapidForcing |
|
|
| end |
|
|
| end OAI |
|
|
