| import Mathlib |
| import OAI.Analysis.BoxTransport.Computation |
|
|
| namespace OAI |
|
|
| /-! Smooth expression calculus and effective mixed derivatives. -/ |
|
|
| noncomputable section |
| open scoped Topology |
| open scoped BigOperators ContDiff |
|
|
| open scoped BigOperators ContDiff |
| open Nat.Partrec (Code) |
| namespace BoxTransport.Routing.Computation |
|
|
| abbrev Expr := Code |
|
|
| def node (m : ℕ) (e : Expr) : Expr := .prec (Denumerable.ofNat Expr m) e |
|
|
| def cst (q : QCode) : Expr := node (3 * Encodable.encode q) .zero |
|
|
| def invE (b : ℕ) (e : Expr) : Expr := node (3 * b + 1) e |
|
|
| def flatE (m : ℕ) (e : Expr) : Expr := node (3 * m + 2) e |
|
|
| def varE : Axis → Expr |
| | none => .zero |
| | some j => if j = 0 then .succ else if j = 1 then .left else .right |
|
|
| noncomputable def unaryValue (m : ℕ) (x : ℝ) : ℝ := |
| if m % 3 = 0 then Qval (Denumerable.ofNat QCode (m / 3)) |
| else if m % 3 = 1 then x⁻¹ else flatTerm (m / 3) x |
|
|
| noncomputable def value : Expr → SpaceTime → ℝ |
| | .zero, p => p.1 |
| | .succ, p => p.2 0 |
| | .left, p => p.2 1 |
| | .right, p => p.2 2 |
| | .pair e f, p => value e p + value f p |
| | .comp e f, p => value e p * value f p |
| | .prec m e, p => unaryValue (Encodable.encode m) (value e p) |
| | .rfind' e, p => -value e p |
|
|
| def Valid : Expr → Prop |
| | .zero | .succ | .left | .right => True |
| | .pair e f | .comp e f => Valid e ∧ Valid f |
| | .prec m e => Valid e ∧ (Encodable.encode m % 3 = 1 → |
| ∀ p, ((Encodable.encode m / 3 : ℕ) + 1 : ℝ)⁻¹ ≤ |value e p|) |
| | .rfind' e => Valid e |
|
|
| @[simp] theorem value_node (m : ℕ) (e : Expr) (p : SpaceTime) : |
| value (node m e) p = unaryValue m (value e p) := by simp [value, node] |
| @[simp] theorem value_cst (q : QCode) (p : SpaceTime) : value (cst q) p = (Qval q : ℝ) := by |
| rw [cst, value_node] |
| rw [unaryValue, ite_eq_left (by omega), Nat.mul_div_right _ (by omega), Denumerable.ofNat_encode] |
| @[simp] theorem value_invE (b : ℕ) (e : Expr) (p : SpaceTime) : value (invE b e) p = (value e p)⁻¹ := by |
| simp [invE, unaryValue] |
| @[simp] theorem value_flatE (m : ℕ) (e : Expr) (p : SpaceTime) : value (flatE m e) p = flatTerm m (value e p) := by |
| simp [flatE, unaryValue, Nat.mul_add_div (by omega : 0 < 3)] |
| @[simp] theorem valid_node (m : ℕ) (e : Expr) : Valid (node m e) ↔ |
| Valid e ∧ (m % 3 = 1 → ∀ p, ((m / 3 : ℕ) + 1 : ℝ)⁻¹ ≤ |value e p|) := by |
| simp [Valid, node] |
| @[simp] theorem valid_cst (q : QCode) : Valid (cst q) := by simp [cst, Valid] |
| @[simp] theorem valid_flatE (m : ℕ) (e : Expr) : Valid (flatE m e) ↔ Valid e := by |
| simp [flatE] |
| @[simp] theorem valid_invE (b : ℕ) (e : Expr) : Valid (invE b e) ↔ |
| Valid e ∧ ∀ p, ((b : ℝ) + 1)⁻¹ ≤ |value e p| := by simp [invE, Nat.mul_add_div (by omega : 0 < 3)] |
|
|
| @[simp] theorem value_varE (j : Axis) (p : SpaceTime) : |
| value (varE j) p = match j with | none => p.1 | some i => p.2 i := by |
| cases j with |
| | none => rfl |
| | some i => fin_cases i <;> simp [varE, value] |
| @[simp] theorem valid_varE (j : Axis) : Valid (varE j) := by |
| cases j with |
| | none => trivial |
| | some i => fin_cases i <;> simp [varE, Valid] |
|
|
| theorem nonzero_of_inverse_bound {b : ℕ} {x : ℝ} (h : ((b : ℝ) + 1)⁻¹ ≤ |x|) : x ≠ 0 := by |
| have hp : (0 : ℝ) < ((b : ℝ) + 1)⁻¹ := by positivity |
| exact abs_pos.mp (hp.trans_le h) |
|
|
| theorem smooth_value {e : Expr} (he : Valid e) : ContDiff ℝ ∞ (value e) := by |
| induction e with |
| | zero => exact contDiff_fst |
| | succ => exact (contDiff_apply ℝ ℝ (0 : Fin 3)).comp contDiff_snd |
| | left => exact (contDiff_apply ℝ ℝ (1 : Fin 3)).comp contDiff_snd |
| | right => exact (contDiff_apply ℝ ℝ (2 : Fin 3)).comp contDiff_snd |
| | pair e f ih₁ ih₂ => exact (ih₁ he.1).add (ih₂ he.2) |
| | comp e f ih₁ ih₂ => exact (ih₁ he.1).mul (ih₂ he.2) |
| | rfind' e ih => exact (ih he).neg |
| | prec m e _ ih => |
| change ContDiff ℝ ∞ (fun p => unaryValue (Encodable.encode m) (value e p)) |
| unfold unaryValue |
| split_ifs with h₀ h₁ |
| · exact contDiff_const |
| · exact (ih he.1).inv (fun p => nonzero_of_inverse_bound (he.2 h₁ p)) |
| · exact (contDiff_flatTerm _).comp (ih he.1) |
|
|
| def diffUnary (n : ℕ) (e de : Expr) : Expr := |
| if n % 3 = 0 then cst qZero |
| else if n % 3 = 1 then .rfind' (.comp (.comp (invE (n / 3) e) (invE (n / 3) e)) de) |
| else .comp (.pair (flatE (n / 3 + 2) e) |
| (.rfind' (.comp (cst (qNat (n / 3))) (flatE (n / 3 + 1) e)))) de |
|
|
| def diff (j : Axis) : Expr → Expr |
| | .zero => cst (if j = none then qOne else qZero) |
| | .succ => cst (if j = some 0 then qOne else qZero) |
| | .left => cst (if j = some 1 then qOne else qZero) |
| | .right => cst (if j = some 2 then qOne else qZero) |
| | .pair e f => .pair (diff j e) (diff j f) |
| | .comp e f => .pair (.comp (diff j e) f) (.comp e (diff j f)) |
| | .prec m e => diffUnary (Encodable.encode m) e (diff j e) |
| | .rfind' e => .rfind' (diff j e) |
|
|
| theorem valid_diff {e : Expr} (he : Valid e) (j : Axis) : Valid (diff j e) := by |
| induction e with |
| | zero | succ | left | right => exact valid_cst _ |
| | pair e f ih₁ ih₂ => exact ⟨ih₁ he.1, ih₂ he.2⟩ |
| | comp e f ih₁ ih₂ => exact ⟨⟨ih₁ he.1, he.2⟩, he.1, ih₂ he.2⟩ |
| | rfind' e ih => exact ih he |
| | prec m e _ ih => |
| dsimp [diff, diffUnary] |
| split_ifs with h₀ h₁ |
| · exact valid_cst _ |
| · have hi : Valid (invE (Encodable.encode m / 3) e) := (valid_invE _ _).2 ⟨he.1, he.2 h₁⟩ |
| exact ⟨⟨hi, hi⟩, ih he.1⟩ |
| · exact ⟨⟨(valid_flatE _ _).2 he.1, valid_cst _, (valid_flatE _ _).2 he.1⟩, ih he.1⟩ |
|
|
| theorem value_diff {e : Expr} (he : Valid e) (j : Axis) (p : SpaceTime) : |
| value (diff j e) p = fderiv ℝ (value e) p (coordinateDirection j) := by |
| induction e with |
| | zero => |
| cases j with |
| | none => simp [diff, value, coordinateDirection, fderiv_fst] |
| | some i => simp [diff, value, coordinateDirection, fderiv_fst] |
| | succ => |
| have hd : fderiv ℝ (value Code.succ) p = |
| (ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 0).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space) := |
| ((ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 0).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space)).hasFDerivAt.fderiv |
| rw [hd] |
| cases j with |
| | none => simp [diff, coordinateDirection] |
| | some i => fin_cases i <;> simp [diff, coordinateDirection, coordinateVector] |
| | left => |
| have hd : fderiv ℝ (value Code.left) p = |
| (ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 1).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space) := |
| ((ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 1).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space)).hasFDerivAt.fderiv |
| rw [hd] |
| cases j with |
| | none => simp [diff, coordinateDirection] |
| | some i => fin_cases i <;> simp [diff, coordinateDirection, coordinateVector] |
| | right => |
| have hd : fderiv ℝ (value Code.right) p = |
| (ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 2).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space) := |
| ((ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin 3 => ℝ) 2).comp |
| (ContinuousLinearMap.snd ℝ ℝ Space)).hasFDerivAt.fderiv |
| rw [hd] |
| cases j with |
| | none => simp [diff, coordinateDirection] |
| | some i => fin_cases i <;> simp [diff, coordinateDirection, coordinateVector] |
| | pair e f ih₁ ih₂ => |
| have he' := (smooth_value he.1).differentiable (by simp) |
| have hf' := (smooth_value he.2).differentiable (by simp) |
| rw [diff, value, ih₁ he.1, ih₂ he.2] |
| exact (congrArg (fun L : SpaceTime →L[ℝ] ℝ => L (coordinateDirection j)) |
| ((he' p).hasFDerivAt.add (hf' p).hasFDerivAt).fderiv).symm |
| | comp e f ih₁ ih₂ => |
| have he' := (smooth_value he.1).differentiable (by simp) |
| have hf' := (smooth_value he.2).differentiable (by simp) |
| simp only [diff, value, ih₁ he.1, ih₂ he.2] |
| have hd := ((he' p).hasFDerivAt.mul (hf' p).hasFDerivAt).fderiv |
| change fderiv ℝ (fun p => value e p * value f p) p = _ at hd |
| rw [hd] |
| simp only [add_apply, smul_apply, smul_eq_mul] |
| ring |
| | rfind' e ih => |
| have he' := (smooth_value (e := e) he).differentiable (by simp) |
| simp only [diff, value, ih he] |
| have hd := (he' p).hasFDerivAt.neg.fderiv |
| change fderiv ℝ (fun p => -value e p) p = _ at hd |
| rw [hd] |
| rfl |
| | prec m e _ ih => |
| have he' := (smooth_value he.1).differentiable (by simp) |
| change value (diffUnary (Encodable.encode m) e (diff j e)) p = |
| fderiv ℝ (fun p => unaryValue (Encodable.encode m) (value e p)) p _ |
| unfold diffUnary unaryValue |
| split_ifs with h₀ h₁ |
| · simp |
| · have hn := nonzero_of_inverse_bound (he.2 h₁ p) |
| simp only [value, value_invE, ih he.1] |
| have hd := ((hasDerivAt_inv hn).comp_hasFDerivAt p (he' p).hasFDerivAt).fderiv |
| change fderiv ℝ (fun p => (value e p)⁻¹) p = _ at hd |
| rw [hd] |
| simp [pow_two, mul_assoc] |
| · simp only [value, value_cst, Qval_nat, Rat.cast_natCast, value_flatE, ih he.1] |
| have hd := ((hasDerivAt_flatTerm (Encodable.encode m / 3) (value e p)).comp_hasFDerivAt p (he' p).hasFDerivAt).fderiv |
| change fderiv ℝ (fun p => flatTerm (Encodable.encode m / 3) (value e p)) p = _ at hd |
| rw [hd] |
| simp only [smul_apply, smul_eq_mul] |
| ring |
|
|
| end BoxTransport.Routing.Computation |
|
|
| open scoped BigOperators ContDiff |
| open Nat.Partrec (Code) |
| namespace BoxTransport.Routing.Computation |
|
|
| def qGuardInv (b : ℕ) (q : QCode) : QCode := |
| if qLe (qInv (qNat (2 * (b + 1)))) (qAbs q) then qInv q else qZero |
|
|
| theorem qGuardInv_error (b : ℕ) (q : QCode) {x : ℝ} |
| (hx : ((b : ℝ) + 1)⁻¹ ≤ |x|) : |
| |x⁻¹ - (Qval (qGuardInv b q) : ℝ)| ≤ 2 * ((b : ℝ) + 1) ^ 2 * |x - (Qval q : ℝ)| := by |
| let D : ℝ := (b : ℝ) + 1 |
| have hD : 0 < D := by dsimp [D]; positivity |
| have hx0 := nonzero_of_inverse_bound hx |
| have hxmul : 1 ≤ |x| * D := (inv_le_iff_one_le_mul₀ hD).mp hx |
| have hinvx : |x⁻¹| ≤ D := by |
| rw [abs_inv, inv_le_iff_one_le_mul₀ (abs_pos.mpr hx0)] |
| nlinarith |
| unfold qGuardInv |
| split_ifs with hq |
| · have hq' : (2 * D)⁻¹ ≤ |(Qval q : ℝ)| := by |
| have h := (qLe_iff _ _).1 hq |
| simp only [Qval_inv, Qval_nat, Qval_abs] at h |
| have hc := (Rat.cast_le (K := ℝ)).2 h |
| simpa [D] using hc |
| have hq0 : (Qval q : ℝ) ≠ 0 := abs_pos.mp ((by positivity : (0 : ℝ) < (2 * D)⁻¹).trans_le hq') |
| have hinvq : |(Qval q : ℝ)⁻¹| ≤ 2 * D := by |
| rw [abs_inv, inv_le_iff_one_le_mul₀ (abs_pos.mpr hq0)] |
| have h := (inv_le_iff_one_le_mul₀ (by positivity : 0 < 2 * D)).mp hq' |
| nlinarith |
| simp only [Qval_inv, Rat.cast_inv] |
| have hi : x⁻¹ - (Qval q : ℝ)⁻¹ = x⁻¹ * (Qval q : ℝ)⁻¹ * ((Qval q : ℝ) - x) := by |
| field_simp |
| rw [hi, abs_mul, abs_mul, abs_sub_comm (Qval q : ℝ) x] |
| calc |
| |x⁻¹| * |(Qval q : ℝ)⁻¹| * |x - (Qval q : ℝ)| ≤ D * (2 * D) * |x - (Qval q : ℝ)| := by |
| gcongr |
| _ = _ := by dsimp [D]; ring |
| · have hq' : |(Qval q : ℝ)| < (2 * D)⁻¹ := by |
| have h := lt_of_not_ge ((qLe_iff _ _).not.mp hq) |
| simp only [Qval_inv, Qval_nat, Qval_abs] at h |
| have hc := (Rat.cast_lt (K := ℝ)).2 h |
| simpa [D] using hc |
| have hdist : (2 * D)⁻¹ ≤ |x - (Qval q : ℝ)| := by |
| have ht := abs_add_le (x - (Qval q : ℝ)) (Qval q : ℝ) |
| have hid : (2 * D)⁻¹ + (2 * D)⁻¹ = D⁻¹ := by field_simp; ring |
| dsimp [D] at hx ⊢ hq' hid |
| rw [sub_add_cancel] at ht |
| linarith |
| simp only [Qval_zero, Rat.cast_zero, sub_zero] |
| have hmul := mul_le_mul_of_nonneg_left hdist (by positivity : 0 ≤ 2 * D ^ 2) |
| have hid : 2 * D ^ 2 * (2 * D)⁻¹ = D := by field_simp |
| rw [hid] at hmul |
| exact hinvx.trans hmul |
|
|
| def unaryBound (m : ℕ) (_radius : ℕ) : ℕ := |
| if m % 3 = 0 then qBound (Denumerable.ofNat QCode (m / 3)) |
| else if m % 3 = 1 then m / 3 + 1 else (m / 3).factorial |
|
|
| def boundE (R : ℕ) : Expr → ℕ |
| | .zero | .succ | .left | .right => R |
| | .pair e f => boundE R e + boundE R f |
| | .comp e f => boundE R e * boundE R f |
| | .prec m _ => unaryBound (Encodable.encode m) R |
| | .rfind' e => boundE R e |
|
|
| def unaryAmp (m A : ℕ) : ℕ := |
| if m % 3 = 0 then 0 |
| else if m % 3 = 1 then 2 * (m / 3 + 1) ^ 2 * A |
| else flatLipschitzBound (m / 3) * A + 1 |
|
|
| def ampE (R : ℕ) : Expr → ℕ |
| | .zero | .succ | .left | .right => 0 |
| | .pair e f => ampE R e + ampE R f |
| | .comp e f => (boundE R e + ampE R e) * ampE R f + boundE R f * ampE R e |
| | .prec m e => unaryAmp (Encodable.encode m) (ampE R e) |
| | .rfind' e => ampE R e |
|
|
| theorem coord_le_norm (j : Axis) (p : SpaceTime) : |
| |value (varE j) p| ≤ ‖p‖ := by |
| cases j with |
| | none => exact norm_fst_le p |
| | some j => |
| simpa using (norm_le_pi_norm p.2 j).trans (norm_snd_le p) |
|
|
| theorem value_bound {e : Expr} (he : Valid e) (R : ℕ) {p : SpaceTime} (hp : ‖p‖ ≤ R) : |
| |value e p| ≤ boundE R e := by |
| induction e with |
| | zero => exact (coord_le_norm none p).trans hp |
| | succ => exact (coord_le_norm (some 0) p).trans hp |
| | left => exact (coord_le_norm (some 1) p).trans hp |
| | right => exact (coord_le_norm (some 2) p).trans hp |
| | pair e f ih₁ ih₂ => |
| exact (abs_add_le _ _).trans (by exact_mod_cast add_le_add (ih₁ he.1) (ih₂ he.2)) |
| | comp e f ih₁ ih₂ => |
| simpa only [value, boundE, Nat.cast_mul, abs_mul] using |
| mul_le_mul (ih₁ he.1) (ih₂ he.2) (abs_nonneg _) (Nat.cast_nonneg _) |
| | rfind' e ih => simpa only [value, abs_neg, boundE] using ih he |
| | prec m e _ ih => |
| simp only [value, unaryValue, boundE, unaryBound] |
| split_ifs with h₀ h₁ |
| · exact_mod_cast Qval_bound (Denumerable.ofNat QCode (Encodable.encode m / 3)) |
| · have hb := he.2 h₁ p |
| have hne := nonzero_of_inverse_bound hb |
| rw [abs_inv, inv_le_iff_one_le_mul₀ (abs_pos.mpr hne)] |
| have h := (inv_le_iff_one_le_mul₀ (by positivity : 0 < ((Encodable.encode m / 3 : ℕ) : ℝ) + 1)).mp hb |
| push_cast |
| nlinarith |
| · exact flatTerm_bound _ _ |
|
|
| noncomputable def unaryEval (m : ℕ) (q : QCode) (N : ℕ) : QCode := |
| if m % 3 = 0 then Denumerable.ofNat QCode (m / 3) |
| else if m % 3 = 1 then qGuardInv (m / 3) q else qFlat (m / 3, q, N) |
|
|
| noncomputable def evalE (q : RationalPointCode) (N : ℕ) : Expr → QCode |
| | .zero => q.1 |
| | .succ => q.2.1 |
| | .left => q.2.2.1 |
| | .right => q.2.2.2 |
| | .pair e f => qAdd (evalE q N e) (evalE q N f) |
| | .comp e f => qMul (evalE q N e) (evalE q N f) |
| | .prec m e => unaryEval (Encodable.encode m) (evalE q N e) N |
| | .rfind' e => qNeg (evalE q N e) |
|
|
| theorem mul_approx {x y a b ε B C A D : ℝ} |
| (_hε : 0 ≤ ε) (hε₁ : ε ≤ 1) (hA : 0 ≤ A) (_hD : 0 ≤ D) |
| (hx : |x| ≤ B) (hy : |y| ≤ C) (ha : |x - a| ≤ A * ε) (hb : |y - b| ≤ D * ε) : |
| |x * y - a * b| ≤ ((B + A) * D + C * A) * ε := by |
| have haa : |a| ≤ B + A := by |
| calc |
| |a| = |(a - x) + x| := by rw [sub_add_cancel] |
| _ ≤ |a - x| + |x| := abs_add_le _ _ |
| _ ≤ A * ε + B := by rw [abs_sub_comm]; gcongr |
| _ ≤ B + A := by nlinarith |
| have hid : x * y - a * b = a * (y - b) + y * (x - a) := by ring |
| rw [hid] |
| apply (abs_add_le _ _).trans |
| rw [abs_mul, abs_mul] |
| have hBn : 0 ≤ B + A := (abs_nonneg a).trans haa |
| have hCn : 0 ≤ C := (abs_nonneg y).trans hy |
| calc |
| |a| * |y - b| + |y| * |x - a| ≤ (B + A) * (D * ε) + C * (A * ε) := by |
| gcongr |
| _ = _ := by ring |
|
|
| theorem evalE_error {e : Expr} (he : Valid e) (q : RationalPointCode) (N R : ℕ) |
| (hR : ‖codeSpaceTime q‖ ≤ R) : |
| |value e (codeSpaceTime q) - (Qval (evalE q N e) : ℝ)| ≤ |
| (ampE R e : ℝ) * ((N : ℝ) + 1)⁻¹ := by |
| have hε : (0 : ℝ) ≤ ((N : ℝ) + 1)⁻¹ := by positivity |
| have hε₁ : ((N : ℝ) + 1)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ (by have := Nat.cast_nonneg (α := ℝ) N; linarith) |
| induction e with |
| | zero => simp [value, evalE, codeSpaceTime, ampE, Qval, rationalValue] |
| | succ => simp [value, evalE, codeSpaceTime, ampE, Qval, rationalValue] |
| | left => simp [value, evalE, codeSpaceTime, ampE, Qval, rationalValue] |
| | right => simp [value, evalE, codeSpaceTime, ampE, Qval, rationalValue] |
| | pair e f ih₁ ih₂ => |
| simp only [value, evalE, Qval_add, Rat.cast_add, ampE, Nat.cast_add] |
| have hee := ih₁ he.1 |
| have hff := ih₂ he.2 |
| have hid : value e (codeSpaceTime q) + value f (codeSpaceTime q) - |
| ((Qval (evalE q N e) : ℝ) + (Qval (evalE q N f) : ℝ)) = |
| (value e (codeSpaceTime q) - (Qval (evalE q N e) : ℝ)) + |
| (value f (codeSpaceTime q) - (Qval (evalE q N f) : ℝ)) := by ring |
| rw [hid, add_mul] |
| exact (abs_add_le _ _).trans (add_le_add hee hff) |
| | comp e f ih₁ ih₂ => |
| simp only [value, evalE, Qval_mul, Rat.cast_mul, ampE, Nat.cast_add, Nat.cast_mul] |
| exact mul_approx hε hε₁ (Nat.cast_nonneg _) (Nat.cast_nonneg _) |
| (value_bound he.1 R hR) (value_bound he.2 R hR) (ih₁ he.1) (ih₂ he.2) |
| | rfind' e ih => simpa only [value, evalE, Qval_neg, Rat.cast_neg, neg_sub_neg, abs_sub_comm, ampE] using ih he |
| | prec m e _ ih => |
| have hchild := ih he.1 |
| simp only [value, evalE, unaryValue, unaryEval, ampE, unaryAmp] |
| split_ifs with h₀ h₁ |
| · simp |
| · have hg := qGuardInv_error (Encodable.encode m / 3) (evalE q N e) (he.2 h₁ (codeSpaceTime q)) |
| apply hg.trans |
| push_cast |
| simpa only [mul_assoc] using mul_le_mul_of_nonneg_left hchild |
| (by positivity : 0 ≤ 2 * ((Encodable.encode m / 3 : ℕ) + 1 : ℝ) ^ 2) |
| · have hl := (flatTerm_lipschitz (Encodable.encode m / 3)).dist_le_mul |
| (value e (codeSpaceTime q)) (Qval (evalE q N e)) |
| simp only [Real.dist_eq, NNReal.coe_natCast] at hl |
| have ht := qFlat_error (Encodable.encode m / 3) (evalE q N e) N |
| have hd := abs_sub_le (flatTerm (Encodable.encode m / 3) (value e (codeSpaceTime q))) |
| (flatTerm (Encodable.encode m / 3) (Qval (evalE q N e))) |
| (Qval (qFlat (Encodable.encode m / 3, evalE q N e, N))) |
| apply hd.trans |
| push_cast |
| calc |
| _ ≤ (flatLipschitzBound (Encodable.encode m / 3) : ℝ) * |
| ((ampE R e : ℝ) * ((N : ℝ) + 1)⁻¹) + ((N : ℝ) + 1)⁻¹ := by |
| gcongr |
| exact hl.trans (mul_le_mul_of_nonneg_left hchild (Nat.cast_nonneg _)) |
| _ = _ := by ring |
|
|
| end BoxTransport.Routing.Computation |
|
|
| open scoped BigOperators ContDiff |
| open Nat.Partrec (Code) |
| namespace BoxTransport.Routing.Computation |
|
|
| attribute [fun_prop] Primrec Computable |
| attribute [fun_prop] Primrec.const Primrec.id Primrec.fst Primrec.snd Primrec.comp Primrec.pair Primrec.succ Primrec.encode Primrec.ofNat |
| attribute [fun_prop] Computable.const Computable.id Computable.fst Computable.snd Computable.comp Computable.pair |
|
|
| @[fun_prop] theorem pr_add {α} [Primcodable α] {f g : α → ℕ} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => f a + g a) := Primrec.nat_add.comp hf hg |
| @[fun_prop] theorem pr_mul {α} [Primcodable α] {f g : α → ℕ} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => f a * g a) := Primrec.nat_mul.comp hf hg |
| @[fun_prop] theorem pr_sub {α} [Primcodable α] {f g : α → ℕ} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => f a - g a) := Primrec.nat_sub.comp hf hg |
| @[fun_prop] theorem pr_div {α} [Primcodable α] {f g : α → ℕ} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => f a / g a) := Primrec.nat_div.comp hf hg |
| @[fun_prop] theorem pr_mod {α} [Primcodable α] {f g : α → ℕ} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => f a % g a) := Primrec.nat_mod.comp hf hg |
| @[fun_prop] theorem pr_square {α} [Primcodable α] {f : α → ℕ} (hf : Primrec f) : |
| Primrec (fun a => f a ^ 2) := by simpa only [pow_two] using pr_mul hf hf |
| @[fun_prop] theorem pr_pair {α} [Primcodable α] {f g : α → Expr} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => Code.pair (f a) (g a)) := Code.primrec₂_pair.comp hf hg |
| @[fun_prop] theorem pr_comp {α} [Primcodable α] {f g : α → Expr} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => Code.comp (f a) (g a)) := Code.primrec₂_comp.comp hf hg |
| @[fun_prop] theorem pr_prec {α} [Primcodable α] {f g : α → Expr} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => Code.prec (f a) (g a)) := Code.primrec₂_prec.comp hf hg |
| attribute [fun_prop] Code.primrec_rfind' primrec_qNat primrec_qBound primrec_qInv primrec_qAbs primrec_qNeg primrec_factorial |
|
|
| @[fun_prop] theorem pr_qAdd {α} [Primcodable α] {f g : α → QCode} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => qAdd (f a) (g a)) := primrec_qAdd.comp hf hg |
| @[fun_prop] theorem pr_qMul {α} [Primcodable α] {f g : α → QCode} (hf : Primrec f) (hg : Primrec g) : |
| Primrec (fun a => qMul (f a) (g a)) := primrec_qMul.comp hf hg |
|
|
| @[fun_prop] theorem primrec_node : Primrec (fun p : ℕ × Expr => node p.1 p.2) := by |
| unfold node; fun_prop |
| @[fun_prop] theorem pr_node {α} [Primcodable α] {m : α → ℕ} {e : α → Expr} |
| (hm : Primrec m) (he : Primrec e) : Primrec (fun a => node (m a) (e a)) := primrec_node.comp (hm.pair he) |
| @[fun_prop] theorem primrec_cst : Primrec cst := by unfold cst; fun_prop |
| @[fun_prop] theorem pr_invE {α} [Primcodable α] {m : α → ℕ} {e : α → Expr} |
| (hm : Primrec m) (he : Primrec e) : Primrec (fun a => invE (m a) (e a)) := by unfold invE; fun_prop |
| @[fun_prop] theorem pr_flatE {α} [Primcodable α] {m : α → ℕ} {e : α → Expr} |
| (hm : Primrec m) (he : Primrec e) : Primrec (fun a => flatE (m a) (e a)) := by unfold flatE; fun_prop |
|
|
| @[fun_prop] theorem primrec_diffUnary : |
| Primrec (fun p : ℕ × Expr × Expr => diffUnary p.1 p.2.1 p.2.2) := by |
| unfold diffUnary |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 0)) |
| · fun_prop |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 1)) <;> fun_prop |
|
|
| theorem diff_eq_rec (j : Axis) (e : Expr) : diff j e = |
| Code.recOn e (cst (if j = none then qOne else qZero)) |
| (cst (if j = some 0 then qOne else qZero)) |
| (cst (if j = some 1 then qOne else qZero)) |
| (cst (if j = some 2 then qOne else qZero)) |
| (fun _ _ de df => Code.pair de df) |
| (fun e f de df => Code.pair (Code.comp de f) (Code.comp e df)) |
| (fun m e _ de => diffUnary (Encodable.encode m) e de) |
| (fun _ de => Code.rfind' de) := by |
| induction e <;> simp_all only [diff] |
|
|
| @[fun_prop] theorem primrec_diff : Primrec (fun p : Axis × Expr => diff p.1 p.2) := by |
| simp_rw [diff_eq_rec] |
| apply Code.primrec_recOn Primrec.snd |
| · exact (show Primrec (fun j : Axis => cst (if j = none then qOne else qZero)) from Primrec.dom_finite _).comp Primrec.fst |
| · exact (show Primrec (fun j : Axis => cst (if j = some 0 then qOne else qZero)) from Primrec.dom_finite _).comp Primrec.fst |
| · exact (show Primrec (fun j : Axis => cst (if j = some 1 then qOne else qZero)) from Primrec.dom_finite _).comp Primrec.fst |
| · exact (show Primrec (fun j : Axis => cst (if j = some 2 then qOne else qZero)) from Primrec.dom_finite _).comp Primrec.fst |
| · fun_prop |
| · fun_prop |
| · fun_prop |
| · fun_prop |
|
|
| @[fun_prop] theorem primrec_unaryBound : Primrec (fun p : ℕ × ℕ => unaryBound p.1 p.2) := by |
| unfold unaryBound |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 0)) |
| · fun_prop |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 1)) <;> fun_prop |
|
|
| theorem boundE_eq_rec (R : ℕ) (e : Expr) : boundE R e = |
| Code.recOn e R R R R (fun _ _ a b => a + b) (fun _ _ a b => a * b) |
| (fun m _ _ _ => unaryBound (Encodable.encode m) R) (fun _ a => a) := by |
| induction e <;> simp_all only [boundE] |
|
|
| @[fun_prop] theorem primrec_boundE : Primrec (fun p : ℕ × Expr => boundE p.1 p.2) := by |
| simp_rw [boundE_eq_rec] |
| apply Code.primrec_recOn Primrec.snd <;> fun_prop |
|
|
| @[fun_prop] theorem primrec_unaryAmp : Primrec (fun p : ℕ × ℕ => unaryAmp p.1 p.2) := by |
| unfold unaryAmp flatLipschitzBound |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 0)) |
| · fun_prop |
| apply Primrec.ite (Primrec.eq.comp (by fun_prop) (Primrec.const 1)) <;> fun_prop |
|
|
| theorem ampE_eq_rec (R : ℕ) (e : Expr) : ampE R e = |
| Code.recOn e 0 0 0 0 (fun _ _ a b => a + b) |
| (fun e f a b => (boundE R e + a) * b + boundE R f * a) |
| (fun m _ _ a => unaryAmp (Encodable.encode m) a) (fun _ a => a) := by |
| induction e <;> simp_all only [ampE] |
|
|
| @[fun_prop] theorem primrec_ampE : Primrec (fun p : ℕ × Expr => ampE p.1 p.2) := by |
| simp_rw [ampE_eq_rec] |
| apply Code.primrec_recOn Primrec.snd <;> fun_prop |
|
|
| @[fun_prop] theorem primrec_qGuardInv : Primrec (fun p : ℕ × QCode => qGuardInv p.1 p.2) := by |
| unfold qGuardInv |
| apply Primrec.ite (primrec_qLe.comp (by fun_prop) (by fun_prop)) <;> fun_prop |
|
|
| attribute [fun_prop] Primrec.to_comp computable_qFlat |
|
|
| @[fun_prop] theorem computable_unaryEval : |
| Computable (fun p : ℕ × QCode × ℕ => unaryEval p.1 p.2.1 p.2.2) := by |
| unfold unaryEval |
| apply computable_ite (PrimrecPred.computablePred (Primrec.eq.comp (by fun_prop) (Primrec.const 0))) |
| · fun_prop |
| apply computable_ite (PrimrecPred.computablePred (Primrec.eq.comp (by fun_prop) (Primrec.const 1))) <;> fun_prop |
|
|
| theorem evalE_eq_rec (q : RationalPointCode) (N : ℕ) (e : Expr) : evalE q N e = |
| Code.recOn e q.1 q.2.1 q.2.2.1 q.2.2.2 |
| (fun _ _ a b => qAdd a b) (fun _ _ a b => qMul a b) |
| (fun m _ _ a => unaryEval (Encodable.encode m) a N) (fun _ a => qNeg a) := by |
| induction e <;> simp_all only [evalE] |
|
|
| theorem computable_Expr_recOn {α σ} |
| [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} |
| (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} |
| (hr : Computable r) {pr : α → Code → Code → σ → σ → σ} |
| (hpr : Computable fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) |
| {co : α → Code → Code → σ → σ → σ} |
| (hco : Computable fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) |
| {pc : α → Code → Code → σ → σ → σ} |
| (hpc : Computable fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) |
| {rf : α → Code → σ → σ} (hrf : Computable fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : |
| Computable (fun a : α => (Code.recOn (c a) (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) : σ)) := |
| Code.computable_recOn hc hz hs hl hr |
| (pr := fun a b => pr a b.1 b.2.1 b.2.2.1 b.2.2.2) (.mk hpr) |
| (co := fun a b => co a b.1 b.2.1 b.2.2.1 b.2.2.2) (.mk hco) |
| (pc := fun a b => pc a b.1 b.2.1 b.2.2.1 b.2.2.2) (.mk hpc) |
| (rf := fun a b => rf a b.1 b.2) (.mk hrf) |
|
|
| @[fun_prop] theorem computable_evalE : |
| Computable (fun p : RationalPointCode × ℕ × Expr => evalE p.1 p.2.1 p.2.2) := by |
| simp_rw [evalE_eq_rec] |
| apply computable_Expr_recOn (Computable.snd.comp Computable.snd) <;> fun_prop |
|
|
| end BoxTransport.Routing.Computation |
|
|
| open scoped BigOperators ContDiff |
| open Nat.Partrec (Code) |
| namespace BoxTransport.Routing.Computation |
|
|
| def pointBound (q : RationalPointCode) : ℕ := |
| qBound q.1 + qBound q.2.1 + qBound q.2.2.1 + qBound q.2.2.2 |
|
|
| @[fun_prop] theorem primrec_pointBound : Primrec pointBound := by unfold pointBound; fun_prop |
|
|
| theorem norm_code_le (q : RationalPointCode) : ‖codeSpaceTime q‖ ≤ pointBound q := by |
| have h0 : |(Qval q.1 : ℝ)| ≤ (qBound q.1 : ℝ) := by exact_mod_cast Qval_bound q.1 |
| have h1 : |(Qval q.2.1 : ℝ)| ≤ (qBound q.2.1 : ℝ) := by exact_mod_cast Qval_bound q.2.1 |
| have h2 : |(Qval q.2.2.1 : ℝ)| ≤ (qBound q.2.2.1 : ℝ) := by exact_mod_cast Qval_bound q.2.2.1 |
| have h3 : |(Qval q.2.2.2 : ℝ)| ≤ (qBound q.2.2.2 : ℝ) := by exact_mod_cast Qval_bound q.2.2.2 |
| rw [Prod.norm_def, max_le_iff] |
| constructor |
| · change |(Qval q.1 : ℝ)| ≤ _ |
| unfold pointBound; push_cast; have := Nat.cast_nonneg (α := ℝ) (qBound q.2.1 + qBound q.2.2.1 + qBound q.2.2.2) |
| push_cast at this; linarith |
| · apply (pi_norm_le_iff_of_nonneg (Nat.cast_nonneg _)).2 |
| intro j |
| fin_cases j <;> change |(Qval _ : ℝ)| ≤ _ |
| all_goals unfold pointBound; push_cast |
| all_goals linarith [Nat.cast_nonneg (α := ℝ) (qBound q.1), Nat.cast_nonneg (α := ℝ) (qBound q.2.1), |
| Nat.cast_nonneg (α := ℝ) (qBound q.2.2.1), Nat.cast_nonneg (α := ℝ) (qBound q.2.2.2)] |
|
|
| noncomputable def evalPrecise (e : Expr) (q : RationalPointCode) (N : ℕ) : QCode := |
| evalE q ((N + 1) * (ampE (pointBound q) e + 1)) e |
|
|
| @[fun_prop] theorem computable_evalPrecise : |
| Computable (fun p : Expr × RationalPointCode × ℕ => evalPrecise p.1 p.2.1 p.2.2) := by |
| unfold evalPrecise |
| fun_prop |
|
|
| theorem amplification_precision (A N : ℕ) : |
| (A : ℝ) * (((((N + 1) * (A + 1) : ℕ) : ℝ) + 1)⁻¹) ≤ ((N : ℝ) + 1)⁻¹ := by |
| 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 [Nat.cast_nonneg (α := ℝ) N] |
|
|
| theorem evalPrecise_error {e : Expr} (he : Valid e) (q : RationalPointCode) (N : ℕ) : |
| |value e (codeSpaceTime q) - (Qval (evalPrecise e q N) : ℝ)| ≤ ((N : ℝ) + 1)⁻¹ := |
| (evalE_error he q _ _ (norm_code_le q)).trans (amplification_precision _ N) |
|
|
| def mixedE (ds : List Axis) (e : Expr) : Expr := ds.foldr diff e |
|
|
| @[simp] theorem mixedE_nil (e : Expr) : mixedE [] e = e := rfl |
| @[simp] theorem mixedE_cons (j : Axis) (ds : List Axis) (e : Expr) : |
| mixedE (j :: ds) e = diff j (mixedE ds e) := rfl |
|
|
| @[fun_prop] theorem primrec_mixedE : Primrec (fun p : List Axis × Expr => mixedE p.1 p.2) := by |
| unfold mixedE |
| exact Primrec.list_foldr (h := fun _ p => diff p.1 p.2) Primrec.fst Primrec.snd (.mk (primrec_diff.comp Primrec.snd)) |
|
|
| theorem valid_mixedE {e : Expr} (he : Valid e) (ds : List Axis) : Valid (mixedE ds e) := by |
| induction ds with |
| | nil => exact he |
| | cons j ds ih => exact valid_diff ih j |
|
|
| theorem smooth_mixedDerivative {U : Field} (hU : ContDiff ℝ ∞ U) (ds : List Axis) : |
| ContDiff ℝ ∞ (mixedDerivative ds U) := by |
| induction ds with |
| | nil => exact hU |
| | cons j ds ih => exact (ih.fderiv_right (m := ∞) (by simp)).clm_apply contDiff_const |
|
|
| theorem mixedDerivative_component {U : Field} (hU : ContDiff ℝ ∞ U) |
| {es : Fin 3 → Expr} (he : ∀ j, Valid (es j)) (hval : ∀ p j, value (es j) p = U p j) |
| (ds : List Axis) (p : SpaceTime) (j : Fin 3) : |
| value (mixedE ds (es j)) p = mixedDerivative ds U p j := by |
| induction ds generalizing p with |
| | nil => exact hval p j |
| | cons d ds ih => |
| rw [mixedE_cons, value_diff (valid_mixedE (he j) ds)] |
| have hv : value (mixedE ds (es j)) = fun p => mixedDerivative ds U p j := by |
| funext p |
| exact ih p |
| rw [hv, fderiv_apply ((smooth_mixedDerivative hU ds).differentiable (by simp) p)] |
| rfl |
|
|
| theorem tsupport_mixedDerivative_subset (U : Field) (ds : List Axis) : |
| tsupport (mixedDerivative ds U) ⊆ tsupport U := by |
| induction ds with |
| | nil => exact Set.Subset.rfl |
| | cons j ds ih => exact (tsupport_fderiv_apply_subset ℝ (coordinateDirection j)).trans ih |
|
|
| theorem exists_supportRadius {U : Field} (hU : HasCompactSupport U) : |
| ∃ R : ℕ, ∀ p ∈ tsupport U, ‖p‖ ≤ R := by |
| obtain ⟨r, hr⟩ := hU.isCompact.isBounded.subset_closedBall (0 : SpaceTime) |
| obtain ⟨R, hR⟩ := exists_nat_ge r |
| refine ⟨R, fun p hp => ?_⟩ |
| have hp' : ‖p‖ ≤ r := by simpa [Metric.mem_closedBall, dist_zero_right] using hr hp |
| exact hp'.trans hR |
|
|
| def familyBound (R : ℕ) (es : Fin 3 → Expr) (ds : List Axis) : ℕ := |
| boundE R (mixedE ds (es 0)) + boundE R (mixedE ds (es 1)) + boundE R (mixedE ds (es 2)) |
|
|
| @[fun_prop] theorem primrec_familyBound (R : ℕ) (es : Fin 3 → Expr) : |
| Primrec (familyBound R es) := by unfold familyBound; fun_prop |
|
|
| theorem boundE_le_familyBound (R : ℕ) (es : Fin 3 → Expr) (ds : List Axis) (j : Fin 3) : |
| boundE R (mixedE ds (es j)) ≤ familyBound R es ds := by |
| fin_cases j <;> simp only [familyBound, Fin.reduceFinMk] <;> omega |
|
|
| theorem uniform_mixed_bound {U : Field} (hU : ContDiff ℝ ∞ U) |
| {es : Fin 3 → Expr} (he : ∀ j, Valid (es j)) (hval : ∀ p j, value (es j) p = U p j) |
| (R : ℕ) (hR : ∀ p ∈ tsupport U, ‖p‖ ≤ R) (ds : List Axis) (p : SpaceTime) (j : Fin 3) : |
| |mixedDerivative ds U p j| ≤ familyBound R es ds := by |
| by_cases hp : p ∈ tsupport U |
| · rw [← mixedDerivative_component hU he hval] |
| exact (value_bound (valid_mixedE (he j) ds) R (hR p hp)).trans |
| (Nat.cast_le.mpr (boundE_le_familyBound R es ds j)) |
| · have hx : mixedDerivative ds U p = 0 := |
| image_eq_zero_of_notMem_tsupport (fun h => hp (tsupport_mixedDerivative_subset U ds h)) |
| rw [hx]; simp only [Pi.zero_apply, abs_zero]; positivity |
|
|
| theorem spacetime_decomposition (p : SpaceTime) : |
| p = ∑ j : Axis, value (varE j) p • coordinateDirection j := by |
| simp only [Fintype.sum_option, Fin.sum_univ_three, value_varE] |
| apply Prod.ext |
| · simp [coordinateDirection] |
| · funext j |
| fin_cases j <;> simp [coordinateDirection, coordinateVector] |
|
|
| theorem opnorm_from_coordinates (L : SpaceTime →L[ℝ] ℝ) {M : ℝ} (hM : 0 ≤ M) |
| (hL : ∀ j : Axis, |L (coordinateDirection j)| ≤ M) : ‖L‖ ≤ 4 * M := by |
| apply L.opNorm_le_bound (by positivity) |
| intro p |
| calc |
| ‖L p‖ = ‖∑ j : Axis, value (varE j) p • L (coordinateDirection j)‖ := by |
| conv_lhs => rw [spacetime_decomposition p] |
| simp only [map_sum, map_smul] |
| _ ≤ ∑ j : Axis, ‖value (varE j) p • L (coordinateDirection j)‖ := norm_sum_le _ _ |
| _ ≤ ∑ _j : Axis, ‖p‖ * M := by |
| apply Finset.sum_le_sum |
| intro j _ |
| simp only [norm_smul, Real.norm_eq_abs] |
| exact mul_le_mul (coord_le_norm j p) (hL j) (abs_nonneg _) (norm_nonneg _) |
| _ = (4 * M) * ‖p‖ := by simp [Fintype.card_option]; ring |
|
|
| def gradientBound (R : ℕ) (es : Fin 3 → Expr) (ds : List Axis) : ℕ := |
| familyBound R es (none :: ds) + familyBound R es (some 0 :: ds) + |
| familyBound R es (some 1 :: ds) + familyBound R es (some 2 :: ds) |
|
|
| @[fun_prop] theorem pr_list_cons {α β} [Primcodable α] [Primcodable β] {f : α → β} {g : α → List β} |
| (hf : Primrec f) (hg : Primrec g) : Primrec (fun a => f a :: g a) := Primrec.list_cons.comp hf hg |
|
|
| @[fun_prop] theorem primrec_gradientBound (R : ℕ) (es : Fin 3 → Expr) : |
| Primrec (gradientBound R es) := by unfold gradientBound; fun_prop |
|
|
| theorem familyBound_le_gradientBound (R : ℕ) (es : Fin 3 → Expr) (ds : List Axis) (d : Axis) : |
| familyBound R es (d :: ds) ≤ gradientBound R es ds := by |
| cases d with |
| | none => unfold gradientBound; omega |
| | some j => fin_cases j <;> simp only [gradientBound, Fin.reduceFinMk] <;> omega |
|
|
| theorem mixed_component_lipschitz {U : Field} (hU : ContDiff ℝ ∞ U) |
| {es : Fin 3 → Expr} (he : ∀ j, Valid (es j)) (hval : ∀ p j, value (es j) p = U p j) |
| (R : ℕ) (hR : ∀ p ∈ tsupport U, ‖p‖ ≤ R) (ds : List Axis) (j : Fin 3) : |
| LipschitzWith (4 * gradientBound R es ds) (fun p => mixedDerivative ds U p j) := by |
| have hs := smooth_mixedDerivative hU ds |
| apply lipschitzWith_of_nnnorm_fderiv_le ((contDiff_pi.mp hs j).differentiable (by simp)) |
| intro p |
| apply NNReal.coe_le_coe.mp |
| simp only [coe_nnnorm, NNReal.coe_mul, NNReal.coe_natCast, NNReal.coe_ofNat] |
| apply opnorm_from_coordinates _ (Nat.cast_nonneg _) |
| intro d |
| rw [fderiv_apply (hs.differentiable (by simp) p)] |
| change |mixedDerivative (d :: ds) U p j| ≤ _ |
| exact (uniform_mixed_bound hU he hval R hR (d :: ds) p j).trans |
| (Nat.cast_le.mpr (familyBound_le_gradientBound R es ds d)) |
|
|
| theorem effective_of_expressions {U : Field} (hU : ContDiff ℝ ∞ U) (hc : HasCompactSupport U) |
| (es : Fin 3 → Expr) (he : ∀ j, Valid (es j)) (hval : ∀ p j, value (es j) p = U p j) : |
| Effective U := by |
| obtain ⟨R, hR⟩ := exists_supportRadius hc |
| let ev : EvaluationRequest → RationalCode := fun r => |
| evalPrecise (mixedE r.1 (es r.2.2.2)) r.2.1 (2 * r.2.2.1 + 1) |
| let md : List Axis × ℕ → ℕ := fun r => |
| ((2 * r.2 + 1) + 1) * (4 * gradientBound R es r.1 + 1) |
| have hes : Primrec es := Primrec.dom_finite _ |
| have hev : Computable ev := by |
| unfold ev |
| have hs : Primrec (fun r : EvaluationRequest => es r.2.2.2) := |
| hes.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)) |
| have hm : Primrec (fun r : EvaluationRequest => mixedE r.1 (es r.2.2.2)) := |
| primrec_mixedE.comp (Primrec.fst.pair hs) |
| have hp : Primrec (fun r : EvaluationRequest => 2 * r.2.2.1 + 1) := by fun_prop |
| have hq : Primrec (fun r : EvaluationRequest => r.2.1) := Primrec.fst.comp Primrec.snd |
| have hreq : Computable (fun r : EvaluationRequest => (mixedE r.1 (es r.2.2.2), r.2.1, 2 * r.2.2.1 + 1)) := |
| (hm.pair (hq.pair hp)).to_comp |
| have h := computable_evalPrecise.comp hreq |
| exact h |
| have hmd : Computable md := by unfold md; fun_prop |
| refine ⟨ev, md, familyBound R es, hev, hmd, (primrec_familyBound R es).to_comp, ?_, ?_⟩ |
| · intro ds q N p hp j |
| have hl := (mixed_component_lipschitz hU he hval R hR ds j).dist_le_mul p (codeSpaceTime q) |
| simp only [dist_eq_norm, NNReal.coe_mul, NNReal.coe_ofNat, NNReal.coe_natCast] at hl |
| have heval := evalPrecise_error (valid_mixedE (he j) ds) q (2 * N + 1) |
| rw [mixedDerivative_component hU he hval ds (codeSpaceTime q) j] at heval |
| change |mixedDerivative ds U p j - (Qval (evalPrecise (mixedE ds (es j)) q (2 * N + 1)) : ℝ)| ≤ _ |
| calc |
| _ ≤ |mixedDerivative ds U p j - mixedDerivative ds U (codeSpaceTime q) j| + |
| |mixedDerivative ds U (codeSpaceTime q) j - (Qval (evalPrecise (mixedE ds (es j)) q (2 * N + 1)) : ℝ)| := abs_sub_le _ _ _ |
| _ ≤ (4 * (gradientBound R es ds : ℝ)) * ((md (ds, N) : ℝ) + 1)⁻¹ + |
| (((2 * N + 1 : ℕ) : ℝ) + 1)⁻¹ := by |
| apply add_le_add _ heval |
| exact hl.trans (mul_le_mul_of_nonneg_left hp (by positivity)) |
| _ ≤ (((2 * N + 1 : ℕ) : ℝ) + 1)⁻¹ + (((2 * N + 1 : ℕ) : ℝ) + 1)⁻¹ := by |
| apply add_le_add _ le_rfl |
| simpa only [md, Nat.cast_mul, Nat.cast_ofNat] using amplification_precision (4 * gradientBound R es ds) (2 * N + 1) |
| _ = ((N : ℝ) + 1)⁻¹ := by push_cast; field_simp; ring |
| · exact uniform_mixed_bound hU he hval R hR |
|
|
| end BoxTransport.Routing.Computation |
|
|
| open scoped BigOperators ContDiff |
| open Nat.Partrec (Code) |
| namespace BoxTransport.Routing.Computation |
|
|
| def Representable (f : SpaceTime → ℝ) : Prop := ∃ e : Expr, Valid e ∧ value e = f |
|
|
| attribute [fun_prop] Representable |
|
|
| namespace Representable |
|
|
| @[fun_prop] theorem rational (q : ℚ) : Representable (fun _ => (q : ℝ)) := by |
| obtain ⟨r, hr⟩ := Qval_surjective q |
| exact ⟨cst r, valid_cst r, by funext p; simp [hr]⟩ |
|
|
| @[fun_prop] theorem nat (n : ℕ) : Representable (fun _ => (n : ℝ)) := by |
| simpa using rational (n : ℚ) |
|
|
| @[fun_prop] theorem ofNat (n : ℕ) [n.AtLeastTwo] : Representable (fun _ => (ofNat(n) : ℝ)) := nat n |
|
|
| @[fun_prop] theorem zero : Representable (fun _ => (0 : ℝ)) := by simpa using nat 0 |
| @[fun_prop] theorem one : Representable (fun _ => (1 : ℝ)) := by simpa using nat 1 |
| @[fun_prop] theorem time : Representable (fun p : SpaceTime => p.1) := |
| ⟨.zero, trivial, rfl⟩ |
| @[fun_prop] theorem space (j : Fin 3) : Representable (fun p : SpaceTime => p.2 j) := |
| ⟨varE (some j), valid_varE _, by funext p; simp⟩ |
|
|
| @[fun_prop] theorem add {f g : SpaceTime → ℝ} (hf : Representable f) (hg : Representable g) : |
| Representable (fun p => f p + g p) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| obtain ⟨d, hd, rfl⟩ := hg |
| exact ⟨.pair e d, ⟨he, hd⟩, rfl⟩ |
|
|
| @[fun_prop] theorem mul {f g : SpaceTime → ℝ} (hf : Representable f) (hg : Representable g) : |
| Representable (fun p => f p * g p) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| obtain ⟨d, hd, rfl⟩ := hg |
| exact ⟨.comp e d, ⟨he, hd⟩, rfl⟩ |
|
|
| @[fun_prop] theorem neg {f : SpaceTime → ℝ} (hf : Representable f) : |
| Representable (fun p => -f p) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| exact ⟨.rfind' e, he, rfl⟩ |
|
|
| @[fun_prop] theorem sub {f g : SpaceTime → ℝ} (hf : Representable f) (hg : Representable g) : |
| Representable (fun p => f p - g p) := by simpa only [sub_eq_add_neg] using hf.add hg.neg |
|
|
| @[fun_prop] theorem div_rat {f : SpaceTime → ℝ} (hf : Representable f) (q : ℚ) : |
| Representable (fun p => f p / (q : ℝ)) := by |
| simpa only [Rat.cast_inv, div_eq_mul_inv] using hf.mul (rational q⁻¹) |
|
|
| @[fun_prop] theorem div_nat {f : SpaceTime → ℝ} (hf : Representable f) (n : ℕ) : |
| Representable (fun p => f p / (n : ℝ)) := by simpa using hf.div_rat (n : ℚ) |
|
|
| @[fun_prop] theorem div_ofNat {f : SpaceTime → ℝ} (hf : Representable f) (n : ℕ) [n.AtLeastTwo] : |
| Representable (fun p => f p / (ofNat(n) : ℝ)) := hf.div_nat n |
|
|
| @[fun_prop] theorem flat {f : SpaceTime → ℝ} (hf : Representable f) (m : ℕ) : |
| Representable (fun p => flatTerm m (f p)) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| exact ⟨flatE m e, (valid_flatE _ _).2 he, by funext p; simp⟩ |
|
|
| @[fun_prop] theorem glue {f : SpaceTime → ℝ} (hf : Representable f) : |
| Representable (fun p => expNegInvGlue (f p)) := by |
| simpa only [flatTerm, pow_zero, one_mul] using hf.flat 0 |
|
|
| lemma exists_inv_nat_le {ε : ℝ} (hε : 0 < ε) : ∃ b : ℕ, ((b : ℝ) + 1)⁻¹ ≤ ε := by |
| obtain ⟨b, hb⟩ := exists_nat_gt ε⁻¹ |
| refine ⟨b, (inv_le_iff_one_le_mul₀ (by positivity)).2 ?_⟩ |
| have h := mul_lt_mul_of_pos_left hb hε |
| rw [mul_inv_cancel₀ (ne_of_gt hε)] at h |
| nlinarith |
|
|
| theorem inv {f : SpaceTime → ℝ} (hf : Representable f) |
| (hsep : ∃ ε : ℝ, 0 < ε ∧ ∀ p, ε ≤ |f p|) : Representable (fun p => (f p)⁻¹) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| obtain ⟨ε, hε, hsep⟩ := hsep |
| obtain ⟨b, hb⟩ := exists_inv_nat_le hε |
| exact ⟨invE b e, (valid_invE _ _).2 ⟨he, fun p => hb.trans (hsep p)⟩, |
| by funext p; simp⟩ |
|
|
| theorem div {f g : SpaceTime → ℝ} (hf : Representable f) (hg : Representable g) |
| (hsep : ∃ ε : ℝ, 0 < ε ∧ ∀ p, ε ≤ |g p|) : Representable (fun p => f p / g p) := by |
| simpa only [div_eq_mul_inv] using hf.mul (hg.inv hsep) |
|
|
| theorem transition_denom_lower (x : ℝ) : |
| expNegInvGlue (1 / 2) ≤ expNegInvGlue x + expNegInvGlue (1 - x) := by |
| rcases le_total (1 / 2 : ℝ) x with hx | hx |
| · exact (expNegInvGlue.monotone hx).trans (le_add_of_nonneg_right (expNegInvGlue.nonneg _)) |
| · have hy : (1 / 2 : ℝ) ≤ 1 - x := by linarith |
| exact (expNegInvGlue.monotone hy).trans (le_add_of_nonneg_left (expNegInvGlue.nonneg _)) |
|
|
| @[fun_prop] theorem transition {f : SpaceTime → ℝ} (hf : Representable f) : |
| Representable (fun p => Real.smoothTransition (f p)) := by |
| apply hf.glue.div (hf.glue.add ((one.sub hf).glue)) |
| refine ⟨expNegInvGlue (1 / 2), expNegInvGlue.pos_of_pos (by norm_num), fun p => ?_⟩ |
| rw [abs_of_nonneg (add_nonneg (expNegInvGlue.nonneg _) (expNegInvGlue.nonneg _))] |
| exact transition_denom_lower _ |
|
|
| @[fun_prop] theorem directional {f : SpaceTime → ℝ} (hf : Representable f) (j : Axis) : |
| Representable (fun p => fderiv ℝ f p (coordinateDirection j)) := by |
| obtain ⟨e, he, rfl⟩ := hf |
| exact ⟨diff j e, valid_diff he j, funext (value_diff he j)⟩ |
|
|
| theorem smooth {f : SpaceTime → ℝ} (hf : Representable f) : ContDiff ℝ ∞ f := by |
| obtain ⟨e, he, rfl⟩ := hf |
| exact smooth_value he |
|
|
| @[fun_prop] theorem sum {ι : Type*} (s : Finset ι) {f : ι → SpaceTime → ℝ} |
| (hf : ∀ i ∈ s, Representable (f i)) : Representable (fun p => ∑ i ∈ s, f i p) := by |
| classical |
| induction s using Finset.induction with |
| | empty => simpa using zero |
| | @insert i s hi ih => |
| simpa only [Finset.sum_insert hi] using (hf i (Finset.mem_insert_self _ _)).add |
| (ih (fun j hj => hf j (Finset.mem_insert_of_mem hj))) |
|
|
| @[fun_prop] theorem prod {ι : Type*} (s : Finset ι) {f : ι → SpaceTime → ℝ} |
| (hf : ∀ i ∈ s, Representable (f i)) : Representable (fun p => ∏ i ∈ s, f i p) := by |
| classical |
| induction s using Finset.induction with |
| | empty => simpa using one |
| | @insert i s hi ih => |
| simpa only [Finset.prod_insert hi] using (hf i (Finset.mem_insert_self _ _)).mul |
| (ih (fun j hj => hf j (Finset.mem_insert_of_mem hj))) |
|
|
| end Representable |
|
|
| end BoxTransport.Routing.Computation |
|
|
| end |
|
|
| end OAI |
|
|
