lean/OAI/Analysis/BoxTransport/Computation.lean

import Mathlib
import OAI.Analysis.BoxTransport.Definitions

namespace OAI

/-! Computable rational arithmetic and exponential/flat-function approximation. -/

noncomputable section
open scoped Topology
open scoped BigOperators ContDiff

open scoped BigOperators ContDiff

namespace BoxTransport.Routing.Computation

abbrev QCode := ℕ × ℕ × ℕ

def Qval (q : QCode) : ℚ := ((q.1 : ℚ) - q.2.1) / (q.2.2 + 1)

def qZero : QCode := (0, 0, 0)
def qOne : QCode := (1, 0, 0)
def qNat (n : ℕ) : QCode := (n, 0, 0)
def qNeg (q : QCode) : QCode := (q.2.1, q.1, q.2.2)
def qAdd (q r : QCode) : QCode :=
  (q.1 * (r.2.2 + 1) + r.1 * (q.2.2 + 1),
   q.2.1 * (r.2.2 + 1) + r.2.1 * (q.2.2 + 1),
   (q.2.2 + 1) * (r.2.2 + 1) - 1)
def qMul (q r : QCode) : QCode :=
  (q.1 * r.1 + q.2.1 * r.2.1, q.1 * r.2.1 + q.2.1 * r.1,
   (q.2.2 + 1) * (r.2.2 + 1) - 1)
def qInv (q : QCode) : QCode :=
  if q.2.1 < q.1 then (q.2.2 + 1, 0, q.1 - q.2.1 - 1)
  else if q.1 < q.2.1 then (0, q.2.2 + 1, q.2.1 - q.1 - 1)
  else qZero

def qSub (q r : QCode) : QCode := qAdd q (qNeg r)
def qDiv (q r : QCode) : QCode := qMul q (qInv r)
def qPow (q : QCode) (n : ℕ) : QCode := (qMul q)^[n] qOne

def qLe (q r : QCode) : Prop :=
  q.1 * (r.2.2 + 1) + r.2.1 * (q.2.2 + 1) ≤
    r.1 * (q.2.2 + 1) + q.2.1 * (r.2.2 + 1)
instance : DecidableRel qLe := fun _ _ => Nat.decLe _ _

@[simp] theorem Qval_zero : Qval qZero = 0 := by norm_num [Qval, qZero]
@[simp] theorem Qval_one : Qval qOne = 1 := by norm_num [Qval, qOne]
@[simp] theorem Qval_nat (n : ℕ) : Qval (qNat n) = n := by simp [Qval, qNat]
@[simp] theorem Qval_neg (q : QCode) : Qval (qNeg q) = -Qval q := by
  dsimp [Qval, qNeg]
  ring

theorem denominator_product (d e : ℕ) :
    (((d + 1) * (e + 1) - 1 : ℕ) : ℚ) + 1 = (d + 1) * (e + 1) := by
  have h : 1 ≤ (d + 1) * (e + 1) := by nlinarith
  rw [Nat.cast_sub h]
  push_cast
  ring

@[simp] theorem Qval_add (q r : QCode) : Qval (qAdd q r) = Qval q + Qval r := by
  simp only [Qval, qAdd, Nat.cast_add, Nat.cast_mul, Nat.cast_one, denominator_product]
  field_simp
  ring

@[simp] theorem Qval_mul (q r : QCode) : Qval (qMul q r) = Qval q * Qval r := by
  simp only [Qval, qMul, Nat.cast_add, Nat.cast_mul, denominator_product]
  rw [div_mul_div_comm]
  congr 1
  ring

@[simp] theorem Qval_inv (q : QCode) : Qval (qInv q) = (Qval q)⁻¹ := by
  unfold qInv
  split_ifs with h h'
  · have hd : 1 ≤ q.1 - q.2.1 := by omega
    have he : ((((q.1 - q.2.1) - 1 : ℕ) : ℚ) + 1) = (q.1 : ℚ) - q.2.1 := by
      rw [Nat.cast_sub hd, Nat.cast_sub (by omega : q.2.1 ≤ q.1)]
      norm_num
    simp only [Qval, Nat.cast_add, Nat.cast_one, Nat.cast_zero, sub_zero, he, inv_div]
  · have hd : 1 ≤ q.2.1 - q.1 := by omega
    have he : ((((q.2.1 - q.1) - 1 : ℕ) : ℚ) + 1) = (q.2.1 : ℚ) - q.1 := by
      rw [Nat.cast_sub hd, Nat.cast_sub (by omega : q.1 ≤ q.2.1)]
      norm_num
    simp only [Qval, Nat.cast_add, Nat.cast_one, Nat.cast_zero, zero_sub, he, inv_div]
    rw [← neg_sub (q.1 : ℚ) q.2.1, div_neg, neg_div, neg_neg]
  · have he : q.1 = q.2.1 := by omega
    simp [Qval, qZero, he]

@[simp] theorem Qval_sub (q r : QCode) : Qval (qSub q r) = Qval q - Qval r := by
  simp [qSub, sub_eq_add_neg]
@[simp] theorem Qval_div (q r : QCode) : Qval (qDiv q r) = Qval q / Qval r := by
  simp [qDiv, div_eq_mul_inv]
@[simp] theorem Qval_pow (q : QCode) (n : ℕ) : Qval (qPow q n) = Qval q ^ n := by
  induction n with
  | zero => simp [qPow]
  | succ n ih =>
    simp only [qPow, Function.iterate_succ_apply', Qval_mul]
    rw [← qPow, ih, pow_succ']

theorem qLe_iff (q r : QCode) : qLe q r ↔ Qval q ≤ Qval r := by
  rw [Qval, Qval, div_le_div_iff₀ (by positivity) (by positivity)]
  rw [qLe]
  have :
      q.1 * (r.2.2 + 1) + r.2.1 * (q.2.2 + 1) ≤
        r.1 * (q.2.2 + 1) + q.2.1 * (r.2.2 + 1) ↔
      (q.1 : ℚ) * (r.2.2 + 1) + r.2.1 * (q.2.2 + 1) ≤
        r.1 * (q.2.2 + 1) + q.2.1 * (r.2.2 + 1) := by norm_cast
  rw [this]
  constructor <;> intro h <;> nlinarith

theorem Qval_surjective : Function.Surjective Qval := by
  intro q
  let p := q.num.toNat
  let n := (-q.num).toNat
  have hpn : q.num = (p : ℤ) - n := (Int.toNat_sub_toNat_neg q.num).symm
  refine ⟨(p, n, q.den - 1), ?_⟩
  have hd : 1 ≤ q.den := q.pos
  have he : ((q.den - 1 : ℕ) : ℚ) + 1 = q.den := by
    rw [Nat.cast_sub hd]
    norm_num
  rw [Qval, he, ← Int.cast_natCast p, ← Int.cast_natCast n, ← Int.cast_sub, ← hpn]
  exact Rat.num_div_den q

private theorem pr_plus {α} [Primcodable α] {f g : α → ℕ}
    (hf : Primrec f) (hg : Primrec g) : Primrec fun a => f a + g a :=
  Primrec.nat_add.comp hf hg
private theorem pr_times {α} [Primcodable α] {f g : α → ℕ}
    (hf : Primrec f) (hg : Primrec g) : Primrec fun a => f a * g a :=
  Primrec.nat_mul.comp hf hg

 theorem primrec_qNat : Primrec qNat := (Primrec.id.pair ((Primrec.const 0).pair (.const 0)))
 theorem primrec_qNeg : Primrec qNeg :=
  (Primrec.fst.comp Primrec.snd).pair (Primrec.fst.pair (Primrec.snd.comp Primrec.snd))
 theorem primrec_qAdd : Primrec₂ qAdd := by
  unfold qAdd
  apply Primrec.pair
  · exact pr_plus
      (pr_times (Primrec.fst.comp Primrec.fst)
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))))
      (pr_times (Primrec.fst.comp Primrec.snd)
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst))))
  apply Primrec.pair
  · exact pr_plus
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.fst))
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))))
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.snd))
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst))))
  exact Primrec.nat_sub.comp
    (pr_times (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst)))
      (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))) (Primrec.const 1)

 theorem primrec_qMul : Primrec₂ qMul := by
  unfold qMul
  apply Primrec.pair
  · exact pr_plus (pr_times (Primrec.fst.comp Primrec.fst) (Primrec.fst.comp Primrec.snd))
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.fst))
        (Primrec.fst.comp (Primrec.snd.comp Primrec.snd)))
  apply Primrec.pair
  · exact pr_plus
      (pr_times (Primrec.fst.comp Primrec.fst) (Primrec.fst.comp (Primrec.snd.comp Primrec.snd)))
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.fst)) (Primrec.fst.comp Primrec.snd))
  exact Primrec.nat_sub.comp
    (pr_times (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst)))
      (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))) (Primrec.const 1)

 theorem primrec_qInv : Primrec qInv := by
  unfold qInv
  apply Primrec.ite (Primrec.nat_lt.comp (Primrec.fst.comp Primrec.snd) Primrec.fst)
  · apply Primrec.pair
    · exact Primrec.succ.comp (Primrec.snd.comp Primrec.snd)
    apply Primrec.pair (Primrec.const 0)
    exact Primrec.nat_sub.comp
      (Primrec.nat_sub.comp Primrec.fst (Primrec.fst.comp Primrec.snd)) (Primrec.const 1)
  apply Primrec.ite (Primrec.nat_lt.comp Primrec.fst (Primrec.fst.comp Primrec.snd))
  · apply Primrec.pair (Primrec.const 0)
    apply Primrec.pair (Primrec.succ.comp (Primrec.snd.comp Primrec.snd))
    exact Primrec.nat_sub.comp
      (Primrec.nat_sub.comp (Primrec.fst.comp Primrec.snd) Primrec.fst) (Primrec.const 1)
  exact Primrec.const qZero

 theorem primrec_qSub : Primrec₂ qSub :=
  primrec_qAdd.comp Primrec.fst (primrec_qNeg.comp Primrec.snd)
 theorem primrec_qDiv : Primrec₂ qDiv :=
  primrec_qMul.comp Primrec.fst (primrec_qInv.comp Primrec.snd)
 theorem primrec_qPow : Primrec₂ qPow := by
  exact Primrec.nat_iterate Primrec.snd (Primrec.const qOne)
    (primrec_qMul.comp (Primrec.fst.comp Primrec.fst) Primrec.snd)

 theorem primrec_qLe : PrimrecRel qLe := by
  exact Primrec.nat_le.comp
    (pr_plus
      (pr_times (Primrec.fst.comp Primrec.fst)
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))))
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.snd))
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst)))))
    (pr_plus
      (pr_times (Primrec.fst.comp Primrec.snd)
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.fst))))
      (pr_times (Primrec.fst.comp (Primrec.snd.comp Primrec.fst))
        (Primrec.succ.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))))

def qAbs (q : QCode) : QCode := if qLe qZero q then q else qNeg q

@[simp] theorem Qval_abs (q : QCode) : Qval (qAbs q) = |Qval q| := by
  unfold qAbs
  split_ifs with h
  · rw [abs_of_nonneg (by simpa only [qLe_iff, Qval_zero] using h)]
  · rw [Qval_neg, abs_of_neg (lt_of_not_ge (by simpa only [qLe_iff, Qval_zero] using h))]

theorem primrec_qAbs : Primrec qAbs :=
  Primrec.ite (primrec_qLe.comp (.const qZero) .id) .id primrec_qNeg

theorem primrec_factorial : Primrec Nat.factorial := by
  have hp : Primrec (Nat.rec 1 (fun n s => (n + 1) * s)) :=
    Primrec.nat_rec₁ 1 (Primrec.nat_mul.comp (Primrec.succ.comp Primrec.fst) Primrec.snd)
  apply hp.of_eq
  intro n
  induction n with
  | zero => rfl
  | succ n ih => dsimp; rw [ih, Nat.factorial_succ]

def qTaylor (q : QCode) (n : ℕ) : QCode :=
  ((List.range n).map fun m => qDiv (qPow q m) (qNat m.factorial)).foldr qAdd qZero

@[simp] theorem Qval_taylor (q : QCode) (n : ℕ) :
    Qval (qTaylor q n) = ∑ m ∈ Finset.range n, Qval q ^ m / m.factorial := by
  have hsum (l : List QCode) : Qval (l.foldr qAdd qZero) = (l.map Qval).sum := by
    induction l with
    | nil => simp
    | cons q l ih => simp [ih]
  rw [qTaylor, hsum, List.map_map]
  simp only [Function.comp_def, Qval_div, Qval_pow, Qval_nat]
  simpa only [List.toFinset_range] using (List.sum_toFinset (fun m => Qval q ^ m / m.factorial) (List.nodup_range (n := n))).symm

theorem primrec_qTaylor : Primrec₂ qTaylor := by
  unfold Primrec₂ qTaylor
  apply Primrec.list_foldr (h := fun _ p => qAdd p.1 p.2)
  · exact Primrec.list_map (Primrec.list_range.comp Primrec.snd)
      (primrec_qDiv.comp (primrec_qPow.comp (Primrec.fst.comp Primrec.fst) Primrec.snd)
        (primrec_qNat.comp (primrec_factorial.comp Primrec.snd)))
  · exact Primrec.const qZero
  exact primrec_qAdd.comp (Primrec.fst.comp Primrec.snd) (Primrec.snd.comp Primrec.snd)

def expStop (r : QCode × ℕ) (m : ℕ) : Prop :=
  qLe (qDiv (qAbs r.1) (qNat (m + 1))) (qInv (qNat 2)) ∧
    qLe (qMul (qDiv (qPow (qAbs r.1) m) (qNat m.factorial)) (qNat 2))
      (qInv (qNat (r.2 + 1)))

instance : DecidableRel expStop := fun _ _ => inferInstanceAs (Decidable (_ ∧ _))

theorem primrec_expStop : PrimrecRel expStop := by
  apply PrimrecPred.and
  · exact primrec_qLe.comp
      (primrec_qDiv.comp (primrec_qAbs.comp (Primrec.fst.comp Primrec.fst))
        (primrec_qNat.comp (Primrec.succ.comp Primrec.snd))) (Primrec.const _)
  exact primrec_qLe.comp
    (primrec_qMul.comp
      (primrec_qDiv.comp
        (primrec_qPow.comp (primrec_qAbs.comp (Primrec.fst.comp Primrec.fst)) Primrec.snd)
        (primrec_qNat.comp (primrec_factorial.comp Primrec.snd))) (Primrec.const _))
    (primrec_qInv.comp (primrec_qNat.comp (Primrec.succ.comp (Primrec.snd.comp Primrec.fst))))

theorem expStop_iff (q : QCode) (N m : ℕ) : expStop (q, N) m ↔
    |(Qval q : ℝ)| / (m + 1) ≤ 1 / 2 ∧
    |(Qval q : ℝ)| ^ m / m.factorial * 2 ≤ ((N : ℝ) + 1)⁻¹ := by
  simp only [expStop, qLe_iff, Qval_div, Qval_abs, Qval_nat, Qval_inv,
    Qval_mul, Qval_pow]
  rw [← Rat.cast_le (K := ℝ), ← Rat.cast_le (K := ℝ)]
  push_cast
  norm_num

theorem exists_expStop (r : QCode × ℕ) : ∃ m, expStop r m := by
  let x : ℝ := Qval r.1
  have htail : Filter.Tendsto (fun m : ℕ => |x| ^ m / m.factorial * 2)
      Filter.atTop (nhds 0) := by
    simpa using (Real.summable_pow_div_factorial |x|).tendsto_atTop_zero.mul_const 2
  have hp : (0 : ℝ) < ((r.2 : ℝ) + 1)⁻¹ := by positivity
  obtain ⟨K, hK⟩ := Filter.eventually_atTop.1 (htail.eventually_lt_const hp)
  obtain ⟨M : ℕ, hM⟩ := exists_nat_gt (2 * |x|)
  refine ⟨max K M, (expStop_iff r.1 r.2 _).2 ⟨?_, (hK _ (le_max_left ..)).le⟩⟩
  rw [div_le_iff₀ (by positivity)]
  have hm : (M : ℝ) ≤ (max K M : ℕ) := by exact_mod_cast le_max_right K M
  dsimp [x] at hM
  linarith

noncomputable def qExp (r : QCode × ℕ) : QCode := qTaylor r.1 (Nat.find (exists_expStop r))

theorem computable_qExp : Computable qExp :=
  primrec_qTaylor.to_comp.comp Computable.fst (Computable.find primrec_expStop.computablePred exists_expStop)

theorem real_exp_taylor_bound (x : ℝ) (n : ℕ) (h : |x| / (n + 1) ≤ 1 / 2) :
    |Real.exp x - ∑ m ∈ Finset.range n, x ^ m / m.factorial| ≤
      |x| ^ n / n.factorial * 2 := by
  have hc := Complex.exp_bound' (x := (x : ℂ)) (n := n) (by simpa [Real.norm_eq_abs] using h)
  rw [← Complex.ofReal_exp] at hc
  have he : (∑ m ∈ Finset.range n, (x : ℂ) ^ m / (m.factorial : ℂ)) =
      ((∑ m ∈ Finset.range n, x ^ m / m.factorial : ℝ) : ℂ) := by push_cast; rfl
  rw [he, ← Complex.ofReal_sub, Complex.norm_real] at hc
  simpa [Real.norm_eq_abs] using hc

theorem qExp_error (q : QCode) (N : ℕ) :
    |Real.exp (Qval q) - (Qval (qExp (q, N)) : ℝ)| ≤ ((N : ℝ) + 1)⁻¹ := by
  have h := (expStop_iff q N (Nat.find (exists_expStop (q, N)))).1
    (Nat.find_spec (exists_expStop (q, N)))
  rw [qExp, Qval_taylor]
  push_cast
  exact (real_exp_taylor_bound _ _ h.1).trans h.2

end BoxTransport.Routing.Computation

open scoped BigOperators ContDiff
namespace BoxTransport.Routing.Computation

noncomputable def flatTerm (m : ℕ) (x : ℝ) : ℝ := x⁻¹ ^ m * expNegInvGlue x

@[simp] theorem flatTerm_zero_index : flatTerm 0 = expNegInvGlue := by
  funext x
  simp [flatTerm]

theorem flatTerm_zero {m : ℕ} {x : ℝ} (hx : x ≤ 0) : flatTerm m x = 0 := by
  simp [flatTerm, expNegInvGlue.zero_of_nonpos hx]

theorem contDiff_flatTerm (m : ℕ) : ContDiff ℝ ∞ (flatTerm m) := by
  convert! (expNegInvGlue.contDiff_polynomial_eval_inv_mul (n := ⊤) (Polynomial.X ^ m)) using 1
  ext x
  simp only [flatTerm, Polynomial.eval_pow, Polynomial.eval_X]

theorem hasDerivAt_flatTerm (m : ℕ) (x : ℝ) :
    HasDerivAt (flatTerm m) (flatTerm (m + 2) x - m * flatTerm (m + 1) x) x := by
  convert expNegInvGlue.hasDerivAt_polynomial_eval_inv_mul (Polynomial.X ^ m) x using 1
  · ext y
    simp [flatTerm]
  · cases m with
    | zero => simp [flatTerm]
    | succ m =>
      rw [Polynomial.derivative_X_pow]
      simp only [flatTerm, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X,
        Polynomial.eval_sub, Polynomial.eval_C, Nat.succ_sub_one, Nat.cast_succ]
      simp only [pow_succ]
      ring

theorem flatTerm_nonneg (m : ℕ) (x : ℝ) : 0 ≤ flatTerm m x := by
  by_cases hx : x ≤ 0
  · rw [flatTerm_zero hx]
  · unfold flatTerm
    have : 0 ≤ x⁻¹ := inv_nonneg.mpr (le_of_not_ge hx)
    exact mul_nonneg (pow_nonneg this _) (expNegInvGlue.nonneg x)

theorem flatTerm_bound (m : ℕ) (x : ℝ) : |flatTerm m x| ≤ (m.factorial : ℝ) := by
  rw [abs_of_nonneg (flatTerm_nonneg m x)]
  by_cases hx : x ≤ 0
  · rw [flatTerm_zero hx]
    positivity
  have hv : 0 ≤ x⁻¹ := le_of_lt (inv_pos.mpr (lt_of_not_ge hx))
  have hterm : x⁻¹ ^ m / (m.factorial : ℝ) ≤ Real.exp x⁻¹ := by
    apply le_trans _ (Real.sum_le_exp_of_nonneg hv (m + 1))
    exact Finset.single_le_sum (f := fun i : ℕ => x⁻¹ ^ i / (i.factorial : ℝ))
      (fun i _ => by positivity) (Finset.mem_range.mpr (Nat.lt_succ_self m))
  have hm : (0 : ℝ) < m.factorial := by exact_mod_cast Nat.factorial_pos m
  have hmul := mul_le_mul_of_nonneg_right ((div_le_iff₀ hm).mp hterm)
    (Real.exp_pos (-x⁻¹)).le
  have he : Real.exp x⁻¹ * Real.exp (-x⁻¹) = 1 := by rw [← Real.exp_add]; simp
  unfold flatTerm expNegInvGlue
  rw [ite_eq_right hx]
  nlinarith [he]

def flatLipschitzBound (m : ℕ) : ℕ := (m + 2).factorial + m * (m + 1).factorial

theorem flatTerm_lipschitz (m : ℕ) : LipschitzWith (flatLipschitzBound m) (flatTerm m) := by
  apply lipschitzWith_of_nnnorm_deriv_le ((contDiff_flatTerm m).differentiable (by simp))
  intro x
  rw [(hasDerivAt_flatTerm m x).deriv]
  apply NNReal.coe_le_coe.mp
  simp only [coe_nnnorm, Real.norm_eq_abs, flatLipschitzBound,
    Nat.cast_add, Nat.cast_mul]
  calc
    |flatTerm (m + 2) x - (m : ℝ) * flatTerm (m + 1) x| ≤
        |flatTerm (m + 2) x| + |(m : ℝ) * flatTerm (m + 1) x| := abs_sub _ _
    _ ≤ (m + 2).factorial + (m : ℝ) * (m + 1).factorial := by
      simp only [abs_mul, Nat.abs_cast]
      
      gcongr <;> exact flatTerm_bound _ _

end BoxTransport.Routing.Computation

open scoped BigOperators ContDiff
namespace BoxTransport.Routing.Computation

theorem computable_ite {α β} [Primcodable α] [Primcodable β]
    {p : α → Prop} [DecidablePred p] {f g : α → β}
    (hp : ComputablePred p) (hf : Computable f) (hg : Computable g) :
    Computable (fun a => if p a then f a else g a) := by
  simpa only [Bool.cond_decide] using Computable.cond hp.decide hf hg

def qBound (q : QCode) : ℕ := q.1 + q.2.1

theorem Qval_bound (q : QCode) : |Qval q| ≤ qBound q := by
  rw [Qval, abs_div, abs_of_pos (by positivity : (0 : ℚ) < q.2.2 + 1)]
  have h : |(q.1 : ℚ) - q.2.1| ≤ (q.1 : ℚ) + q.2.1 := by
    simpa only [Nat.abs_cast] using abs_sub (q.1 : ℚ) q.2.1
  apply le_trans (div_le_self (abs_nonneg _) (by norm_cast; omega))
  simpa [qBound] using h

theorem primrec_qBound : Primrec qBound :=
  Primrec.nat_add.comp Primrec.fst (Primrec.fst.comp Primrec.snd)

noncomputable def qFlat (r : ℕ × QCode × ℕ) : QCode :=
  if qLe r.2.1 qZero then qZero else
    let w := qPow (qInv r.2.1) r.1
    qMul w (qExp (qNeg (qInv r.2.1), (r.2.2 + 1) * (qBound w + 1)))

theorem computable_qFlat : Computable qFlat := by
  unfold qFlat
  apply computable_ite (primrec_qLe.comp (Primrec.fst.comp Primrec.snd) (.const qZero)).computablePred
  · exact .const qZero
  have hw : Primrec fun r : ℕ × QCode × ℕ => qPow (qInv r.2.1) r.1 :=
    primrec_qPow.comp (primrec_qInv.comp (Primrec.fst.comp Primrec.snd)) Primrec.fst
  exact primrec_qMul.to_comp.comp hw.to_comp (computable_qExp.comp
    ((primrec_qNeg.comp (primrec_qInv.comp (Primrec.fst.comp Primrec.snd))).pair
      (Primrec.nat_mul.comp (Primrec.succ.comp (Primrec.snd.comp Primrec.snd))
        (Primrec.succ.comp (primrec_qBound.comp hw)))).to_comp)

theorem qFlat_error (m : ℕ) (q : QCode) (N : ℕ) :
    |flatTerm m (Qval q) - (Qval (qFlat (m, q, N)) : ℝ)| ≤ ((N : ℝ) + 1)⁻¹ := by
  by_cases hq : qLe q qZero
  · rw [qFlat, ite_eq_left hq, Qval_zero, Rat.cast_zero, sub_zero,
      flatTerm_zero (by exact_mod_cast (show Qval q ≤ 0 from by simpa using (qLe_iff q qZero).1 hq)), abs_zero]
    positivity
  have hp : (0 : ℝ) < Qval q := by
    exact_mod_cast lt_of_not_ge (by simpa only [qLe_iff, Qval_zero] using hq)
  let w := qPow (qInv q) m
  let B := qBound w
  have hB : |(Qval w : ℝ)| ≤ (B : ℝ) := by exact_mod_cast Qval_bound w
  have hw : (Qval w : ℝ) = (Qval q : ℝ)⁻¹ ^ m := by simp [w]
  have hx : (Qval (qNeg (qInv q)) : ℝ) = -(Qval q : ℝ)⁻¹ := by simp
  have he := qExp_error (qNeg (qInv q)) ((N + 1) * (B + 1))
  rw [hx] at he
  rw [qFlat, ite_eq_right hq]
  change |flatTerm m (Qval q) - (Qval (qMul w
    (qExp (qNeg (qInv q), (N + 1) * (B + 1)))) : ℝ)| ≤ _
  rw [Qval_mul, Rat.cast_mul]
  have ht : flatTerm m (Qval q) = (Qval w : ℝ) * Real.exp (-(Qval q : ℝ)⁻¹) := by
    simp only [flatTerm, expNegInvGlue, not_le.mpr hp, ↓reduceIte, hw]
  rw [ht, ← mul_sub, abs_mul]
  apply le_trans (mul_le_mul hB he (abs_nonneg _) (Nat.cast_nonneg B))
  push_cast
  rw [← div_eq_mul_inv, div_le_iff₀ (by positivity)]
  have hn : (0 : ℝ) < N + 1 := by positivity
  apply (mul_le_mul_iff_right₀ hn).mp
  field_simp
  nlinarith

end BoxTransport.Routing.Computation

end

end OAI