| import OAI.MathematicalPhysics.RapidForcing.EffectiveProfiles |
|
|
| namespace OAI |
|
|
| section |
|
|
| open scoped BigOperators Topology |
| open Filter |
| namespace RapidForcing.EffectiveProfile |
|
|
| structure Ball where |
| center : ℚ |
| radius : ℚ |
| deriving DecidableEq |
|
|
| def Ball.exact (q : ℚ) : Ball := ⟨q, 0⟩ |
| def Ball.add (a b : Ball) : Ball := ⟨a.center + b.center, a.radius + b.radius⟩ |
| def Ball.mul (a b : Ball) : Ball := |
| ⟨a.center * b.center, |
| |a.center| * b.radius + |b.center| * a.radius + a.radius * b.radius⟩ |
|
|
| def Ball.pow (a : Ball) : ℕ → Ball |
| | 0 => Ball.exact 1 |
| | n + 1 => (a.pow n).mul a |
|
|
| def Ball.denInv (a : Ball) : Ball := |
| ⟨(max (1 / 16) a.center)⁻¹, 256 * a.radius⟩ |
|
|
| def Ball.Covers (a : Ball) (x : ℝ) : Prop := |(a.center : ℝ) - x| ≤ (a.radius : ℝ) |
|
|
| lemma Ball.Covers.radius_nonneg {a : Ball} {x : ℝ} (h : a.Covers x) : 0 ≤ a.radius := by |
| exact_mod_cast (abs_nonneg _).trans h |
|
|
| lemma Ball.covers_exact (q : ℚ) : (Ball.exact q).Covers q := by |
| simp [Ball.exact, Covers] |
|
|
| lemma Ball.Covers.add {a b : Ball} {x y : ℝ} (ha : a.Covers x) (hb : b.Covers y) : |
| (a.add b).Covers (x + y) := by |
| dsimp [Covers, Ball.add] at * |
| push_cast |
| calc |
| |(a.center : ℝ) + b.center - (x + y)| = |(a.center - x) + (b.center - y)| := by congr 1; ring |
| _ ≤ |(a.center : ℝ) - x| + |(b.center : ℝ) - y| := abs_add_le _ _ |
| _ ≤ _ := add_le_add ha hb |
|
|
| lemma Ball.Covers.mul {a b : Ball} {x y : ℝ} (ha : a.Covers x) (hb : b.Covers y) : |
| (a.mul b).Covers (x * y) := by |
| have he1 : (0 : ℝ) ≤ a.radius := by exact_mod_cast ha.radius_nonneg |
| have he2 : (0 : ℝ) ≤ b.radius := by exact_mod_cast hb.radius_nonneg |
| change |((a.center * b.center : ℚ) : ℝ) - x * y| ≤ _ |
| simp only [Ball.mul, Rat.cast_mul, Rat.cast_add, Rat.cast_abs] |
| calc |
| |(a.center : ℝ) * b.center - x*y| = |
| |(a.center : ℝ) * (b.center - y) + (b.center : ℝ) * (a.center - x) - |
| (a.center - x) * (b.center - y)| := by congr 1; ring |
| _ ≤ |(a.center : ℝ) * (b.center - y)| + |(b.center : ℝ) * (a.center - x)| + |
| |((a.center : ℝ) - x) * (b.center - y)| := |
| (abs_sub _ _).trans (add_le_add (abs_add_le _ _) le_rfl) |
| _ ≤ _ := by |
| simp only [abs_mul] |
| gcongr |
| · exact hb |
| · exact ha |
| · exact ha |
| · exact hb |
|
|
| lemma Ball.Covers.pow {a : Ball} {x : ℝ} (ha : a.Covers x) (n : ℕ) : |
| (a.pow n).Covers (x ^ n) := by |
| induction n with |
| | zero => simpa [Ball.pow] using Ball.covers_exact 1 |
| | succ n ih => simpa only [Ball.pow, pow_succ] using ih.mul ha |
|
|
| lemma clamp_dist (c x : ℝ) (hx : (1 / 16 : ℝ) ≤ x) : |
| |max (1 / 16) c - x| ≤ |c - x| := by |
| by_cases hc : (1 / 16 : ℝ) ≤ c |
| · rw [max_eq_right hc] |
| · rw [max_eq_left (le_of_not_ge hc), abs_of_nonpos (by linarith), |
| abs_of_nonpos (by linarith)] |
| linarith |
|
|
| lemma Ball.Covers.denInv {a : Ball} {x : ℝ} (ha : a.Covers x) (hx : (1 / 16 : ℝ) ≤ x) : |
| a.denInv.Covers x⁻¹ := by |
| have hz : (1 / 16 : ℝ) ≤ max (1 / 16) (a.center : ℝ) := le_max_left _ _ |
| have hp : 0 < max (1 / 16) (a.center : ℝ) := lt_of_lt_of_le (by norm_num) hz |
| have hxp : 0 < x := by linarith |
| have hprod : (1 / 256 : ℝ) ≤ max (1 / 16) (a.center : ℝ) * x := by nlinarith |
| change |(((max (1 / 16) a.center)⁻¹ : ℚ) : ℝ) - x⁻¹| ≤ _ |
| simp only [Ball.denInv, Rat.cast_inv, Rat.cast_max, Rat.cast_div, Rat.cast_one, |
| Rat.cast_ofNat, Rat.cast_mul] |
| rw [inv_sub_inv hp.ne' hxp.ne', abs_div, abs_mul, abs_of_pos hp, abs_of_pos hxp, |
| (div_le_iff₀ (mul_pos hp hxp))] |
| calc |
| |x - max (1 / 16) (a.center : ℝ)| = |max (1 / 16) (a.center : ℝ) - x| := abs_sub_comm _ _ |
| _ ≤ |(a.center : ℝ) - x| := clamp_dist _ _ hx |
| _ ≤ (a.radius : ℝ) := ha |
| _ ≤ 256 * (a.radius : ℝ) * (max (1 / 16) (a.center : ℝ) * x) := by |
| have hnon : (0 : ℝ) ≤ a.radius := by exact_mod_cast ha.radius_nonneg |
| nlinarith |
|
|
| def Encloses (b : ℕ → Ball) (x : ℝ) : Prop := |
| (∀ k, (b k).Covers x) ∧ Tendsto (fun k => ((b k).radius : ℝ)) atTop (𝓝 0) |
|
|
| lemma Encloses.centers {b : ℕ → Ball} {x : ℝ} (h : Encloses b x) : |
| Tendsto (fun k => ((b k).center : ℝ)) atTop (𝓝 x) := by |
| apply tendsto_iff_norm_sub_tendsto_zero.2 |
| exact squeeze_zero (fun _ => norm_nonneg _) (fun k => by simpa only [Real.norm_eq_abs, Ball.Covers] using h.1 k) h.2 |
|
|
| lemma encloses_exact (q : ℚ) : Encloses (fun _ => Ball.exact q) q := |
| ⟨fun _ => Ball.covers_exact _, by simp [Ball.exact]⟩ |
|
|
| lemma Encloses.add {a b : ℕ → Ball} {x y : ℝ} (ha : Encloses a x) (hb : Encloses b y) : |
| Encloses (fun k => (a k).add (b k)) (x + y) := |
| ⟨fun k => (ha.1 k).add (hb.1 k), by simpa only [Ball.add, Rat.cast_add, add_zero] using ha.2.add hb.2⟩ |
|
|
| lemma Encloses.mul {a b : ℕ → Ball} {x y : ℝ} (ha : Encloses a x) (hb : Encloses b y) : |
| Encloses (fun k => (a k).mul (b k)) (x * y) := by |
| refine ⟨fun k => (ha.1 k).mul (hb.1 k), ?_⟩ |
| simpa only [Ball.mul, Rat.cast_add, Rat.cast_mul, Rat.cast_abs, mul_zero, add_zero] |
| using ((ha.centers.abs.mul hb.2).add (hb.centers.abs.mul ha.2)).add (ha.2.mul hb.2) |
|
|
| lemma Encloses.pow {a : ℕ → Ball} {x : ℝ} (ha : Encloses a x) (n : ℕ) : |
| Encloses (fun k => (a k).pow n) (x ^ n) := by |
| induction n with |
| | zero => simpa [Ball.pow] using encloses_exact 1 |
| | succ n ih => simpa [Ball.pow, pow_succ] using ih.mul ha |
|
|
| lemma Encloses.denInv {a : ℕ → Ball} {x : ℝ} (ha : Encloses a x) (hx : (1 / 16 : ℝ) ≤ x) : |
| Encloses (fun k => (a k).denInv) x⁻¹ := |
| ⟨fun k => (ha.1 k).denInv hx, by simpa [Ball.denInv] using ha.2.const_mul 256⟩ |
|
|
| def expTerms (q : ℚ) (k : ℕ) : ℕ := k + ⌈2 * |q|⌉₊ + 1 |
|
|
| def expBall (q : ℚ) (k : ℕ) : Ball := |
| let n := expTerms q k |
| ⟨∑ j ∈ Finset.range n, q ^ j / (j.factorial : ℚ), |
| |q| ^ n / (n.factorial : ℚ) * 2⟩ |
|
|
| lemma expTerms_large (q : ℚ) (k : ℕ) : |(q : ℝ)| / (expTerms q k + 1) ≤ 1 / 2 := by |
| have h : 2 * |(q : ℝ)| ≤ (⌈2 * |q|⌉₊ : ℝ) := by |
| exact_mod_cast (Nat.le_ceil (2 * |q|)) |
| have hp : (0 : ℝ) < expTerms q k + 1 := by positivity |
| apply (div_le_iff₀ hp).2 |
| dsimp [expTerms] |
| push_cast |
| have : (0 : ℝ) ≤ k := Nat.cast_nonneg _ |
| linarith |
|
|
| lemma expBall_covers (q : ℚ) (k : ℕ) : (expBall q k).Covers (Real.exp q) := by |
| have h := @Complex.exp_bound' (q : ℂ) (expTerms q k) (by |
| simpa only [← Complex.ofReal_ratCast, Complex.norm_real, Real.norm_eq_abs, Nat.cast_succ] |
| using expTerms_large q k) |
| have heq : (Complex.exp (q : ℂ) - ∑ j ∈ Finset.range (expTerms q k), |
| (q : ℂ) ^ j / (j.factorial : ℂ)) = |
| ((Real.exp (q : ℝ) - ∑ j ∈ Finset.range (expTerms q k), |
| (q : ℝ) ^ j / (j.factorial : ℝ)) : ℝ) := by |
| simp |
| rw [heq, Complex.norm_real, Real.norm_eq_abs] at h |
| simpa [Ball.Covers, expBall, Complex.norm_real, Real.norm_eq_abs, abs_sub_comm, |
| ← Complex.ofReal_ratCast, Rat.norm_cast_real] using h |
|
|
| lemma expBall_encloses (q : ℚ) : Encloses (expBall q) (Real.exp q) := by |
| refine ⟨expBall_covers q, ?_⟩ |
| have hN : Tendsto (expTerms q) atTop atTop := by |
| exact (tendsto_add_atTop_nat (⌈2 * |q|⌉₊ + 1)).congr (fun n => by simp [expTerms, Nat.add_assoc]) |
| have h := (FloorSemiring.tendsto_pow_div_factorial_atTop |(q : ℝ)|).comp hN |
| simpa [expBall] using h.mul_const 2 |
|
|
| def monoBall (n : ℕ) (q : ℚ) (k : ℕ) : Ball := |
| if q ≤ 0 then Ball.exact 0 else |
| (Ball.exact (q⁻¹ ^ n)).mul (expBall (-q⁻¹) k) |
|
|
| def glueBall : GluePoly → ℚ → ℕ → Ball |
| | [], _, _ => Ball.exact 0 |
| | (a, n) :: p, q, k => ((Ball.exact a).mul (monoBall n q k)).add (glueBall p q k) |
|
|
| lemma monoBall_encloses (n : ℕ) (q : ℚ) : Encloses (monoBall n q) (monoGlue n q) := by |
| by_cases hq : q ≤ 0 |
| · have hx : (q : ℝ) ≤ 0 := by exact_mod_cast hq |
| unfold monoBall |
| simpa [hq, monoGlue, expNegInvGlue.zero_of_nonpos hx] using encloses_exact 0 |
| · have hx : ¬ (q : ℝ) ≤ 0 := by exact_mod_cast hq |
| unfold monoBall |
| simpa [hq, monoGlue, expNegInvGlue, hx] using |
| (encloses_exact (q⁻¹ ^ n)).mul (expBall_encloses (-q⁻¹)) |
|
|
| lemma glueBall_encloses (p : GluePoly) (q : ℚ) : Encloses (glueBall p q) (glue p q) := by |
| induction p with |
| | nil => simpa [glueBall, glue] using encloses_exact 0 |
| | cons a p ih => |
| rcases a with ⟨a, n⟩ |
| exact ((encloses_exact a).mul (monoBall_encloses n q)).add ih |
|
|
| def Expr.numeric : Expr → ℚ → ℕ → Ball |
| | .const a, _, _ => Ball.exact a |
| | .left p, q, k => glueBall p q k |
| | .right p, q, k => glueBall p (1 - q) k |
| | .invDen n, q, k => |
| ((glueBall [(1, 0)] q k).add (glueBall [(1, 0)] (1 - q) k)).denInv.pow n |
| | .add a b, q, k => (a.numeric q k).add (b.numeric q k) |
| | .mul a b, q, k => (a.numeric q k).mul (b.numeric q k) |
|
|
| lemma Expr.numeric_encloses (e : Expr) (q : ℚ) : Encloses (e.numeric q) (e.value q) := by |
| induction e with |
| | const a => exact encloses_exact a |
| | left p => exact glueBall_encloses p q |
| | right p => simpa [Expr.value, Expr.numeric] using glueBall_encloses p (1 - q) |
| | invDen n => |
| have hd : Encloses (fun k => (glueBall [(1, 0)] q k).add (glueBall [(1, 0)] (1 - q) k)) |
| (expNegInvGlue q + expNegInvGlue (1 - q)) := by |
| simpa only [glue_one, Rat.cast_sub, Rat.cast_one] using |
| (glueBall_encloses [(1, 0)] q).add (glueBall_encloses [(1, 0)] (1 - q)) |
| exact (hd.denInv (denominator_lower q)).pow n |
| | add a b ha hb => exact ha.add hb |
| | mul a b ha hb => exact ha.mul hb |
|
|
| def Expr.numericError (e : Expr) (q : ℚ) (k : ℕ) (inputError : ℚ) : ℚ := |
| (e.numeric q k).radius + e.diff.bound * inputError |
|
|
| lemma Expr.numeric_error_le (e : Expr) (q : ℚ) (k : ℕ) (r : ℚ) (x : ℝ) |
| (hx : |(q : ℝ) - x| ≤ (r : ℝ)) : |
| |((e.numeric q k).center : ℝ) - e.value x| ≤ (e.numericError q k r : ℝ) := by |
| have he := (e.numeric_encloses q).1 k |
| have hd : |e.value q - e.value x| ≤ (e.diff.bound : ℝ) * |(q : ℝ) - x| := by |
| exact e.lipschitz.dist_le_mul (q : ℝ) x |
| calc |
| _ ≤ |((e.numeric q k).center : ℝ) - e.value q| + |e.value q - e.value x| := abs_sub_le _ _ _ |
| _ ≤ (e.numeric q k).radius + (e.diff.bound : ℝ) * (r : ℝ) := |
| add_le_add he (hd.trans (mul_le_mul_of_nonneg_left hx (by exact_mod_cast e.diff.bound_nonneg))) |
| _ = _ := by simp [numericError] |
|
|
| end RapidForcing.EffectiveProfile |
|
|
| end |
|
|
| end OAI |
|
|
