math / data /lean /OAI /MathematicalPhysics /RapidForcing /FormulaNames.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
8.6 kB
import OAI.MathematicalPhysics.RapidForcing.FieldExpressions
namespace OAI
section
open scoped BigOperators Topology
open Set Filter
namespace RapidForcing.EffectiveProfile
namespace Formula
variable {d : β„•}
def lipBound (R : β„š) : Formula d β†’ β„š
| .const _ => 0
| .var _ => 1
| .add a b => a.lipBound R + b.lipBound R
| .mul a b => a.bound R * b.lipBound R + b.bound R * a.lipBound R
| .profile e a => e.diff.bound * a.lipBound R
lemma lipBound_nonneg (a : Formula d) (R : β„š) : 0 ≀ a.lipBound R := by
induction a with
| const q => rfl
| var i => norm_num [lipBound]
| add a b ha hb => exact add_nonneg ha hb
| mul a b ha hb =>
exact add_nonneg (mul_nonneg (a.bound_nonneg R) hb) (mul_nonneg (b.bound_nonneg R) ha)
| profile e a ha => exact mul_nonneg e.diff.bound_nonneg ha
lemma abs_sub_le_lipBound (a : Formula d) (R : β„š) (x y : Fin d β†’ ℝ)
(hx : βˆ€ i, |x i| ≀ |(R : ℝ)|) (hy : βˆ€ i, |y i| ≀ |(R : ℝ)|) :
|a.value x - a.value y| ≀ (a.lipBound R : ℝ) * β€–x - yβ€– := by
induction a with
| const q => simp [value, lipBound]
| var i => simpa [value, lipBound, Real.norm_eq_abs] using norm_le_pi_norm (x - y) i
| add a b ha hb =>
calc
_ = |(a.value x - a.value y) + (b.value x - b.value y)| := by dsimp [value]; congr 1; ring
_ ≀ |a.value x - a.value y| + |b.value x - b.value y| := abs_add_le _ _
_ ≀ (a.lipBound R : ℝ) * β€–x - yβ€– + (b.lipBound R : ℝ) * β€–x - yβ€– := add_le_add ha hb
_ = _ := by simp [lipBound, add_mul]
| mul a b ha hb =>
calc
_ = |a.value x * (b.value x - b.value y) + b.value y * (a.value x - a.value y)| := by
dsimp [value]; congr 1; ring
_ ≀ |a.value x| * |b.value x - b.value y| + |b.value y| * |a.value x - a.value y| := by
simpa [abs_mul] using abs_add_le (a.value x * (b.value x - b.value y))
(b.value y * (a.value x - a.value y))
_ ≀ (a.bound R : ℝ) * ((b.lipBound R : ℝ) * β€–x - yβ€–) +
(b.bound R : ℝ) * ((a.lipBound R : ℝ) * β€–x - yβ€–) := by
apply add_le_add
Β· exact mul_le_mul (a.abs_value_le R x hx) hb (abs_nonneg _) (by exact_mod_cast a.bound_nonneg R)
Β· exact mul_le_mul (b.abs_value_le R y hy) ha (abs_nonneg _) (by exact_mod_cast b.bound_nonneg R)
_ = _ := by simp only [lipBound, Rat.cast_add, Rat.cast_mul]; ring
| profile e a ha =>
have he : |e.value (a.value x) - e.value (a.value y)| ≀
(e.diff.bound : ℝ) * |a.value x - a.value y| := e.lipschitz.dist_le_mul _ _
exact he.trans (by simpa only [lipBound, Rat.cast_mul, mul_assoc] using
mul_le_mul_of_nonneg_left ha (show (0 : ℝ) ≀ e.diff.bound by exact_mod_cast e.diff.bound_nonneg))
def RationalName (name : β„• β†’ Part (Fin d β†’ β„š)) (x : Fin d β†’ ℝ) : Prop :=
βˆ€ n, βˆƒ q, q ∈ name n ∧ β€–(fun i => (q i : ℝ)) - xβ€– ≀ accuracy n
def choosePrecision (L Ξ΅ : β„š) : Part β„• :=
Nat.rfindOpt fun n => if (1 / 2 : β„š) ^ n * L ≀ Ξ΅ / 2 then some n else none
lemma choosePrecision_spec (L Ξ΅ : β„š) {n : β„•} (hn : n ∈ choosePrecision L Ξ΅) :
(1 / 2 : β„š) ^ n * L ≀ Ξ΅ / 2 := by
obtain ⟨m, hm⟩ := Nat.rfindOpt_spec hn
split_ifs at hm with h
Β· have he := Option.mem_some_iff.mp hm
subst m
exact h
Β· cases hm
lemma choosePrecision_dom (L Ξ΅ : β„š) (hΞ΅ : 0 < Ξ΅) : (choosePrecision L Ξ΅).Dom := by
have he : (0 : ℝ) < (Ξ΅ : ℝ) / 2 := by exact_mod_cast (half_pos hΞ΅)
have hlim : Tendsto (fun n : β„• => (1 / 2 : ℝ) ^ n * (L : ℝ)) atTop (𝓝 0) := by
simpa using (tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0 : ℝ) ≀ 1 / 2)
(by norm_num : (1 / 2 : ℝ) < 1)).mul_const (L : ℝ)
obtain ⟨n, hn⟩ := (hlim.eventually (Iio_mem_nhds he)).exists
have hn'' : (((1 / 2 : β„š) ^ n * L : β„š) : ℝ) ≀ ((Ξ΅ / 2 : β„š) : ℝ) := by
simpa only [Rat.cast_mul, Rat.cast_pow, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hn.le
have hn' : (1 / 2 : β„š) ^ n * L ≀ Ξ΅ / 2 := by exact_mod_cast hn''
exact Nat.rfindOpt_dom.mpr ⟨n, n, by rw [ite_eq_left hn']; rfl⟩
def evalName (a : Formula d) (name : β„• β†’ Part (Fin d β†’ β„š)) (Ξ΅ : β„š) : Part Ball := do
let qβ‚€ ← name 0
let R := 2 + βˆ‘ i, |qβ‚€ i|
let L := a.lipBound R
let n ← choosePrecision L Ξ΅
let q ← name n
let b ← a.evalAt q (Ξ΅ / 2)
pure ⟨b.center, b.radius + (1 / 2 : β„š) ^ n * L⟩
lemma rationalName_spec {name : β„• β†’ Part (Fin d β†’ β„š)} {x : Fin d β†’ ℝ}
(hn : RationalName name x) (n : β„•) {q : Fin d β†’ β„š} (hq : q ∈ name n) :
β€–(fun i => (q i : ℝ)) - xβ€– ≀ accuracy n := by
obtain ⟨q', hq', he⟩ := hn n
exact Part.mem_unique hq hq' β–Έ he
lemma accuracy_le_one (n : β„•) : accuracy n ≀ 1 :=
pow_le_oneβ‚€ (by norm_num) (by norm_num)
lemma name_box {name : β„• β†’ Part (Fin d β†’ β„š)} {x : Fin d β†’ ℝ}
(hn : RationalName name x) {qβ‚€ q : Fin d β†’ β„š} (hβ‚€ : qβ‚€ ∈ name 0)
{n : β„•} (hq : q ∈ name n) :
(βˆ€ i, |x i| ≀ |((2 + βˆ‘ j, |qβ‚€ j| : β„š) : ℝ)|) ∧
(βˆ€ i, |(q i : ℝ)| ≀ |((2 + βˆ‘ j, |qβ‚€ j| : β„š) : ℝ)|) := by
have hdistβ‚€ := rationalName_spec hn 0 hβ‚€
have hdist := (rationalName_spec hn n hq).trans (accuracy_le_one n)
have hp : (0 : β„š) ≀ 2 + βˆ‘ j, |qβ‚€ j| := by positivity
have hp' : (0 : ℝ) ≀ ((2 + βˆ‘ j, |qβ‚€ j| : β„š) : ℝ) := by exact_mod_cast hp
constructor
Β· intro i
have hi := (norm_le_pi_norm ((fun j => (qβ‚€ j : ℝ)) - x) i).trans hdistβ‚€
have hsum : |(qβ‚€ i : ℝ)| ≀ (βˆ‘ j, |qβ‚€ j| : β„š) := by
exact_mod_cast (Finset.single_le_sum (fun j (_ : j ∈ (Finset.univ : Finset (Fin d))) => abs_nonneg (qβ‚€ j))
(Finset.mem_univ i))
have ht := abs_sub_le (x i) (qβ‚€ i : ℝ) 0
simp only [Real.norm_eq_abs, Pi.sub_apply, accuracy, pow_zero] at hi
rw [abs_sub_comm] at hi
simp only [sub_zero] at ht
rw [abs_of_nonneg hp', Rat.cast_add, Rat.cast_ofNat]
linarith
Β· intro i
have hi := (norm_le_pi_norm ((fun j => (qβ‚€ j : ℝ)) - x) i).trans hdistβ‚€
have hi' := (norm_le_pi_norm ((fun j => (q j : ℝ)) - x) i).trans hdist
have hsum : |(qβ‚€ i : ℝ)| ≀ (βˆ‘ j, |qβ‚€ j| : β„š) := by
exact_mod_cast (Finset.single_le_sum (fun j (_ : j ∈ (Finset.univ : Finset (Fin d))) => abs_nonneg (qβ‚€ j))
(Finset.mem_univ i))
have ht := abs_sub_le (q i : ℝ) (x i) (qβ‚€ i : ℝ)
have ht' := abs_sub_le (q i : ℝ) (qβ‚€ i : ℝ) 0
simp only [Real.norm_eq_abs, Pi.sub_apply, accuracy, pow_zero] at hi hi'
rw [abs_sub_comm] at hi
simp only [sub_zero] at ht'
rw [abs_of_nonneg hp', Rat.cast_add, Rat.cast_ofNat]
linarith
lemma evalName_spec (a : Formula d) {name : β„• β†’ Part (Fin d β†’ β„š)} {x : Fin d β†’ ℝ}
(hn : RationalName name x) (Ξ΅ : β„š) (hΞ΅ : 0 < Ξ΅) {b : Ball} (hb : b ∈ a.evalName name Ξ΅) :
b.Covers (a.value x) ∧ b.radius ≀ Ξ΅ := by
obtain ⟨qβ‚€, hβ‚€, hrest⟩ := Part.mem_bind_iff.mp hb
obtain ⟨n, hn', hrest⟩ := Part.mem_bind_iff.mp hrest
obtain ⟨q, hq, hrest⟩ := Part.mem_bind_iff.mp hrest
obtain ⟨c, hc, hb⟩ := Part.mem_bind_iff.mp hrest
have he : b = ⟨c.center, c.radius + (1 / 2 : β„š) ^ n * a.lipBound (2 + βˆ‘ i, |qβ‚€ i|)⟩ :=
Part.mem_some_iff.mp hb
subst b
have hprec := choosePrecision_spec _ _ hn'
obtain ⟨hc, hc'⟩ := a.evalAt_spec q (Ρ / 2) (by positivity) hc
obtain ⟨hx, hy⟩ := name_box hn hβ‚€ hq
have hdist := a.abs_sub_le_lipBound _ _ _ hy hx
have hbound := rationalName_spec hn n hq
have hL : (0 : ℝ) ≀ a.lipBound (2 + βˆ‘ i, |qβ‚€ i|) := by exact_mod_cast a.lipBound_nonneg _
refine ⟨?_, by change c.radius + (1 / 2 : β„š) ^ n * a.lipBound (2 + βˆ‘ i, |qβ‚€ i|) ≀ Ξ΅; linarith⟩
change |(c.center : ℝ) - a.value x| ≀ _
calc
_ ≀ |(c.center : ℝ) - a.value (fun i => (q i : ℝ))| +
|a.value (fun i => (q i : ℝ)) - a.value x| := abs_sub_le _ _ _
_ ≀ (c.radius : ℝ) + (a.lipBound (2 + βˆ‘ i, |qβ‚€ i|) : ℝ) * accuracy n :=
add_le_add hc (hdist.trans (mul_le_mul_of_nonneg_left hbound hL))
_ = _ := by simp [accuracy, mul_comm]
lemma evalName_dom (a : Formula d) {name : β„• β†’ Part (Fin d β†’ β„š)} {x : Fin d β†’ ℝ}
(hn : RationalName name x) (Ξ΅ : β„š) (hΞ΅ : 0 < Ξ΅) : (a.evalName name Ξ΅).Dom := by
have ht (n : β„•) : (name n).Dom := let ⟨_, h, _⟩ := hn n; h.fst
refine ⟨ht 0, choosePrecision_dom _ _ hΡ, ht _, ?_⟩
exact ⟨a.evalAt_dom _ _ (by positivity), trivial⟩
end Formula
end RapidForcing.EffectiveProfile
end
end OAI