lean/OAI/MathematicalPhysics/RapidForcing/FieldExpressions.lean

import OAI.MathematicalPhysics.RapidForcing.RationalProfiles

namespace OAI

section

open scoped BigOperators Topology
open Set Filter
namespace RapidForcing.EffectiveProfile

def Expr.approx (e : Expr) (q ε : ℚ) : Part Ball :=
  Nat.rfindOpt fun k => if (e.numeric q k).radius ≤ ε then some (e.numeric q k) else none

lemma Expr.approx_spec (e : Expr) (q ε : ℚ) {b : Ball} (hb : b ∈ e.approx q ε) :
    b.Covers (e.value q) ∧ b.radius ≤ ε := by
  obtain ⟨k, hk⟩ := Nat.rfindOpt_spec hb
  split_ifs at hk with hk'
  · have heq : b = e.numeric q k := (Option.mem_some_iff.mp hk).symm
    subst b
    exact ⟨(e.numeric_encloses q).1 k, hk'⟩
  · cases hk

lemma Expr.approx_dom (e : Expr) (q ε : ℚ) (hε : 0 < ε) : (e.approx q ε).Dom := by
  have hε' : (0 : ℝ) < ε := by exact_mod_cast hε
  obtain ⟨k, hk⟩ := ((e.numeric_encloses q).2.eventually (Iio_mem_nhds hε')).exists
  have hk' : (e.numeric q k).radius ≤ ε := by exact_mod_cast hk.le
  apply Nat.rfindOpt_dom.mpr
  exact ⟨k, e.numeric q k, by simp [hk']⟩

inductive Formula (d : ℕ) where
  | const : ℚ → Formula d
  | var : Fin d → Formula d
  | add : Formula d → Formula d → Formula d
  | mul : Formula d → Formula d → Formula d
  | profile : Expr → Formula d → Formula d

namespace Formula
variable {d : ℕ}

noncomputable def value : Formula d → (Fin d → ℝ) → ℝ
  | .const q, _ => q
  | .var i, x => x i
  | .add a b, x => a.value x + b.value x
  | .mul a b, x => a.value x * b.value x
  | .profile e a, x => e.value (a.value x)

def neg (a : Formula d) : Formula d := .mul (.const (-1)) a

def sub (a b : Formula d) : Formula d := .add a b.neg

@[simp] lemma value_neg (a : Formula d) (x : Fin d → ℝ) :
    a.neg.value x = -a.value x := by simp [neg, value]
@[simp] lemma value_sub (a b : Formula d) (x : Fin d → ℝ) :
    (a.sub b).value x = a.value x - b.value x := by simp [sub, value, sub_eq_add_neg]

def bound (R : ℚ) : Formula d → ℚ
  | .const q => |q|
  | .var _ => |R|
  | .add a b => a.bound R + b.bound R
  | .mul a b => a.bound R * b.bound R
  | .profile e _ => e.bound

lemma bound_nonneg (a : Formula d) (R : ℚ) : 0 ≤ a.bound R := by
  induction a with
  | const q => exact abs_nonneg _
  | var i => exact abs_nonneg _
  | add a b ha hb => exact add_nonneg ha hb
  | mul a b ha hb => exact mul_nonneg ha hb
  | profile e a ha => exact e.bound_nonneg

lemma abs_value_le (a : Formula d) (R : ℚ) (x : Fin d → ℝ)
    (hx : ∀ i, |x i| ≤ |(R : ℝ)|) : |a.value x| ≤ (a.bound R : ℝ) := by
  induction a with
  | const q => simp [value, bound]
  | var i => simpa [value, bound] using hx i
  | 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 _)
      (show (0 : ℝ) ≤ a.bound R by exact_mod_cast a.bound_nonneg R)
  | profile e a ha => exact e.abs_value_le _

def diff (i : Fin d) : Formula d → Formula d
  | .const _ => .const 0
  | .var j => .const (if j = i then 1 else 0)
  | .add a b => .add (a.diff i) (b.diff i)
  | .mul a b => .add (.mul (a.diff i) b) (.mul a (b.diff i))
  | .profile e a => .mul (.profile e.diff a) (a.diff i)

lemma contDiff (a : Formula d) : ContDiff ℝ (⊤ : ℕ∞) a.value := by
  induction a with
  | const q => exact contDiff_const
  | var i => exact contDiff_apply ℝ ℝ i
  | add a b ha hb => exact ha.add hb
  | mul a b ha hb => exact ha.mul hb
  | profile e a ha => exact e.contDiff.comp ha

lemma hasDerivAt_line (a : Formula d) (i : Fin d) (x : Fin d → ℝ) (t : ℝ) :
    HasDerivAt (fun s => a.value (x + s • Pi.single i (1 : ℝ)))
      ((a.diff i).value (x + t • Pi.single i 1)) t := by
  induction a with
  | const q => simpa [diff, value] using hasDerivAt_const t (q : ℝ)
  | var j =>
    by_cases h : j = i
    · subst j
      simpa [diff, value, Pi.single_apply] using (hasDerivAt_id t).const_add (x i)
    · simpa [diff, value, Pi.single_apply, h, Ne.symm h] using hasDerivAt_const t (x j)
  | add a b ha hb => exact ha.add hb
  | mul a b ha hb => exact ha.mul hb
  | profile e a ha => exact (e.hasDerivAt _).comp t ha

lemma fderiv_apply_single (a : Formula d) (i : Fin d) (x : Fin d → ℝ) :
    fderiv ℝ a.value x (Pi.single i 1) = (a.diff i).value x := by
  have hline : HasDerivAt (fun s : ℝ => x + s • Pi.single i (1 : ℝ))
      (Pi.single i 1) 0 := by
    simpa using ((hasDerivAt_id (0 : ℝ)).smul_const (Pi.single i (1 : ℝ))).const_add x
  have hf : HasFDerivAt a.value (fderiv ℝ a.value x) (x + (0 : ℝ) • Pi.single i 1) := by
    simpa using (a.contDiff.differentiable (by simp) x).hasFDerivAt
  have h := hf.comp_hasDerivAt 0 hline
  simpa using h.unique (a.hasDerivAt_line i x 0)

def evalAt (a : Formula d) (q : Fin d → ℚ) (ε : ℚ) : Part Ball :=
  match a with
  | .const r => Part.some (Ball.exact r)
  | .var i => Part.some (Ball.exact (q i))
  | .add a b => do
      let u ← a.evalAt q (ε / 2)
      let v ← b.evalAt q (ε / 2)
      pure (u.add v)
  | .mul a b =>
      let R := 1 + ∑ i, |q i|
      let η := min 1 (ε / (4 * (a.bound R + b.bound R + 2)))
      do
        let u ← a.evalAt q η
        let v ← b.evalAt q η
        pure (u.mul v)
  | .profile e a => do
      let u ← a.evalAt q (ε / (2 * (e.diff.bound + 1)))
      let v ← e.approx u.center (ε / 2)
      pure ⟨v.center, v.radius + e.diff.bound * u.radius⟩

lemma Ball.Covers.center_le {a : Ball} {x : ℝ} (h : a.Covers x) {B : ℚ}
    (hB : |x| ≤ (B : ℝ)) : |a.center| ≤ B + a.radius := by
  have he : |(a.center : ℝ)| ≤ (B : ℝ) + a.radius := by
    calc
      _ ≤ |(a.center : ℝ) - x| + |x| := by simpa using abs_sub_le (a.center : ℝ) x 0
      _ ≤ (a.radius : ℝ) + B := add_le_add h hB
      _ = _ := by ring
  exact_mod_cast he

lemma numeric_operand_bound (a : Formula d) (q : Fin d → ℚ) :
    |a.value (fun i => q i)| ≤ (a.bound (1 + ∑ i, |q i|) : ℝ) := by
  apply a.abs_value_le
  intro i
  have h : |q i| ≤ 1 + ∑ j, |q j| := by
    have := Finset.single_le_sum (fun j (_ : j ∈ (Finset.univ : Finset (Fin d))) => abs_nonneg (q j))
      (Finset.mem_univ i)
    linarith
  have hp : (0 : ℚ) ≤ 1 + ∑ j, |q j| := by positivity
  exact_mod_cast (show |q i| ≤ |1 + (∑ j, |q j|)| by simpa [abs_of_nonneg hp] using h)

lemma evalAt_spec (a : Formula d) (q : Fin d → ℚ) (ε : ℚ) (hε : 0 < ε)
    {r : Ball} (hr : r ∈ a.evalAt q ε) :
    r.Covers (a.value (fun i => q i)) ∧ r.radius ≤ ε := by
  induction a generalizing ε r with
  | const c =>
    have he : r = Ball.exact c := Part.mem_some_iff.mp hr
    subst r
    exact ⟨Ball.covers_exact c, hε.le⟩
  | var i =>
    have he : r = Ball.exact (q i) := Part.mem_some_iff.mp hr
    subst r
    exact ⟨Ball.covers_exact _, hε.le⟩
  | add a b ha hb =>
    obtain ⟨u, hu, hrest⟩ := Part.mem_bind_iff.mp hr
    obtain ⟨v, hv, hr⟩ := Part.mem_bind_iff.mp hrest
    have he : r = u.add v := Part.mem_some_iff.mp hr
    subst r
    obtain ⟨hu, hu'⟩ := ha _ (by positivity) hu
    obtain ⟨hv, hv'⟩ := hb _ (by positivity) hv
    refine ⟨hu.add hv, ?_⟩
    change u.radius + v.radius ≤ ε
    linarith
  | mul a b ha hb =>
    let R : ℚ := 1 + ∑ i, |q i|
    let B : ℚ := a.bound R + b.bound R + 2
    let η : ℚ := min 1 (ε / (4 * B))
    have hB : 0 < B := by dsimp [B]; linarith [a.bound_nonneg R, b.bound_nonneg R]
    have hη : 0 < η := lt_min (by norm_num) (by positivity)
    obtain ⟨u, hu, hrest⟩ := Part.mem_bind_iff.mp hr
    obtain ⟨v, hv, hr⟩ := Part.mem_bind_iff.mp hrest
    have he : r = u.mul v := Part.mem_some_iff.mp hr
    subst r
    obtain ⟨hu, hu'⟩ := ha _ hη hu
    obtain ⟨hv, hv'⟩ := hb _ hη hv
    have huc := Ball.Covers.center_le hu (a.numeric_operand_bound q)
    have hvc := Ball.Covers.center_le hv (b.numeric_operand_bound q)
    have hu0 := hu.radius_nonneg
    have hv0 := hv.radius_nonneg
    have hη1 : η ≤ 1 := min_le_left _ _
    have hηε : η * (4 * B) ≤ ε := (le_div_iff₀ (by positivity)).mp (min_le_right _ _)
    have huc' : |u.center| ≤ a.bound R + 1 := by
      change |u.center| ≤ a.bound R + u.radius at huc
      linarith
    have hvc' : |v.center| ≤ b.bound R + 1 := by
      change |v.center| ≤ b.bound R + v.radius at hvc
      linarith
    have hB0 : 0 ≤ b.bound R + 1 := by linarith [b.bound_nonneg R]
    have hA0 : 0 ≤ a.bound R + 1 := by linarith [a.bound_nonneg R]
    refine ⟨hu.mul hv, ?_⟩
    change |u.center| * v.radius + |v.center| * u.radius + u.radius * v.radius ≤ ε
    calc
      _ ≤ (a.bound R + 1) * η + (b.bound R + 1) * η + η * η := by
        gcongr
      _ ≤ (a.bound R + b.bound R + 3) * η := by nlinarith
      _ ≤ (4 * B) * η := by
        apply mul_le_mul_of_nonneg_right _ hη.le
        dsimp [B]
        linarith [a.bound_nonneg R, b.bound_nonneg R]
      _ ≤ ε := by simpa [mul_comm] using hηε
  | profile e a ha =>
    obtain ⟨u, hu, hrest⟩ := Part.mem_bind_iff.mp hr
    obtain ⟨v, hv, hr⟩ := Part.mem_bind_iff.mp hrest
    have he : r = ⟨v.center, v.radius + e.diff.bound * u.radius⟩ := Part.mem_some_iff.mp hr
    subst r
    have hL : 0 < 2 * (e.diff.bound + 1) := by linarith [e.diff.bound_nonneg]
    obtain ⟨hu, hu'⟩ := ha _ (div_pos hε hL) hu
    obtain ⟨hv, hv'⟩ := e.approx_spec _ _ hv
    refine ⟨?_, ?_⟩
    · change |(v.center : ℝ) - e.value (a.value (fun i => q i))| ≤ _
      have hd : |e.value u.center - e.value (a.value (fun i => q i))| ≤
          (e.diff.bound : ℝ) * |(u.center : ℝ) - a.value (fun i => q i)| :=
        e.lipschitz.dist_le_mul _ _
      have he : |e.value u.center - e.value (a.value (fun i => q i))| ≤
          (e.diff.bound : ℝ) * (u.radius : ℝ) :=
        hd.trans (mul_le_mul_of_nonneg_left hu
          (by exact_mod_cast e.diff.bound_nonneg))
      exact (abs_sub_le _ _ _).trans (by simpa using add_le_add hv he)
    · change v.radius + e.diff.bound * u.radius ≤ ε
      have hmul := (le_div_iff₀ hL).mp hu'
      have hu0 := hu.radius_nonneg
      have hL0 := e.diff.bound_nonneg
      nlinarith

lemma evalAt_dom (a : Formula d) (q : Fin d → ℚ) (ε : ℚ) (hε : 0 < ε) :
    (a.evalAt q ε).Dom := by
  induction a generalizing ε with
  | const c => trivial
  | var i => trivial
  | add a b ha hb => exact ⟨ha _ (by positivity), hb _ (by positivity), trivial⟩
  | mul a b ha hb =>
    have hpos : 0 < min 1 (ε / (4 * (a.bound (1 + ∑ i, |q i|) +
        b.bound (1 + ∑ i, |q i|) + 2))) := by
      apply lt_min (by norm_num)
      apply div_pos hε
      have := a.bound_nonneg (1 + ∑ i, |q i|)
      have := b.bound_nonneg (1 + ∑ i, |q i|)
      positivity
    exact ⟨ha _ hpos, hb _ hpos, trivial⟩
  | profile e a ha =>
    have hp : 0 < ε / (2 * (e.diff.bound + 1)) := by
      apply div_pos hε
      have := e.diff.bound_nonneg
      positivity
    refine ⟨ha _ hp, ?_⟩
    exact ⟨e.approx_dom _ _ (by positivity), trivial⟩

end Formula
end RapidForcing.EffectiveProfile

end

end OAI