| import OAI.MathematicalPhysics.AlternatingFlow.Analytic |
|
|
| namespace OAI |
|
|
| open scoped BigOperators ENNReal NNReal Topology ContDiff |
| open MeasureTheory |
| namespace AlternatingNS |
| namespace Bounds |
| noncomputable section |
|
|
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] |
|
|
| def BoundedJets (f : E → F) : Prop := |
| ContDiff ℝ ∞ f ∧ ∀ r : ℕ, ∃ C : ℝ, 0 ≤ C ∧ ∀ x, ‖iteratedFDeriv ℝ r f x‖ ≤ C |
|
|
| def ScaledJets (s : ℕ → ℝ) (f : ℕ → E → F) : Prop := |
| (∀ n, ContDiff ℝ ∞ (f n)) ∧ ∀ r : ℕ, ∃ C : ℝ, 0 ≤ C ∧ |
| ∀ n x, ‖iteratedFDeriv ℝ r (f n) x‖ ≤ C * s n ^ r |
|
|
| lemma compact_bounded (f : E → F) (hf : ContDiff ℝ ∞ f) (hc : HasCompactSupport f) : |
| BoundedJets f := by |
| refine ⟨hf, fun r => ?_⟩ |
| obtain ⟨B, hB⟩ := ((hc.iteratedFDeriv r).isCompact_range |
| (hf.continuous_iteratedFDeriv (WithTop.coe_le_coe.mpr le_top))).exists_bound_of_continuousOn |
| continuous_id.continuousOn |
| exact ⟨max 0 B, le_max_left _ _, fun x => (hB _ ⟨x, rfl⟩).trans (le_max_right _ _)⟩ |
|
|
| lemma ScaledJets.congr {s : ℕ → ℝ} {f g : ℕ → E → F} (hf : ScaledJets s f) |
| (he : ∀ n x, f n x = g n x) : ScaledJets s g := by |
| have h : f = g := funext (fun n => funext (he n)) |
| rwa [← h] |
|
|
| lemma ScaledJets.const {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) (a : ℕ → F) |
| (B : ℝ) (hB : 0 ≤ B) (ha : ∀ n, ‖a n‖ ≤ B) : |
| ScaledJets s (fun n (_ : E) => a n) := by |
| refine ⟨fun _ => contDiff_const, fun r => ⟨B, hB, fun n x => ?_⟩⟩ |
| rcases r with _ | r |
| · simpa only [norm_iteratedFDeriv_zero, pow_zero, mul_one] using ha n |
| · rw [iteratedFDeriv_const_of_ne (Nat.succ_ne_zero _), Pi.zero_apply, norm_zero] |
| exact mul_nonneg hB (pow_nonneg (hs n) _) |
|
|
| lemma ScaledJets.fixed {s : ℕ → ℝ} (hs : ∀ n, 1 ≤ s n) {f : E → F} |
| (hf : BoundedJets f) : ScaledJets s (fun _ => f) := by |
| refine ⟨fun _ => hf.1, fun r => ?_⟩ |
| obtain ⟨C, hC, h⟩ := hf.2 r |
| exact ⟨C, hC, fun n x => (h x).trans (le_mul_of_one_le_right hC (one_le_pow₀ (hs n)))⟩ |
|
|
| lemma ScaledJets.add {s : ℕ → ℝ} {f g : ℕ → E → F} |
| (hf : ScaledJets s f) (hg : ScaledJets s g) : |
| ScaledJets s (fun n x => f n x + g n x) := by |
| refine ⟨fun n => (hf.1 n).add (hg.1 n), fun r => ?_⟩ |
| obtain ⟨A, hA, hfa⟩ := hf.2 r |
| obtain ⟨B, hB, hgb⟩ := hg.2 r |
| refine ⟨A + B, add_nonneg hA hB, fun n x => ?_⟩ |
| rw [fun_iteratedFDeriv_add_apply (hf.1 n |>.of_le (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt) |
| (hg.1 n |>.of_le (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt)] |
| exact (norm_add_le _ _).trans (by linarith [hfa n x, hgb n x]) |
|
|
| lemma ScaledJets.sub {s : ℕ → ℝ} {f g : ℕ → E → F} |
| (hf : ScaledJets s f) (hg : ScaledJets s g) : |
| ScaledJets s (fun n x => f n x - g n x) := by |
| refine ⟨fun n => (hf.1 n).sub (hg.1 n), fun r => ?_⟩ |
| obtain ⟨A, hA, hfa⟩ := hf.2 r |
| obtain ⟨B, hB, hgb⟩ := hg.2 r |
| refine ⟨A + B, add_nonneg hA hB, fun n x => ?_⟩ |
| rw [fun_iteratedFDeriv_sub_apply (hf.1 n |>.of_le (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt) |
| (hg.1 n |>.of_le (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt)] |
| exact (norm_sub_le _ _).trans (by linarith [hfa n x, hgb n x]) |
|
|
| lemma ScaledJets.smul {s : ℕ → ℝ} (_hs : ∀ n, 0 ≤ s n) {f : ℕ → E → F} |
| (hf : ScaledJets s f) (a : ℕ → ℝ) (B : ℝ) (hB : 0 ≤ B) (ha : ∀ n, |a n| ≤ B) : |
| ScaledJets s (fun n x => a n • f n x) := by |
| refine ⟨fun n => contDiff_const.smul (hf.1 n), fun r => ?_⟩ |
| obtain ⟨C, hC, hc⟩ := hf.2 r |
| refine ⟨B * C, mul_nonneg hB hC, fun n x => ?_⟩ |
| rw [iteratedFDeriv_const_smul_apply' (hf.1 n |>.of_le (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt), norm_smul, |
| Real.norm_eq_abs] |
| calc |
| |a n| * ‖iteratedFDeriv ℝ r (f n) x‖ ≤ B * (C * s n ^ r) := by |
| gcongr |
| exact ha n |
| exact hc n x |
| _ = _ := by ring |
| |
| lemma ScaledJets.mul {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f g : ℕ → E → ℝ} |
| (hf : ScaledJets s f) (hg : ScaledJets s g) : |
| ScaledJets s (fun n x => f n x * g n x) := by |
| classical |
| refine ⟨fun n => (hf.1 n).mul (hg.1 n), fun r => ?_⟩ |
| choose A hA hfa using hf.2 |
| choose B hB hgb using hg.2 |
| let C := ∑ i ∈ Finset.range (r + 1), (r.choose i : ℝ) * A i * B (r - i) |
| refine ⟨C, Finset.sum_nonneg (fun i _ => mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (hA i)) (hB _)), fun n x => ?_⟩ |
| apply (norm_iteratedFDeriv_mul_le (hf.1 n) (hg.1 n) x (WithTop.coe_le_coe.mpr le_top : (r : ℕ∞ω) ≤ (∞ : ℕ∞ω))).trans |
| calc |
| _ ≤ ∑ i ∈ Finset.range (r + 1), |
| (r.choose i : ℝ) * (A i * s n ^ i) * (B (r - i) * s n ^ (r - i)) := by |
| apply Finset.sum_le_sum |
| intro i hi |
| gcongr |
| · exact mul_nonneg (Nat.cast_nonneg _) (mul_nonneg (hA i) (pow_nonneg (hs n) _)) |
| · exact hfa i n x |
| · exact hgb (r - i) n x |
| _ = C * s n ^ r := by |
| rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro i hi |
| have hir : i ≤ r := by simpa using Finset.mem_range.mp hi |
| rw [show (r.choose i : ℝ) * (A i * s n ^ i) * (B (r - i) * s n ^ (r - i)) = |
| ((r.choose i : ℝ) * A i * B (r - i)) * (s n ^ i * s n ^ (r - i)) by ring, |
| ← pow_add, Nat.add_sub_of_le hir] |
| |
| lemma ScaledJets.sum {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {ι : Type*} |
| (I : Finset ι) (f : ι → ℕ → E → F) (hf : ∀ i ∈ I, ScaledJets s (f i)) : |
| ScaledJets s (fun n x => ∑ i ∈ I, f i n x) := by |
| classical |
| induction I using Finset.induction_on with |
| | empty => simpa using ScaledJets.const hs (fun _ => (0 : F)) 0 le_rfl (by simp) |
| | @insert a I ha ih => |
| simpa only [Finset.sum_insert ha] using |
| (hf a (Finset.mem_insert_self _ _)).add (ih (fun i hi => hf i (Finset.mem_insert_of_mem hi))) |
| |
| lemma ScaledJets.ite {s : ℕ → ℝ} {f g : ℕ → E → F} (hs : ∀ n, 0 ≤ s n) |
| (hf : ScaledJets s f) (hg : ScaledJets s g) (p : ℕ → Prop) [DecidablePred p] : |
| ScaledJets s (fun n => if p n then f n else g n) := by |
| refine ⟨fun n => by dsimp only; split_ifs <;> [exact hf.1 n; exact hg.1 n], fun r => ?_⟩ |
| obtain ⟨A, hA, hfa⟩ := hf.2 r |
| obtain ⟨B, hB, hgb⟩ := hg.2 r |
| refine ⟨max A B, le_trans hA (le_max_left _ _), fun n x => ?_⟩ |
| dsimp only |
| split_ifs |
| · exact (hfa n x).trans (mul_le_mul_of_nonneg_right (le_max_left _ _) (pow_nonneg (hs n) _)) |
| · exact (hgb n x).trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (pow_nonneg (hs n) _)) |
| |
| lemma ScaledJets.comp {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f : ℕ → E → F} |
| (hf : ScaledJets s f) {g : F → G} (hg : BoundedJets g) : |
| ScaledJets s (fun n => g ∘ f n) := by |
| classical |
| refine ⟨fun n => hg.1.comp (hf.1 n), fun r => ?_⟩ |
| choose A hA hfa using hf.2 |
| choose B hB hgb using hg.2 |
| let D : ℝ := 1 + ∑ i ∈ Finset.range (r + 1), A i |
| let C : ℝ := ∑ i ∈ Finset.range (r + 1), B i |
| have hD : 1 ≤ D := le_add_of_nonneg_right (Finset.sum_nonneg (fun i _ => hA i)) |
| have hC : 0 ≤ C := Finset.sum_nonneg (fun i _ => hB i) |
| refine ⟨r.factorial * C * D ^ r, by positivity, fun n x => ?_⟩ |
| have h := norm_iteratedFDeriv_comp_le hg.1 (hf.1 n) (WithTop.coe_le_coe.mpr le_top : (r : ℕ∞ω) ≤ (∞ : ℕ∞ω)) x |
| (C := C) (D := D * s n) ?_ ?_ |
| · simpa only [mul_pow, mul_assoc] using h |
| · intro i hi |
| exact (hgb i (f n x)).trans (Finset.single_le_sum (fun i _ => hB i) |
| (Finset.mem_range.mpr (by omega))) |
| · intro i hi hir |
| have hai : A i ≤ D := by |
| have := Finset.single_le_sum (s := Finset.range (r + 1)) (f := A) |
| (fun i _ => hA i) (Finset.mem_range.mpr (by omega : i < r + 1)) |
| dsimp [D]; linarith |
| have hai' : A i ≤ D ^ i := hai.trans (le_self_pow₀ hD (by omega)) |
| calc |
| ‖iteratedFDeriv ℝ i (f n) x‖ ≤ A i * s n ^ i := hfa i n x |
| _ ≤ D ^ i * s n ^ i := mul_le_mul_of_nonneg_right hai' (pow_nonneg (hs n) _) |
| _ = (D * s n) ^ i := (mul_pow _ _ _).symm |
| |
| lemma norm_comp_linear (f : E → F) (hf : ContDiff ℝ ∞ f) (L : G →L[ℝ] E) |
| (r : ℕ) (x : G) : |
| ‖iteratedFDeriv ℝ r (f ∘ L) x‖ ≤ ‖iteratedFDeriv ℝ r f (L x)‖ * ‖L‖ ^ r := by |
| rw [L.iteratedFDeriv_comp_right hf x (WithTop.coe_le_coe.mpr le_top)] |
| simpa using (iteratedFDeriv ℝ r f (L x)).norm_compContinuousLinearMap_le (fun _ => L) |
| |
| lemma ScaledJets.comp_linear {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f : ℕ → E → F} |
| (hf : ScaledJets s f) (L : ℕ → G →L[ℝ] E) (B : ℝ) (hB : 0 ≤ B) |
| (hL : ∀ n, ‖L n‖ ≤ B) : ScaledJets s (fun n => f n ∘ L n) := by |
| refine ⟨fun n => (hf.1 n).comp (L n).contDiff, fun r => ?_⟩ |
| obtain ⟨C, hC, hc⟩ := hf.2 r |
| refine ⟨C * B ^ r, by positivity, fun n x => ?_⟩ |
| apply (norm_comp_linear (f n) (hf.1 n) (L n) r x).trans |
| calc |
| _ ≤ (C * s n ^ r) * B ^ r := by |
| gcongr |
| · exact mul_nonneg hC (pow_nonneg (hs n) _) |
| · exact hc n _ |
| · exact hL n |
| _ = _ := by ring |
| |
| lemma BoundedJets.comp_scaled_linear {s : ℕ → ℝ} (_hs : ∀ n, 0 ≤ s n) {f : E → F} |
| (hf : BoundedJets f) (L : ℕ → G →L[ℝ] E) (B : ℝ) (hB : 0 ≤ B) |
| (hL : ∀ n, ‖L n‖ ≤ B * s n) : ScaledJets s (fun n => f ∘ L n) := by |
| refine ⟨fun n => hf.1.comp (L n).contDiff, fun r => ?_⟩ |
| obtain ⟨C, hC, hc⟩ := hf.2 r |
| refine ⟨C * B ^ r, by positivity, fun n x => ?_⟩ |
| apply (norm_comp_linear f hf.1 (L n) r x).trans |
| calc |
| _ ≤ C * (B * s n) ^ r := by gcongr; exact hc _; exact hL n |
| _ = _ := by ring |
| |
| lemma ScaledJets.constant {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) (a : F) : |
| ScaledJets s (fun _ (_ : E) => a) := |
| ScaledJets.const hs (fun _ => a) ‖a‖ (norm_nonneg _) (fun _ => le_rfl) |
| |
| lemma ScaledJets.cmul {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f : ℕ → E → ℝ} |
| (hf : ScaledJets s f) (a : ℕ → ℝ) (B : ℝ) (hB : 0 ≤ B) (ha : ∀ n, |a n| ≤ B) : |
| ScaledJets s (fun n x => a n * f n x) := hf.smul hs a B hB ha |
| |
| lemma ScaledJets.const_mul {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f : ℕ → E → ℝ} |
| (hf : ScaledJets s f) (a : ℝ) : ScaledJets s (fun n x => a * f n x) := |
| hf.cmul hs (fun _ => a) |a| (abs_nonneg _) (fun _ => le_rfl) |
| |
| lemma ScaledJets.div_const {s : ℕ → ℝ} (hs : ∀ n, 0 ≤ s n) {f : ℕ → E → ℝ} |
| (hf : ScaledJets s f) (a : ℝ) : ScaledJets s (fun n x => f n x / a) := |
| (hf.const_mul hs a⁻¹).congr (fun _ _ => by simp [div_eq_mul_inv, mul_comm]) |
| |
| lemma decoder_bounded (b : ℕ) (hb : 2 ≤ b) : BoundedJets (Profiles.decoder b) := by |
| refine ⟨Profiles.decoder_smooth b hb, fun r => ?_⟩ |
| obtain ⟨C, hC, hc⟩ := Profiles.decoder_derivatives_bounded b hb r |
| exact ⟨C, hC, fun x => by simpa only [norm_iteratedFDeriv_eq_norm_iteratedDeriv, |
| Real.norm_eq_abs] using hc x⟩ |
| |
| lemma selector_bounded (b a : ℕ) (hb : 0 < b) : BoundedJets (Profiles.selector b a) := by |
| apply compact_bounded _ (Profiles.selector_smooth b a) |
| have hb' : (0 : ℝ) < b := by exact_mod_cast hb |
| apply IsCompact.of_isClosed_subset |
| (isCompact_Icc (a := (2 * (a : ℝ) - 1 / 4) / b) (b := (2 * (a : ℝ) + 5 / 4) / b)) |
| isClosed_closure |
| apply closure_minimal _ isClosed_Icc |
| intro x hx |
| obtain ⟨h₁, h₂⟩ := Profiles.selector_support_bound b a x hx |
| exact ⟨(div_le_iff₀ hb').mpr (by nlinarith), (le_div_iff₀ hb').mpr (by nlinarith)⟩ |
|
|
| def readScale (M : Machine) (N n : ℕ) : ℝ := |
| (M.base : ℝ) ^ (Scales.s N n + 1 + Scales.K N n) |
|
|
| lemma readScale_ge_one (M : Machine) (N n : ℕ) : 1 ≤ readScale M N n := |
| one_le_pow₀ (by have := M.base_ge_four; exact_mod_cast (by omega : 1 ≤ M.base)) |
|
|
| lemma readScale_nonneg (M : Machine) (N n : ℕ) : 0 ≤ readScale M N n := |
| le_trans zero_le_one (readScale_ge_one M N n) |
|
|
| lemma inverse_power_bound (M : Machine) (k : ℕ) : |((M.base : ℝ) ^ k)⁻¹| ≤ 1 := by |
| have hb : (1 : ℝ) ≤ M.base := by have := M.base_ge_four; exact_mod_cast (by omega : 1 ≤ M.base) |
| rw [abs_of_nonneg (by positivity)] |
| exact inv_le_one_of_one_le₀ (one_le_pow₀ hb) |
|
|
| lemma scaled_decoder (M : Machine) (N : ℕ) (k : ℕ → ℕ) |
| (hk : ∀ n, k n ≤ Scales.s N n + 1 + Scales.K N n) : |
| ScaledJets (readScale M N) (fun n D => Profiles.decoder M.base ((M.base : ℝ) ^ k n * D)) := by |
| have hb : (1 : ℝ) ≤ M.base := by have := M.base_ge_four; exact_mod_cast (by omega : 1 ≤ M.base) |
| refine (decoder_bounded M.base (by have := M.base_ge_four; omega)).comp_scaled_linear |
| (readScale_nonneg M N) (fun n => (M.base : ℝ) ^ k n • ContinuousLinearMap.id ℝ ℝ) |
| 1 zero_le_one ?_ |
| intro n |
| simpa only [norm_smul, Real.norm_eq_abs, abs_of_nonneg (pow_nonneg (le_trans zero_le_one hb) _), |
| ContinuousLinearMap.norm_id, mul_one, one_mul, readScale] using pow_le_pow_right₀ hb (hk n) |
|
|
| lemma readC_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (LocalRule.readC M N) := by |
| exact scaled_decoder M N (Scales.s N) (fun _ => by omega) |
|
|
| lemma readB_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (LocalRule.readB M N) := by |
| exact scaled_decoder M N (fun n => Scales.s N n + 1 + Scales.K N n) (fun _ => le_rfl) |
|
|
| lemma readA_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (LocalRule.readA M N) := by |
| exact (scaled_decoder M N (fun n => Scales.s N n + 1) (fun _ => by omega)).sub |
| ((readB_scaled M N).cmul (readScale_nonneg M N) _ 1 zero_le_one |
| (fun n => inverse_power_bound M _)) |
|
|
| lemma updateLeft_scaled (M : Machine) (N a l : ℕ) (r : Rule) : |
| ScaledJets (readScale M N) (fun n D => |
| LocalRule.updateLeft M.base a l r (LocalRule.readA M N n D) (LocalRule.readB M N n D)) := by |
| unfold LocalRule.updateLeft |
| split_ifs |
| · exact ((readA_scaled M N).const_mul (readScale_nonneg M N) _).sub |
| (ScaledJets.constant (readScale_nonneg M N) _) |
| · exact readA_scaled M N |
| · exact ((ScaledJets.constant (readScale_nonneg M N) _).add (readA_scaled M N)).div_const |
| (readScale_nonneg M N) _ |
|
|
| lemma updateRight_scaled (M : Machine) (N a l : ℕ) (r : Rule) : |
| ScaledJets (readScale M N) (fun n D => |
| LocalRule.updateRight M.base a l r (LocalRule.readA M N n D) (LocalRule.readB M N n D)) := by |
| have hR := ((readB_scaled M N).const_mul (readScale_nonneg M N) (M.base : ℝ)).sub |
| (ScaledJets.constant (readScale_nonneg M N) (2 * (a : ℝ))) |
| unfold LocalRule.updateRight |
| dsimp only |
| split_ifs |
| · exact ((ScaledJets.constant (readScale_nonneg M N) _).add |
| (((ScaledJets.constant (readScale_nonneg M N) _).add hR).div_const |
| (readScale_nonneg M N) _)).div_const (readScale_nonneg M N) _ |
| · exact ((ScaledJets.constant (readScale_nonneg M N) _).add hR).div_const |
| (readScale_nonneg M N) _ |
| · exact hR |
|
|
| lemma branchNumerator_scaled (M : Machine) (N a l : ℕ) (r : Rule) : |
| ScaledJets (readScale M N) (fun n D => LocalRule.branchNumerator M.base |
| (Scales.K N (n + 1)) a l r (LocalRule.readA M N n D) (LocalRule.readB M N n D)) := by |
| exact ((ScaledJets.constant (readScale_nonneg M N) _).add (updateLeft_scaled M N a l r)).add |
| ((updateRight_scaled M N a l r).cmul (readScale_nonneg M N) _ 1 zero_le_one |
| (fun n => inverse_power_bound M _)) |
|
|
| lemma branch_scaled (M : Machine) (N q a : ℕ) : |
| ScaledJets (readScale M N) (fun n D => |
| LocalRule.branch M N n q a (LocalRule.readA M N n D) (LocalRule.readB M N n D)) := by |
| classical |
| unfold LocalRule.branch |
| dsimp only |
| split_ifs |
| · exact ScaledJets.sum (readScale_nonneg M N) _ _ (fun l _ => |
| ((readA_scaled M N).comp (readScale_nonneg M N) |
| (selector_bounded M.base l (by have := M.base_ge_four; omega))).mul |
| (readScale_nonneg M N) (branchNumerator_scaled M N a l _)) |
| · exact branchNumerator_scaled M N a 0 _ |
|
|
| def writeCore (M : Machine) (N n : ℕ) (D : ℝ) : ℝ := |
| (1 / (M.base : ℝ)) * |
| ∑ q ∈ Finset.range (M.states + 1), ∑ a ∈ Finset.range M.alphabet, |
| Profiles.selector M.base q (LocalRule.readC M N n D) * |
| Profiles.selector M.base a (LocalRule.readB M N n D) * |
| LocalRule.branch M N n q a (LocalRule.readA M N n D) (LocalRule.readB M N n D) |
|
|
| lemma writeCore_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (writeCore M N) := by |
| classical |
| apply ScaledJets.const_mul (readScale_nonneg M N) |
| apply ScaledJets.sum (readScale_nonneg M N) |
| intro q _ |
| apply ScaledJets.sum (readScale_nonneg M N) |
| intro a _ |
| exact (((readC_scaled M N).comp (readScale_nonneg M N) |
| (selector_bounded M.base q (by have := M.base_ge_four; omega))).mul (readScale_nonneg M N) |
| ((readB_scaled M N).comp (readScale_nonneg M N) |
| (selector_bounded M.base a (by have := M.base_ge_four; omega)))).mul (readScale_nonneg M N) |
| (branch_scaled M N q a) |
|
|
| lemma write_factor (M : Machine) (N n : ℕ) (D : ℝ) : |
| LocalRule.write M N n D = Scales.ε M.base N (n + 1) * writeCore M N n D := by |
| unfold LocalRule.write writeCore |
| ring |
|
|
| lemma haltWeight_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (LocalRule.haltWeight M N) := by |
| classical |
| apply ScaledJets.sum (readScale_nonneg M N) |
| intro q _ |
| split_ifs |
| · exact (readC_scaled M N).comp (readScale_nonneg M N) |
| (selector_bounded M.base q (by have := M.base_ge_four; omega)) |
| · exact ScaledJets.constant (readScale_nonneg M N) _ |
|
|
| lemma ScaledJets.finite_family {s : ℕ → ℝ} (hs : ∀ n, 1 ≤ s n) {ι : Type*} [Fintype ι] |
| (f : ι → E → F) (hf : ∀ i, BoundedJets (f i)) (idx : ℕ → ι) : |
| ScaledJets s (fun n => f (idx n)) := by |
| classical |
| refine ⟨fun n => (hf (idx n)).1, fun r => ?_⟩ |
| choose C hC hc using fun i => (hf i).2 r |
| refine ⟨∑ i, C i, Finset.sum_nonneg (fun i _ => hC i), fun n x => ?_⟩ |
| exact ((hc (idx n) x).trans (Finset.single_le_sum (fun i _ => hC i) (Finset.mem_univ _))).trans |
| (le_mul_of_one_le_right (Finset.sum_nonneg (fun i _ => hC i)) (one_le_pow₀ (hs n))) |
|
|
| lemma norm_postcomp_linear (f : E → F) (hf : ContDiff ℝ ∞ f) (L : F →L[ℝ] G) |
| (r : ℕ) (x : E) : |
| ‖iteratedFDeriv ℝ r (L ∘ f) x‖ ≤ ‖L‖ * ‖iteratedFDeriv ℝ r f x‖ := by |
| rw [L.iteratedFDeriv_comp_left hf.contDiffAt (WithTop.coe_le_coe.mpr le_top)] |
| exact L.norm_compContinuousMultilinearMap_le _ |
|
|
| lemma norm_directional_iterated (f : E → F) (hf : ContDiff ℝ ∞ f) (v : E) |
| (r : ℕ) (x : E) : |
| ‖iteratedFDeriv ℝ r (fun x => fderiv ℝ f x v) x‖ ≤ |
| ‖v‖ * ‖iteratedFDeriv ℝ (r + 1) f x‖ := by |
| apply (norm_postcomp_linear _ (hf.fderiv_right (by simp)) |
| (ContinuousLinearMap.apply ℝ F v) r x).trans |
| rw [norm_iteratedFDeriv_fderiv] |
| gcongr |
| exact ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) (fun L => by |
| simpa only [ContinuousLinearMap.apply_apply, mul_comm] using L.le_opNorm v) |
|
|
| lemma norm_e (i : Fin 3) : ‖e i‖ = 1 := by simp [e] |
|
|
| lemma norm_iterated_curl (i j : Fin 3) (f : Space → ℝ) (hf : ContDiff ℝ ∞ f) |
| (r : ℕ) (x : Space) : |
| ‖iteratedFDeriv ℝ r (Spatial.curl i j f) x‖ ≤ 2 * ‖iteratedFDeriv ℝ (r + 1) f x‖ := by |
| have h (i j : Fin 3) : |
| ‖iteratedFDeriv ℝ r (fun x => Spatial.d j f x • e i) x‖ ≤ |
| ‖iteratedFDeriv ℝ (r + 1) f x‖ := by |
| apply (norm_postcomp_linear _ (Spatial.d_smooth j f hf) |
| ((ContinuousLinearMap.id ℝ ℝ).smulRight (e i)) r x).trans |
| have hn : ‖(ContinuousLinearMap.id ℝ ℝ).smulRight (e i)‖ ≤ 1 := |
| ContinuousLinearMap.opNorm_le_bound _ zero_le_one (fun a => by simp [norm_smul, norm_e]) |
| calc |
| _ ≤ 1 * (1 * ‖iteratedFDeriv ℝ (r + 1) f x‖) := by |
| gcongr |
| change ‖iteratedFDeriv ℝ r (fun x : Space => fderiv ℝ f x (e j)) x‖ ≤ _ |
| simpa only [norm_e] using norm_directional_iterated f hf (e j) r x |
| _ = _ := by ring |
| have hi (i j : Fin 3) : ContDiff ℝ ∞ (fun x => Spatial.d j f x • e i) := |
| (Spatial.d_smooth j f hf).smul contDiff_const |
| unfold Spatial.curl |
| rw [fun_iteratedFDeriv_sub_apply |
| ((hi i j).of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt |
| ((hi j i).of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt] |
| exact (norm_sub_le _ _).trans (by linarith [h i j, h j i]) |
|
|
| lemma cutoff_coordinate_bounded (i : Fin 3) : |
| BoundedJets (fun x : Space => Spatial.cutoff x * x i) := by |
| apply compact_bounded _ (Spatial.cutoff_smooth.mul (Spatial.coord_smooth i)) |
| exact Spatial.box_compact.of_isClosed_subset isClosed_closure |
| (tsupport_mul_subset_left.trans Spatial.cutoff_support) |
|
|
| lemma scaled_coord_comp (M : Machine) (N : ℕ) {f : ℕ → ℝ → ℝ} |
| (hf : ScaledJets (readScale M N) f) (idx : ℕ → Fin 3) : |
| ScaledJets (readScale M N) (fun n (x : Space) => f n (x (idx n))) := by |
| apply hf.comp_linear (readScale_nonneg M N) |
| (fun n => PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) (idx n)) 1 zero_le_one |
| intro n |
| apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one |
| intro x |
| simpa only [one_mul, PiLp.proj_apply] using PiLp.norm_apply_le x (idx n) |
|
|
| def fixedPotential (n : ℕ) (x : Space) : ℝ := |
| -(Spatial.cutoff x * x (Construction.receiverIndex n)) |
|
|
| def corePotential (M : Machine) (N n : ℕ) (x : Space) : ℝ := |
| (Spatial.cutoff x * x 0) * writeCore M N n (x (Construction.donorIndex n)) - |
| (Spatial.cutoff x * x (Construction.receiverIndex n)) * |
| (2 * LocalRule.haltWeight M N n (x (Construction.donorIndex n))) |
|
|
| lemma fixedPotential_scaled : ScaledJets (fun _ => 1) fixedPotential := by |
| have h := ScaledJets.finite_family (fun _ => le_rfl : ∀ _ : ℕ, (1 : ℝ) ≤ 1) |
| (fun i (x : Space) => Spatial.cutoff x * x i) cutoff_coordinate_bounded |
| Construction.receiverIndex |
| exact (h.const_mul (fun _ => zero_le_one) (-1)).congr (fun _ _ => by simp [fixedPotential]) |
|
|
| lemma corePotential_scaled (M : Machine) (N : ℕ) : |
| ScaledJets (readScale M N) (corePotential M N) := by |
| have h (idx : ℕ → Fin 3) := ScaledJets.finite_family (readScale_ge_one M N) |
| (fun i (x : Space) => Spatial.cutoff x * x i) cutoff_coordinate_bounded idx |
| exact ((h (fun _ => 0)).mul (readScale_nonneg M N) |
| (scaled_coord_comp M N (writeCore_scaled M N) Construction.donorIndex)).sub |
| ((h Construction.receiverIndex).mul (readScale_nonneg M N) |
| ((scaled_coord_comp M N (haltWeight_scaled M N) Construction.donorIndex).const_mul |
| (readScale_nonneg M N) 2)) |
|
|
| lemma potential_decomposition (M : Machine) (N n : ℕ) (x : Space) : |
| Spatial.cutoff x * Spatial.shearPotential (Construction.donorIndex n) |
| (Construction.receiverIndex n) 0 (LocalRule.write M N n) (LocalRule.signal M N n) x = |
| (Scales.ε M.base N n - Scales.ε M.base N (n + 1)) * fixedPotential n x + |
| Scales.ε M.base N (n + 1) * corePotential M N n x := by |
| unfold Spatial.shearPotential LocalRule.signal fixedPotential corePotential |
| rw [write_factor] |
| ring |
|
|
| lemma potential_bound (M : Machine) (N r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ n x, |
| ‖iteratedFDeriv ℝ r (fun x => Spatial.cutoff x * |
| Spatial.shearPotential (Construction.donorIndex n) (Construction.receiverIndex n) 0 |
| (LocalRule.write M N n) (LocalRule.signal M N n) x) x‖ ≤ |
| C * (Scales.ε M.base N n + Scales.ε M.base N (n + 1) * readScale M N n ^ r) := by |
| obtain ⟨A, hA, ha⟩ := fixedPotential_scaled.2 r |
| obtain ⟨B, hB, hb⟩ := (corePotential_scaled M N).2 r |
| refine ⟨A + B, add_nonneg hA hB, fun n x => ?_⟩ |
| have hε : 0 ≤ Scales.ε M.base N (n + 1) := Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega) |
| have hε' : Scales.ε M.base N (n + 1) ≤ Scales.ε M.base N n := |
| (Scales.ε_strictAnti M.base N (by have := M.base_ge_four; omega)).antitone (by omega) |
| have h₁ := fixedPotential_scaled.1 n |
| have h₂ := (corePotential_scaled M N).1 n |
| simp_rw [potential_decomposition] |
| change ‖iteratedFDeriv ℝ r (fun x => |
| (Scales.ε M.base N n - Scales.ε M.base N (n + 1)) • fixedPotential n x + |
| Scales.ε M.base N (n + 1) • corePotential M N n x) x‖ ≤ _ |
| have hs₁ : ContDiff ℝ ∞ (fun x => |
| (Scales.ε M.base N n - Scales.ε M.base N (n + 1)) • fixedPotential n x) := h₁.const_smul _ |
| have hs₂ : ContDiff ℝ ∞ (fun x => |
| Scales.ε M.base N (n + 1) • corePotential M N n x) := h₂.const_smul _ |
| rw [fun_iteratedFDeriv_add_apply |
| (hs₁.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt |
| (hs₂.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt] |
| apply (norm_add_le _ _).trans |
| rw [iteratedFDeriv_const_smul_apply' (h₁.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt, |
| iteratedFDeriv_const_smul_apply' (h₂.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt, |
| norm_smul, norm_smul, Real.norm_eq_abs, Real.norm_eq_abs, |
| abs_of_nonneg (sub_nonneg.mpr hε'), abs_of_nonneg hε] |
| have haa : ‖iteratedFDeriv ℝ r (fixedPotential n) x‖ ≤ A := by simpa using ha n x |
| have hbb := hb n x |
| have hscale := pow_nonneg (readScale_nonneg M N n) r |
| calc |
| _ ≤ Scales.ε M.base N n * A + |
| Scales.ε M.base N (n + 1) * (B * readScale M N n ^ r) := by |
| exact add_le_add |
| (mul_le_mul (by linarith) haa (norm_nonneg _) (by linarith)) |
| (mul_le_mul_of_nonneg_left hbb hε) |
| _ ≤ _ := by nlinarith [mul_nonneg (show 0 ≤ Scales.ε M.base N n by linarith) hB, |
| mul_nonneg hA (mul_nonneg hε hscale)] |
|
|
| theorem slot_estimate (M : Machine) (N r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ n x, |
| ‖iteratedFDeriv ℝ r (Construction.slot M N n) x‖ ≤ |
| C * (Scales.ε M.base N n + Scales.ε M.base N (n + 1) * readScale M N n ^ (r + 1)) := by |
| obtain ⟨C, hC, hc⟩ := potential_bound M N (r + 1) |
| refine ⟨2 * C, mul_nonneg (by norm_num) hC, fun n x => ?_⟩ |
| have h := norm_iterated_curl (Construction.receiverIndex n) 0 _ |
| (Spatial.cutoff_smooth.mul (Spatial.shearPotential_smooth (Construction.donorIndex n) |
| (Construction.receiverIndex n) 0 _ _ |
| (LocalRule.write_smooth M N n) (LocalRule.signal_smooth M N n))) r x |
| exact h.trans (by nlinarith [hc n x]) |
|
|
| lemma uniform_read_cost (M : Machine) (N r : ℕ) : ∃ D : ℝ, 0 ≤ D ∧ ∀ n, |
| Scales.ε M.base N (n + 1) * readScale M N n ^ (r + 1) ≤ D * Scales.ε M.base N n := by |
| classical |
| let q (n : ℕ) := Scales.ε M.base N (n + 1) * readScale M N n ^ (r + 1) / Scales.ε M.base N n |
| have hε (n : ℕ) : 0 < Scales.ε M.base N n := |
| Scales.ε_pos _ _ _ (by have := M.base_ge_four; omega) |
| have hq (n : ℕ) : 0 ≤ q n := div_nonneg |
| (mul_nonneg (hε _).le (pow_nonneg (readScale_nonneg M N n) _)) (hε _).le |
| let D := 1 + ∑ n ∈ Finset.range r, q n |
| have hD : 1 ≤ D := le_add_of_nonneg_right (Finset.sum_nonneg (fun n _ => hq n)) |
| refine ⟨D, zero_le_one.trans hD, fun n => ?_⟩ |
| by_cases hn : n < r |
| · apply (div_le_iff₀ (hε n)).mp |
| exact (Finset.single_le_sum (fun n _ => hq n) (Finset.mem_range.mpr hn)).trans |
| (by dsimp [D]; linarith) |
| · have h := Scales.derivative_cost_bound M.base N r n (by have := M.base_ge_four; omega) |
| (by omega) |
| have he : readScale M N n ^ (r + 1) = |
| (M.base : ℝ) ^ ((r + 1) * (Scales.s N n + 1 + Scales.K N n)) := by |
| rw [readScale, ← pow_mul, Nat.mul_comm] |
| rw [he] |
| exact h.trans (le_mul_of_one_le_left (hε n).le hD) |
|
|
| theorem slot_decay (M : Machine) (N r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ n x, |
| ‖iteratedFDeriv ℝ r (Construction.slot M N n) x‖ ≤ C * Scales.ε M.base N n := by |
| obtain ⟨C, hC, hc⟩ := slot_estimate M N r |
| obtain ⟨D, hD, hd⟩ := uniform_read_cost M N r |
| refine ⟨C * (1 + D), by positivity, fun n x => (hc n x).trans ?_⟩ |
| have := mul_le_mul_of_nonneg_left (hd n) hC |
| nlinarith |
|
|
| def amplitude (M : Machine) (N : ℕ) : ℕ → ℝ |
| | 0 => 1 |
| | n + 1 => Scales.ε M.base N n |
|
|
| lemma amplitude_nonneg (M : Machine) (N n : ℕ) : 0 ≤ amplitude M N n := by |
| cases n with |
| | zero => exact zero_le_one |
| | succ n => exact Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega) |
|
|
| lemma weighted_amplitude_summable (M : Machine) (N J : ℕ) : |
| Summable (fun n : ℕ => (1 + (n : ℝ)) ^ J * amplitude M N n) := by |
| apply (summable_nat_add_iff 1).mp |
| apply Summable.of_nonneg_of_le (fun n => mul_nonneg (by positivity) (amplitude_nonneg M N _)) _ |
| ((Scales.summable_weighted_ε M.base N J (by have := M.base_ge_four; omega)).mul_left ((2 : ℝ) ^ J)) |
| intro n |
| simp only [amplitude, Nat.cast_add, Nat.cast_one] |
| calc |
| (1 + ((n : ℝ) + 1)) ^ J * Scales.ε M.base N n ≤ |
| (2 * (1 + (n : ℝ))) ^ J * Scales.ε M.base N n := by |
| apply mul_le_mul_of_nonneg_right _ (Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega)) |
| exact pow_le_pow_left₀ (by positivity) (by nlinarith) _ |
| _ = _ := by rw [mul_pow]; ring |
|
|
| lemma piece_decay (M : Machine) (w : List ℕ) (r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ n x, |
| ‖iteratedFDeriv ℝ r (Construction.piece M w n) x‖ ≤ C * amplitude M w.length n := by |
| have hload := compact_bounded (Construction.loading M w) (Construction.loading_smooth M w) |
| (Spatial.box_compact.of_isClosed_subset isClosed_closure (Construction.piece_support M w 0)) |
| obtain ⟨A, hA, ha⟩ := hload.2 r |
| obtain ⟨B, hB, hb⟩ := slot_decay M w.length r |
| refine ⟨max A B, hA.trans (le_max_left _ _), fun n x => ?_⟩ |
| cases n with |
| | zero => |
| change ‖iteratedFDeriv ℝ r (Construction.loading M w) x‖ ≤ max A B * 1 |
| simpa only [mul_one] using (ha x).trans (le_max_left A B) |
| | succ n => exact (hb n x).trans (mul_le_mul_of_nonneg_right (le_max_right A B) |
| (Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega))) |
|
|
| lemma pulse_bounded : BoundedJets Profiles.pulse := by |
| apply compact_bounded _ Profiles.pulse_smooth |
| apply IsCompact.of_isClosed_subset (isCompact_Icc (a := (0 : ℝ)) (b := 1)) isClosed_closure |
| apply closure_minimal _ isClosed_Icc |
| intro t ht |
| exact ⟨le_of_not_gt (fun h => ht (Profiles.pulse_zero_left t h.le)), |
| le_of_not_gt (fun h => ht (Profiles.pulse_zero_right t h.le))⟩ |
|
|
| def pulsePiece (M : Machine) (w : List ℕ) (n : ℕ) (z : ℝ × Space) : Space := |
| Profiles.pulse (z.1 - n) • Construction.piece M w n z.2 |
|
|
| lemma pulsePiece_smooth (M : Machine) (w : List ℕ) (n : ℕ) : |
| ContDiff ℝ ∞ (pulsePiece M w n) := |
| (Profiles.pulse_smooth.comp (contDiff_fst.sub contDiff_const)).fun_smul |
| ((Construction.piece_smooth M w n).comp contDiff_snd) |
|
|
| lemma pulsePiece_decay (M : Machine) (w : List ℕ) (r : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ n z, |
| ‖iteratedFDeriv ℝ r (pulsePiece M w n) z‖ ≤ C * amplitude M w.length n := by |
| classical |
| choose A hA ha using pulse_bounded.2 |
| choose B hB hb using piece_decay M w |
| let C := ∑ i ∈ Finset.range (r + 1), (r.choose i : ℝ) * A i * B (r - i) |
| refine ⟨C, Finset.sum_nonneg (fun i _ => mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (hA i)) (hB _)), |
| fun n z => ?_⟩ |
| have hp (i : ℕ) : |
| ‖iteratedFDeriv ℝ i (fun z : ℝ × Space => Profiles.pulse (z.1 - n)) z‖ ≤ A i := by |
| apply (norm_comp_linear (fun t => Profiles.pulse (t - n)) |
| (Profiles.pulse_smooth.comp (contDiff_id.sub contDiff_const)) (ContinuousLinearMap.fst ℝ ℝ Space) |
| i z).trans |
| rw [iteratedFDeriv_comp_sub] |
| have h₁ := ha i (z.1 - n) |
| have h₂ := pow_le_pow_left₀ (norm_nonneg _) (ContinuousLinearMap.norm_fst_le ℝ ℝ Space) i |
| simpa only [one_pow, mul_one, ContinuousLinearMap.coe_fst', ContinuousLinearMap.coe_snd'] using mul_le_mul h₁ h₂ (pow_nonneg (norm_nonneg _) _) (hA i) |
| have hw (i : ℕ) : |
| ‖iteratedFDeriv ℝ i (fun z : ℝ × Space => Construction.piece M w n z.2) z‖ ≤ |
| B i * amplitude M w.length n := by |
| apply (norm_comp_linear (Construction.piece M w n) (Construction.piece_smooth M w n) |
| (ContinuousLinearMap.snd ℝ ℝ Space) i z).trans |
| have h₁ := hb i n z.2 |
| have h₂ := pow_le_pow_left₀ (norm_nonneg _) (ContinuousLinearMap.norm_snd_le ℝ ℝ Space) i |
| simpa only [one_pow, mul_one, ContinuousLinearMap.coe_fst', ContinuousLinearMap.coe_snd'] using mul_le_mul h₁ h₂ (pow_nonneg (norm_nonneg _) _) |
| (mul_nonneg (hB i) (amplitude_nonneg M w.length n)) |
| apply (norm_iteratedFDeriv_smul_le |
| (Profiles.pulse_smooth.comp (contDiff_fst.sub contDiff_const)) |
| ((Construction.piece_smooth M w n).comp contDiff_snd) z (WithTop.coe_le_coe.mpr le_top)).trans |
| calc |
| _ ≤ ∑ i ∈ Finset.range (r + 1), (r.choose i : ℝ) * A i * (B (r - i) * amplitude M w.length n) := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply mul_le_mul _ (hw (r - i)) (norm_nonneg _) (mul_nonneg (Nat.cast_nonneg _) (hA i)) |
| exact mul_le_mul_of_nonneg_left (hp i) (Nat.cast_nonneg _) |
| _ = C * amplitude M w.length n := by simp only [C, Finset.sum_mul, mul_assoc] |
|
|
| def RapidJets (f : ℝ × Space → F) : Prop := |
| ContDiff ℝ ∞ f ∧ ∀ J r : ℕ, ∃ C : ℝ, 0 ≤ C ∧ |
| ∀ z, 0 ≤ z.1 → (1 + z.1 + ‖z.2‖) ^ J * ‖iteratedFDeriv ℝ r f z‖ ≤ C |
|
|
| lemma box_norm (x : Space) (hx : x ∈ Spatial.box) : ‖x‖ ≤ 9 := by |
| have hi (i : Fin 3) : ‖x.ofLp i‖ ^ 2 ≤ 9 := by |
| have := hx i |
| rw [Real.norm_eq_abs] |
| nlinarith [abs_nonneg (x i)] |
| have hsum := Finset.sum_le_sum (s := Finset.univ) (fun i _ => hi i) |
| rw [← PiLp.norm_sq_eq_of_L2] at hsum |
| norm_num at hsum |
| nlinarith [norm_nonneg x] |
|
|
| lemma pulsePiece_support (M : Machine) (w : List ℕ) (n : ℕ) : |
| tsupport (pulsePiece M w n) ⊆ Set.Icc (n : ℝ) (n + 1) ×ˢ Spatial.box := by |
| apply closure_minimal _ (isClosed_Icc.prod Spatial.isClosed_box) |
| intro z hz |
| have h₁ : Profiles.pulse (z.1 - n) ≠ 0 := fun h => hz (by simp [pulsePiece, h]) |
| have h₂ : Construction.piece M w n z.2 ≠ 0 := fun h => hz (by simp [pulsePiece, h]) |
| refine ⟨⟨?_, ?_⟩, Construction.piece_support M w n (subset_closure h₂)⟩ |
| · exact le_of_not_gt (fun h => h₁ (Profiles.pulse_zero_left _ (by linarith))) |
| · exact le_of_not_gt (fun h => h₁ (Profiles.pulse_zero_right _ (by linarith))) |
|
|
| lemma pulsePiece_weighted (M : Machine) (w : List ℕ) (J r : ℕ) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ n z, 0 ≤ z.1 → |
| (1 + z.1 + ‖z.2‖) ^ J * ‖iteratedFDeriv ℝ r (pulsePiece M w n) z‖ ≤ |
| C * (1 + (n : ℝ)) ^ J * amplitude M w.length n := by |
| obtain ⟨C, hC, hc⟩ := pulsePiece_decay M w r |
| refine ⟨11 ^ J * C, by positivity, fun n z ht => ?_⟩ |
| by_cases hz : z ∈ tsupport (iteratedFDeriv ℝ r (pulsePiece M w n)) |
| · have hsupport := pulsePiece_support M w n (tsupport_iteratedFDeriv_subset r hz) |
| have hn : 0 ≤ (n : ℝ) := Nat.cast_nonneg n |
| have hw : (1 + z.1 + ‖z.2‖) ^ J ≤ (11 * (1 + (n : ℝ))) ^ J := |
| pow_le_pow_left₀ (by positivity) (by linarith [hsupport.1.2, box_norm z.2 hsupport.2]) _ |
| calc |
| _ ≤ (11 * (1 + (n : ℝ))) ^ J * (C * amplitude M w.length n) := |
| mul_le_mul hw (hc n z) (norm_nonneg _) (by positivity) |
| _ = _ := by rw [mul_pow]; ring |
| · rw [image_eq_zero_of_notMem_tsupport hz, norm_zero, mul_zero] |
| exact mul_nonneg (mul_nonneg (mul_nonneg (by positivity) hC) (by positivity)) |
| (amplitude_nonneg M w.length n) |
|
|
| theorem velocity_rapidJets (M : Machine) (w : List ℕ) : |
| RapidJets (Function.uncurry (Construction.velocity M w)) := by |
| classical |
| refine ⟨Construction.velocity_smooth M w, fun J r => ?_⟩ |
| obtain ⟨C, hC, hc⟩ := pulsePiece_weighted M w J r |
| let a : ℕ → ℝ := fun n => C * ((1 + (n : ℝ)) ^ J * amplitude M w.length n) |
| have has : Summable a := (weighted_amplitude_summable M w.length J).mul_left C |
| have ha : ∀ n, 0 ≤ a n := fun n => mul_nonneg hC |
| (mul_nonneg (by positivity) (amplitude_nonneg M w.length n)) |
| refine ⟨∑' n, a n, tsum_nonneg ha, fun z ht => ?_⟩ |
| obtain ⟨N, hN⟩ := TimeGlue.locally_eq_sum Profiles.pulse Profiles.pulse_zero_left |
| (Construction.piece M w) z |
| change Function.uncurry (Construction.velocity M w) =ᶠ[𝓝 z] |
| (fun z => ∑ n ∈ Finset.range N, pulsePiece M w n z) at hN |
| rw [(hN.iteratedFDeriv ℝ r).eq_of_nhds, |
| iteratedFDeriv_fun_sum_apply (fun n _ => (pulsePiece_smooth M w n).of_le |
| (WithTop.coe_le_coe.mpr le_top) |>.contDiffAt)] |
| calc |
| _ ≤ (1 + z.1 + ‖z.2‖) ^ J * ∑ n ∈ Finset.range N, |
| ‖iteratedFDeriv ℝ r (pulsePiece M w n) z‖ := |
| mul_le_mul_of_nonneg_left (norm_sum_le _ _) (by positivity) |
| _ ≤ ∑ n ∈ Finset.range N, a n := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro n _ |
| simpa only [a, mul_assoc] using hc n z ht |
| _ ≤ _ := has.sum_le_tsum _ (fun n _ => ha n) |
| |
| lemma RapidJets.congr {f g : ℝ × Space → F} (hf : RapidJets f) (he : ∀ z, f z = g z) : |
| RapidJets g := by rwa [← funext he] |
| |
| lemma RapidJets.add {f g : ℝ × Space → F} (hf : RapidJets f) (hg : RapidJets g) : |
| RapidJets (fun z => f z + g z) := by |
| refine ⟨hf.1.add hg.1, fun J r => ?_⟩ |
| obtain ⟨A, hA, ha⟩ := hf.2 J r |
| obtain ⟨B, hB, hb⟩ := hg.2 J r |
| refine ⟨A + B, add_nonneg hA hB, fun z hz => ?_⟩ |
| rw [fun_iteratedFDeriv_add_apply (hf.1.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt |
| (hg.1.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt] |
| calc |
| _ ≤ (1 + z.1 + ‖z.2‖) ^ J * |
| (‖iteratedFDeriv ℝ r f z‖ + ‖iteratedFDeriv ℝ r g z‖) := |
| mul_le_mul_of_nonneg_left (norm_add_le _ _) (by positivity) |
| _ ≤ A + B := by rw [mul_add]; exact add_le_add (ha z hz) (hb z hz) |
| |
| lemma RapidJets.linear {f : ℝ × Space → F} (hf : RapidJets f) (L : F →L[ℝ] G) : |
| RapidJets (L ∘ f) := by |
| refine ⟨L.contDiff.comp hf.1, fun J r => ?_⟩ |
| obtain ⟨A, hA, ha⟩ := hf.2 J r |
| refine ⟨‖L‖ * A, by positivity, fun z hz => ?_⟩ |
| calc |
| _ ≤ (1 + z.1 + ‖z.2‖) ^ J * (‖L‖ * ‖iteratedFDeriv ℝ r f z‖) := |
| mul_le_mul_of_nonneg_left (norm_postcomp_linear f hf.1 L r z) (by positivity) |
| _ = ‖L‖ * ((1 + z.1 + ‖z.2‖) ^ J * ‖iteratedFDeriv ℝ r f z‖) := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left (ha z hz) (norm_nonneg _) |
| |
| lemma RapidJets.const_smul {f : ℝ × Space → F} (hf : RapidJets f) (a : ℝ) : |
| RapidJets (fun z => a • f z) := hf.linear (a • ContinuousLinearMap.id ℝ F) |
| |
| lemma RapidJets.sub {f g : ℝ × Space → F} (hf : RapidJets f) (hg : RapidJets g) : |
| RapidJets (fun z => f z - g z) := by |
| simpa only [neg_one_smul, sub_eq_add_neg] using hf.add (hg.const_smul (-1)) |
| |
| lemma RapidJets.zero : RapidJets (fun _ : ℝ × Space => (0 : F)) := by |
| refine ⟨contDiff_const, fun J r => ⟨0, le_rfl, fun z _ => ?_⟩⟩ |
| simp |
| |
| lemma RapidJets.sum {ι : Type*} (s : Finset ι) (f : ι → ℝ × Space → F) |
| (hf : ∀ i ∈ s, RapidJets (f i)) : RapidJets (fun z => ∑ i ∈ s, f i z) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simpa using (RapidJets.zero : RapidJets (fun _ => (0 : F))) |
| | @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))) |
| |
| lemma RapidJets.directional {f : ℝ × Space → F} (hf : RapidJets f) (v : ℝ × Space) : |
| RapidJets (fun z => fderiv ℝ f z v) := by |
| refine ⟨(hf.1.fderiv_right (by simp)).clm_apply contDiff_const, fun J r => ?_⟩ |
| obtain ⟨A, hA, ha⟩ := hf.2 J (r + 1) |
| refine ⟨‖v‖ * A, by positivity, fun z hz => ?_⟩ |
| calc |
| _ ≤ (1 + z.1 + ‖z.2‖) ^ J * (‖v‖ * ‖iteratedFDeriv ℝ (r + 1) f z‖) := |
| mul_le_mul_of_nonneg_left (norm_directional_iterated f hf.1 v r z) (by positivity) |
| _ = ‖v‖ * ((1 + z.1 + ‖z.2‖) ^ J * ‖iteratedFDeriv ℝ (r + 1) f z‖) := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left (ha z hz) (norm_nonneg _) |
| |
| lemma dx_eq_full_directional (F : Field E) (hf : ContDiff ℝ ∞ (Function.uncurry F)) |
| (i : Fin 3) (z : ℝ × Space) : |
| dx i F z.1 z.2 = fderiv ℝ (Function.uncurry F) z (0, e i) := by |
| have h₁ : HasFDerivAt (fun x : Space => (z.1, x)) |
| ((0 : Space →L[ℝ] ℝ).prod (ContinuousLinearMap.id ℝ Space)) z.2 := |
| (hasFDerivAt_const z.1 z.2).prodMk (hasFDerivAt_id z.2) |
| have hh := (hf.differentiable (by simp) (z.1,z.2)).hasFDerivAt.comp z.2 h₁ |
| have he := hh.fderiv |
| change fderiv ℝ (F z.1) z.2 = _ at he |
| rw [dx, he] |
| simp |
| |
| lemma fullDt_eq_full_directional (F : Field E) (hf : ContDiff ℝ ∞ (Function.uncurry F)) |
| (z : ℝ × Space) : |
| Analytic.fullDt F z.1 z.2 = fderiv ℝ (Function.uncurry F) z (1, 0) := by |
| have h₁ : HasFDerivAt (fun t : ℝ => (t, z.2)) |
| ((ContinuousLinearMap.id ℝ ℝ).prod (0 : ℝ →L[ℝ] Space)) z.1 := |
| (hasFDerivAt_id z.1).prodMk (hasFDerivAt_const z.2 z.1) |
| have hh := (hf.differentiable (by simp) (z.1,z.2)).hasFDerivAt.comp z.1 h₁ |
| have he := hh.fderiv |
| change fderiv ℝ (fun t => F t z.2) z.1 = _ at he |
| rw [Analytic.fullDt, he] |
| simp |
| |
| lemma RapidJets.dx {f : Field F} (hf : RapidJets (Function.uncurry f)) (i : Fin 3) : |
| RapidJets (Function.uncurry (dx i f)) := |
| (hf.directional (0, e i)).congr (fun z => (dx_eq_full_directional f hf.1 i z).symm) |
| |
| lemma RapidJets.fullDt {f : Field F} (hf : RapidJets (Function.uncurry f)) : |
| RapidJets (Function.uncurry (Analytic.fullDt f)) := |
| (hf.directional (1, 0)).congr (fun z => (fullDt_eq_full_directional f hf.1 z).symm) |
| |
| lemma RapidJets.smul {f : ℝ × Space → ℝ} {g : ℝ × Space → F} |
| (hf : RapidJets f) (hg : RapidJets g) : RapidJets (fun z => f z • g z) := by |
| classical |
| refine ⟨hf.1.fun_smul hg.1, fun J r => ?_⟩ |
| choose A hA ha using hf.2 J |
| choose B hB hb using hg.2 0 |
| let C := ∑ i ∈ Finset.range (r + 1), (r.choose i : ℝ) * A i * B (r - i) |
| refine ⟨C, Finset.sum_nonneg (fun i _ => mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (hA i)) (hB _)), |
| fun z hz => ?_⟩ |
| apply (mul_le_mul_of_nonneg_left (norm_iteratedFDeriv_smul_le hf.1 hg.1 z |
| (WithTop.coe_le_coe.mpr le_top)) (pow_nonneg (by positivity) J)).trans |
| rw [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro i _ |
| calc |
| _ = (r.choose i : ℝ) * ((1 + z.1 + ‖z.2‖) ^ J * ‖iteratedFDeriv ℝ i f z‖) * |
| ‖iteratedFDeriv ℝ (r - i) g z‖ := by ring |
| _ ≤ _ := mul_le_mul (mul_le_mul_of_nonneg_left (ha i z hz) (Nat.cast_nonneg _)) |
| (by simpa using hb (r - i) z hz) (norm_nonneg _) |
| (mul_nonneg (Nat.cast_nonneg _) (hA i)) |
| |
| lemma advection_eq_sum (u : Velocity) (t : ℝ) (x : Space) : |
| advection u t x = ∑ i : Fin 3, (u t x i) • dx i u t x := by |
| have he (v : Space) : v = ∑ i : Fin 3, v i • e i := by |
| ext j |
| simp [e, Finset.sum_apply, Pi.single_apply] |
| conv_lhs => unfold advection; rw [he (u t x)] |
| simp only [map_sum, map_smul, dx] |
| |
| lemma RapidJets.advection {f : Velocity} (hf : RapidJets (Function.uncurry f)) : |
| RapidJets (Function.uncurry (advection f)) := by |
| have h : ∀ i : Fin 3, RapidJets (fun z : ℝ × Space => f z.1 z.2 i • AlternatingNS.dx i f z.1 z.2) := |
| fun i => (hf.linear (PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) i)).smul (hf.dx i) |
| exact (RapidJets.sum Finset.univ _ (fun i _ => h i)).congr |
| (fun z => (advection_eq_sum f z.1 z.2).symm) |
| |
| lemma RapidJets.laplacian {f : Velocity} (hf : RapidJets (Function.uncurry f)) : |
| RapidJets (Function.uncurry (laplacian f)) := |
| RapidJets.sum Finset.univ _ (fun i _ => (hf.dx i).dx i) |
| |
| lemma RapidJets.fullResidual {f : Velocity} (hf : RapidJets (Function.uncurry f)) (ν : ℝ) : |
| RapidJets (fun z : ℝ × Space => Analytic.fullDt f z.1 z.2 + AlternatingNS.advection f z.1 z.2 - |
| ν • AlternatingNS.laplacian f z.1 z.2) := |
| (hf.fullDt.add hf.advection).sub (hf.laplacian.const_smul ν) |
| |
| def HalfEq (f g : Field F) : Prop := ∀ t, 0 ≤ t → ∀ x, f t x = g t x |
| |
| lemma HalfEq.dx {f g : Field F} (h : HalfEq f g) (i : Fin 3) : HalfEq (dx i f) (dx i g) := by |
| intro t ht x |
| have he : f t = g t := funext (h t ht) |
| simp only [AlternatingNS.dx, he] |
| |
| lemma HalfEq.dt {f g : Field F} (h : HalfEq f g) : HalfEq (dt f) (dt g) := by |
| intro t ht x |
| exact congrArg (fun L : ℝ →L[ℝ] F => L 1) |
| (fderivWithin_congr (fun u hu => h u hu x) (h t ht x)) |
| |
| lemma HalfEq.spatial {f g : Field F} (h : HalfEq f g) (α : MultiIndex) : |
| HalfEq (spatial α f) (spatial α g) := by |
| have hi (i : Fin 3) (n : ℕ) {u v : Field F} (hv : HalfEq u v) : |
| HalfEq ((AlternatingNS.dx i)^[n] u) ((AlternatingNS.dx i)^[n] v) := by |
| induction n with |
| | zero => exact hv |
| | succ n ih => |
| simpa only [Function.iterate_succ_apply'] using ih.dx i |
| exact hi 0 (α 0) (hi 1 (α 1) (hi 2 (α 2) h)) |
|
|
| lemma HalfEq.mixed {f g : Field F} (h : HalfEq f g) (l : ℕ) (α : MultiIndex) : |
| HalfEq (mixed l α f) (mixed l α g) := by |
| induction l with |
| | zero => exact h.spatial α |
| | succ l ih => simpa only [AlternatingNS.mixed, Function.iterate_succ_apply'] using ih.dt |
| |
| lemma RapidJets.spatial {f : Field F} (hf : RapidJets (Function.uncurry f)) (α : MultiIndex) : |
| RapidJets (Function.uncurry (spatial α f)) := by |
| have hi (i : Fin 3) (n : ℕ) {u : Field F} (hu : RapidJets (Function.uncurry u)) : |
| RapidJets (Function.uncurry ((AlternatingNS.dx i)^[n] u)) := by |
| induction n with |
| | zero => exact hu |
| | succ n ih => simpa only [Function.iterate_succ_apply'] using ih.dx i |
| exact hi 0 (α 0) (hi 1 (α 1) (hi 2 (α 2) hf)) |
|
|
| lemma fullDt_iterate {f : Field F} (hf : RapidJets (Function.uncurry f)) (l : ℕ) : |
| RapidJets (Function.uncurry (Analytic.fullDt^[l] f)) ∧ |
| HalfEq (dt^[l] f) (Analytic.fullDt^[l] f) := by |
| induction l with |
| | zero => exact ⟨hf, fun _ _ _ => rfl⟩ |
| | succ l ih => |
| rw [Function.iterate_succ_apply', Function.iterate_succ_apply'] |
| refine ⟨ih.1.fullDt, fun t ht x => ?_⟩ |
| exact (ih.2.dt t ht x).trans (Analytic.dt_eq_full _ ih.1.1 t ht x) |
|
|
| lemma RapidJets.rapid {f : Velocity} (hf : RapidJets (Function.uncurry f)) : Rapid f := by |
| intro J l α |
| obtain ⟨hG, he⟩ := fullDt_iterate (hf.spatial α) l |
| obtain ⟨C, hC, hc⟩ := hG.2 J 0 |
| refine ⟨C, hC, fun t ht x => ?_⟩ |
| rw [show mixed l α f t x = (Analytic.fullDt^[l] (AlternatingNS.spatial α f)) t x from he t ht x] |
| simpa only [norm_iteratedFDeriv_zero, Function.uncurry] using hc (t, x) ht |
|
|
| lemma Rapid.congr_half {f g : Velocity} (hf : Rapid f) (h : HalfEq f g) : Rapid g := by |
| intro J l α |
| obtain ⟨C, hC, hc⟩ := hf J l α |
| refine ⟨C, hC, fun t ht x => ?_⟩ |
| rw [← h.mixed l α t ht x] |
| exact hc t ht x |
|
|
| theorem velocity_rapid (M : Machine) (w : List ℕ) : Rapid (Construction.velocity M w) := |
| (velocity_rapidJets M w).rapid |
|
|
| theorem force_rapid (ν : ℝ) (M : Machine) (w : List ℕ) : Rapid (Construction.force ν M w) := by |
| have hf := velocity_rapidJets M w |
| have hR : Rapid (fun t x => Analytic.fullDt (Construction.velocity M w) t x + |
| advection (Construction.velocity M w) t x - ν • laplacian (Construction.velocity M w) t x) := |
| RapidJets.rapid (f := fun t x => Analytic.fullDt (Construction.velocity M w) t x + |
| advection (Construction.velocity M w) t x - ν • laplacian (Construction.velocity M w) t x) |
| (hf.fullResidual ν) |
| apply Rapid.congr_half hR |
| intro t ht x |
| simp only [Construction.force, residual] |
| rw [Analytic.dt_eq_full _ hf.1 t ht x] |
|
|
| end |
| end Bounds |
| end AlternatingNS |
|
|
| end OAI |
|
|
