| import OAI.MathematicalPhysics.AlternatingFlow.DecoderNames |
| import OAI.MathematicalPhysics.AlternatingFlow.RecursiveBounds |
|
|
| namespace OAI |
|
|
| section ConstructiveBoundsDevelopment |
|
|
| open scoped BigOperators Topology ContDiff |
| open Filter |
|
|
| namespace AlternatingNS.Effective |
| attribute [local instance] Arithmetic.rationalCoding |
|
|
| variable {A : Type*} [Primcodable A] |
|
|
| lemma Scaled.nat {s : A → ℕ → ℝ} (hs : ∀ a n, 0 ≤ s a n) |
| (c : A → ℕ) (hc : Computable c) : Scaled s (fun a _ (_ : ℝ) => (c a : ℝ)) := |
| Scaled.const hs _ c hc (by intro a n; simp) |
|
|
| lemma Scaled.cmul {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {s : A → ℕ → ℝ} (hs : ∀ a n, 0 ≤ s a n) {f : A → ℕ → E → ℝ} |
| (hf : Scaled s f) (c : ℝ) (B : ℕ) (hc : |c| ≤ B) : |
| Scaled s (fun a n x => c * f a n x) := |
| hf.smul hs (fun _ _ => c) (fun _ => B) (Computable.const B) (fun _ _ => hc) |
|
|
| lemma Scaled.affine {s : A → ℕ → ℝ} (hs : ∀ a n, 0 ≤ s a n) |
| {f : A → ℝ → ℝ} (hf : Scaled (fun _ _ => 1) (fun a _ => f a)) |
| (c d : A → ℕ → ℝ) (B : A → ℕ) (hB : Computable B) |
| (hc : ∀ a n, |c a n| ≤ (B a : ℝ) * s a n) : |
| Scaled s (fun a n x => f a (c a n * x + d a n)) := by |
| obtain ⟨sf,C,hC,hfC⟩ := hf |
| refine ⟨fun a n => (sf a 0).comp (contDiff_const.mul contDiff_id |>.add contDiff_const), |
| fun z => C z * B z.1 ^ z.2, |
| Primrec.nat_mul.to_comp.comp hC (nat_pow.to_comp.comp (hB.comp Computable.fst) Computable.snd), |
| fun a r n x => ?_⟩ |
| change ‖iteratedFDeriv ℝ r ((fun y => f a (y + d a n)) ∘ |
| (c a n • ContinuousLinearMap.id ℝ ℝ)) x‖ ≤ _ |
| apply (Bounds.norm_comp_linear _ ((sf a 0).comp (contDiff_id.add contDiff_const)) _ r x).trans |
| change ‖iteratedFDeriv ℝ r (fun y => f a (y + d a n)) (c a n * x)‖ * |
| ‖c a n • ContinuousLinearMap.id ℝ ℝ‖ ^ r ≤ _ |
| rw [iteratedFDeriv_comp_add_right] |
| simp only [norm_smul, Real.norm_eq_abs, ContinuousLinearMap.norm_id, mul_one] |
| push_cast |
| calc |
| _ ≤ (C (a,r) : ℝ) * ((B a : ℝ) * s a n) ^ r := by |
| rw [mul_comm, mul_comm (C (a,r) : ℝ)] |
| exact mul_le_mul (pow_le_pow_left₀ (abs_nonneg _) (hc a n) r) |
| (by simpa using hfC a r 0 (c a n * x + d a n)) (norm_nonneg _) |
| (pow_nonneg (mul_nonneg (Nat.cast_nonneg _) (hs a n)) r) |
| _ = _ := by ring |
|
|
| lemma transition_scaled : Scaled (fun _ : Unit => fun _ => 1) |
| (fun _ _ => Real.smoothTransition) := |
| ⟨fun _ _ => Real.smoothTransition.contDiff, fun z => Quantitative.transitionBound z.2, |
| transitionBound.to_comp.comp Computable.snd, by intro _ r n x; simpa using Quantitative.transition_jet_bound r x⟩ |
|
|
| lemma selector_scaled (b a : A → ℕ) (hB : Computable b) : |
| Scaled (fun _ _ => 1) (fun p _ => Profiles.selector (b p) (a p)) := by |
| have hT := transition_scaled.param (fun _ : A => ()) (Computable.const ()) |
| have h₁ := hT.affine (fun _ _ => zero_le_one) (fun p _ => 8 * (b p : ℝ)) |
| (fun p _ => 2 - 16 * (a p : ℝ)) (fun p => 8 * b p) |
| (Primrec.nat_mul.to_comp.comp (Computable.const 8) hB) (by intro p n; simp) |
| have h₂ := hT.affine (fun _ _ => zero_le_one) (fun p _ => -(8 * (b p : ℝ))) |
| (fun p _ => 16 * (a p : ℝ) + 10) (fun p => 8 * b p) |
| (Primrec.nat_mul.to_comp.comp (Computable.const 8) hB) (by intro p n; simp) |
| exact (h₁.mul (fun _ _ => zero_le_one) h₂).congr (by intros; dsimp [Profiles.selector]; congr 2 <;> ring) |
|
|
| lemma decoder_scaled : Scaled (fun _ : Machine => fun _ => 1) |
| (fun M _ => Profiles.decoder M.base) := by |
| refine ⟨fun M _ => Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega), |
| fun z => Quantitative.decoderBound z.1.base z.2, |
| decoderBound.to_comp.comp (base.to_comp.comp Computable.fst) Computable.snd, ?_⟩ |
| intro M r n x |
| simp only [one_pow, mul_one] |
| exact Quantitative.decoder_jet_bound M.base (by have := M.base_ge_four; omega) r x |
|
|
| lemma read_scaled (M : A → Machine) (N : A → ℕ) (hM : Computable M) |
| (k : A → ℕ → ℕ) (hk : ∀ a n, k a n ≤ Scales.s (N a) n + 1 + Scales.K (N a) n) : |
| Scaled (fun a => Bounds.readScale (M a) (N a)) |
| (fun a n D => Profiles.decoder (M a).base (((M a).base : ℝ) ^ k a n * D)) := by |
| apply (decoder_scaled.param M hM).comp_scaled_linear (fun a => Bounds.readScale_nonneg _ _) |
| (fun a n => ((M a).base : ℝ) ^ k a n • ContinuousLinearMap.id ℝ ℝ) |
| intro a n |
| have hb : (1 : ℝ) ≤ (M a).base := by have := (M a).base_ge_four; exact_mod_cast (by omega : 1 ≤ (M a).base) |
| simpa only [norm_smul, Real.norm_eq_abs, abs_of_nonneg (pow_nonneg (le_trans zero_le_one hb) _), |
| ContinuousLinearMap.norm_id, mul_one, Bounds.readScale] using pow_le_pow_right₀ hb (hk a n) |
|
|
| lemma readC_scaled (M : A → Machine) (N : A → ℕ) (hM : Computable M) : |
| Scaled (fun a => Bounds.readScale (M a) (N a)) (fun a => LocalRule.readC (M a) (N a)) := |
| read_scaled M N hM (fun a => Scales.s (N a)) (by intros; omega) |
|
|
| lemma readB_scaled (M : A → Machine) (N : A → ℕ) (hM : Computable M) : |
| Scaled (fun a => Bounds.readScale (M a) (N a)) (fun a => LocalRule.readB (M a) (N a)) := |
| read_scaled M N hM _ (by intros; rfl) |
|
|
| lemma readA_scaled (M : A → Machine) (N : A → ℕ) (hM : Computable M) : |
| Scaled (fun a => Bounds.readScale (M a) (N a)) (fun a => LocalRule.readA (M a) (N a)) := |
| (read_scaled M N hM (fun a n => Scales.s (N a) n + 1) (by intros; omega)).sub |
| ((readB_scaled M N hM).smul (fun a => Bounds.readScale_nonneg _ _) _ |
| (fun _ => 1) (Computable.const 1) (fun a n => by simpa using Bounds.inverse_power_bound (M a) (Scales.K (N a) n))) |
|
|
| lemma updates_scaled (M : A → Machine) (N a l : A → ℕ) (r : A → Rule) |
| (hM : Computable M) (ha : Computable a) (hl : Computable l) (hr : Computable r) : |
| Scaled (fun p => Bounds.readScale (M p) (N p)) |
| (fun p n D => LocalRule.updateLeft (M p).base (a p) (l p) (r p) |
| (LocalRule.readA (M p) (N p) n D) (LocalRule.readB (M p) (N p) n D)) ∧ |
| Scaled (fun p => Bounds.readScale (M p) (N p)) |
| (fun p n D => LocalRule.updateRight (M p).base (a p) (l p) (r p) |
| (LocalRule.readA (M p) (N p) n D) (LocalRule.readB (M p) (N p) n D)) := by |
| let s := fun p => Bounds.readScale (M p) (N p) |
| have hs : ∀ p n, 0 ≤ s p n := fun p => Bounds.readScale_nonneg _ _ |
| have hhA := readA_scaled M N hM |
| have hhB := readB_scaled M N hM |
| have cb := base.to_comp.comp hM |
| have hrw := Computable.fst.comp (Computable.snd.comp hr) |
| have hb (p : A) (n : ℕ) : |((M p).base : ℝ)| ≤ ((M p).base : ℝ) := by simp |
| have hdiv {f : A → ℕ → ℝ → ℝ} (hf : Scaled s f) : |
| Scaled s (fun p n D => f p n D / (M p).base) := by |
| have h := hf.smul hs (fun p _ => ((M p).base : ℝ)⁻¹) (fun _ => 1) (Computable.const 1) |
| (fun p _ => by simpa using Bounds.inverse_power_bound (M p) 1) |
| exact h.congr (by intros; simp [div_eq_mul_inv, mul_comm]) |
| have h2l := Scaled.nat hs (fun p => 2 * l p) (Primrec.nat_mul.to_comp.comp (Computable.const 2) hl) |
| have h2a := Scaled.nat hs (fun p => 2 * a p) (Primrec.nat_mul.to_comp.comp (Computable.const 2) ha) |
| have h2w := Scaled.nat hs (fun p => 2 * (r p).2.1) (Primrec.nat_mul.to_comp.comp (Computable.const 2) hrw) |
| have hLeft := ((hhA.smul hs (fun p _ => ((M p).base : ℝ)) (fun p => (M p).base) cb hb).sub h2l).ite hs |
| (hhA.ite hs (hdiv (h2w.add hhA)) (fun p _ => (r p).2.2 = 1)) (fun p _ => (r p).2.2 = 0) |
| have hR := (hhB.smul hs (fun p _ => ((M p).base : ℝ)) (fun p => (M p).base) cb hb).sub h2a |
| have hRight := (hdiv (h2l.add (hdiv (h2w.add hR)))).ite hs |
| ((hdiv (h2w.add hR)).ite hs hR (fun p _ => (r p).2.2 = 1)) (fun p _ => (r p).2.2 = 0) |
| constructor |
| · exact hLeft.congr (by intro p n x; dsimp [LocalRule.updateLeft]; push_cast; split_ifs <;> rfl) |
| · exact hRight.congr (by intro p n x; dsimp [LocalRule.updateRight]; push_cast; split_ifs <;> rfl) |
|
|
| lemma branchNumerator_scaled (M : A → Machine) (N a l : A → ℕ) (r : A → Rule) |
| (hM : Computable M) (ha : Computable a) (hl : Computable l) (hr : Computable r) : |
| Scaled (fun p => Bounds.readScale (M p) (N p)) |
| (fun p n D => LocalRule.branchNumerator (M p).base (Scales.K (N p) (n+1)) (a p) (l p) (r p) |
| (LocalRule.readA (M p) (N p) n D) (LocalRule.readB (M p) (N p) n D)) := by |
| have hs := fun p => Bounds.readScale_nonneg (M p) (N p) |
| obtain ⟨hl',hr'⟩ := updates_scaled M N a l r hM ha hl hr |
| exact ((Scaled.nat hs (fun p => 2 * (r p).1) |
| (Primrec.nat_mul.to_comp.comp (Computable.const 2) (Computable.fst.comp hr))).add hl').add |
| (hr'.smul hs (fun p n => (((M p).base : ℝ) ^ Scales.K (N p) (n+1))⁻¹) |
| (fun _ => 1) (Computable.const 1) (fun p n => by simpa using Bounds.inverse_power_bound (M p) (Scales.K (N p) (n+1)))) |
|
|
| attribute [local irreducible] LocalRule.readA LocalRule.readB LocalRule.readC |
| Profiles.selector LocalRule.branchNumerator |
|
|
| lemma branch_scaled (M : A → Machine) (N q a : A → ℕ) |
| (hM : Computable M) (hq : Computable q) (ha : Computable a) : |
| Scaled (fun p => Bounds.readScale (M p) (N p)) |
| (fun p n D => LocalRule.branch (M p) (N p) n (q p) (a p) |
| (LocalRule.readA (M p) (N p) n D) (LocalRule.readB (M p) (N p) n D)) := by |
| have hs := fun p => Bounds.readScale_nonneg (M p) (N p) |
| let r := fun p => (M p).command (q p) (a p) |
| have hr : Computable r := command.to_comp.comp (hM.pair (hq.pair ha)) |
| have hb := base.to_comp.comp hM |
| have hread := (readA_scaled M N hM).param |
| (Prod.fst : A × ℕ → A) Computable.fst |
| have hout : Scaled (fun _ : A × ℕ => fun _ => (1:ℝ)) (fun p _ => Profiles.selector (M p.1).base p.2) := selector_scaled (fun p : A × ℕ => (M p.1).base) Prod.snd (hb.comp Computable.fst) |
| have hsel : Scaled (fun p : A × ℕ => Bounds.readScale (M p.1) (N p.1)) |
| (fun p n => Profiles.selector (M p.1).base p.2 ∘ LocalRule.readA (M p.1) (N p.1) n) := |
| Scaled.comp (A := A × ℕ) (E := ℝ) (F := ℝ) (G := ℝ) |
| (s := fun p => Bounds.readScale (M p.1) (N p.1)) |
| (f := fun p => LocalRule.readA (M p.1) (N p.1)) |
| (g := fun p => Profiles.selector (M p.1).base p.2) (fun p => hs p.1) hread hout |
| have hnum := branchNumerator_scaled (fun p : A × ℕ => M p.1) (fun p => N p.1) |
| (fun p => a p.1) Prod.snd (fun p => r p.1) (hM.comp Computable.fst) |
| (ha.comp Computable.fst) Computable.snd (hr.comp Computable.fst) |
| let S := fun (p : A × ℕ) n => Profiles.selector (M p.1).base p.2 ∘ LocalRule.readA (M p.1) (N p.1) n |
| let V := fun (p : A × ℕ) n D => LocalRule.branchNumerator (M p.1).base (Scales.K (N p.1) (n+1)) (a p.1) p.2 (r p.1) |
| (LocalRule.readA (M p.1) (N p.1) n D) (LocalRule.readB (M p.1) (N p.1) n D) |
| have hprod : Scaled (fun p : A × ℕ => Bounds.readScale (M p.1) (N p.1)) (fun p n D => S p n D * V p n D) := |
| Scaled.mul (A := A × ℕ) (E := ℝ) (s := fun p => Bounds.readScale (M p.1) (N p.1)) (f := S) (g := V) (fun p => hs p.1) hsel hnum |
| have hsum := hprod.sum_range hs |
| (fun p => (M p).alphabet) (alphabet.to_comp.comp hM) |
| exact (hsum.ite hs (branchNumerator_scaled M N a (fun _ => 0) r hM ha (Computable.const 0) hr) |
| (fun p _ => (r p).2.2 = 0)).congr (by intros; simp only [LocalRule.branch, S, V, r, Function.comp_apply, ite_apply]) |
|
|
| attribute [local irreducible] LocalRule.branch |
|
|
| lemma writeCore_scaled : Scaled (fun p : Machine × ℕ => Bounds.readScale p.1 p.2) |
| (fun p => Bounds.writeCore p.1 p.2) := by |
| let A := ((Machine × ℕ) × ℕ) × ℕ |
| let M := fun p : A => p.1.1.1 |
| let N := fun p : A => p.1.1.2 |
| let q := fun p : A => p.1.2 |
| let a := fun p : A => p.2 |
| have hM : Computable M := Computable.fst.comp (Computable.fst.comp Computable.fst) |
| have hq : Computable q := Computable.snd.comp Computable.fst |
| have ha : Computable a := Computable.snd |
| have hs := fun p => Bounds.readScale_nonneg (M p) (N p) |
| have hC := (readC_scaled M N hM).comp (A := A) (E := ℝ) (F := ℝ) (G := ℝ) (s := fun p => Bounds.readScale (M p) (N p)) (g := fun p => Profiles.selector (M p).base (q p)) hs (selector_scaled (fun p => (M p).base) q (base.to_comp.comp hM)) |
| have hB := (readB_scaled M N hM).comp (A := A) (E := ℝ) (F := ℝ) (G := ℝ) (s := fun p => Bounds.readScale (M p) (N p)) (g := fun p => Profiles.selector (M p).base (a p)) hs (selector_scaled (fun p => (M p).base) a (base.to_comp.comp hM)) |
| have hsum := ((hC.mul (E := ℝ) hs hB).mul (E := ℝ) hs (branch_scaled M N q a hM hq ha)).sum_range |
| (fun p : (Machine × ℕ) × ℕ => Bounds.readScale_nonneg p.1.1 p.1.2) |
| (fun p => p.1.1.alphabet) (alphabet.to_comp.comp (Computable.fst.comp Computable.fst)) |
| have hsum' := hsum.sum_range (fun p : Machine × ℕ => Bounds.readScale_nonneg p.1 p.2) |
| (fun p => p.1.states + 1) (Computable.succ.comp (states.to_comp.comp Computable.fst)) |
| exact (hsum'.smul (A := Machine × ℕ) (E := ℝ) (F := ℝ) (fun p => Bounds.readScale_nonneg p.1 p.2) (fun p _ => 1 / (p.1.base : ℝ)) |
| (fun _ => 1) (Computable.const 1) (fun p _ => by simpa using Bounds.inverse_power_bound p.1 1)).congr |
| (by intros; rfl) |
|
|
| lemma haltWeight_scaled : Scaled (fun p : Machine × ℕ => Bounds.readScale p.1 p.2) |
| (fun p => LocalRule.haltWeight p.1 p.2) := by |
| have hs := fun p : (Machine × ℕ) × ℕ => Bounds.readScale_nonneg p.1.1 p.1.2 |
| have h := (readC_scaled (fun p : (Machine × ℕ) × ℕ => p.1.1) (fun p => p.1.2) |
| (Computable.fst.comp Computable.fst)).comp (A := (Machine × ℕ) × ℕ) (s := fun p => Bounds.readScale p.1.1 p.1.2) (E := ℝ) (F := ℝ) (G := ℝ) (g := fun p : (Machine × ℕ) × ℕ => Profiles.selector p.1.1.base p.2) hs |
| (selector_scaled (fun p : (Machine × ℕ) × ℕ => p.1.1.base) Prod.snd (base.to_comp.comp (Computable.fst.comp Computable.fst))) |
| have hzero : Scaled (fun p : (Machine × ℕ) × ℕ => Bounds.readScale p.1.1 p.1.2) |
| (fun _ _ (_ : ℝ) => (0 : ℝ)) := Scaled.const hs _ (fun _ => 0) (Computable.const 0) (by intros; simp) |
| have hi := (h.ite (A := (Machine × ℕ) × ℕ) (E := ℝ) (F := ℝ) hs hzero (fun p _ => p.2 = p.1.1.states ∨ p.2 ∈ p.1.1.haltingStates)).sum_range (A := Machine × ℕ) (E := ℝ) (F := ℝ) |
| (fun p => Bounds.readScale_nonneg p.1 p.2) (fun p => p.1.states + 1) |
| (Computable.succ.comp (states.to_comp.comp Computable.fst)) |
|
|
| exact hi.congr (by intros; simp only [LocalRule.haltWeight, Function.comp_apply, ite_apply]) |
|
|
| lemma Scaled.coord {s : A → ℕ → ℝ} (hs : ∀ a n, 0 ≤ s a n) |
| {f : A → ℕ → ℝ → ℝ} (hf : Scaled s f) (idx : A → ℕ → Fin 3) : |
| Scaled s (fun a n (x : Space) => f a n (x (idx a n))) := by |
| apply hf.comp_linear (E := ℝ) (F := ℝ) (G := Space) hs |
| (fun a n => PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) (idx a n)) |
| (fun _ => 1) (Computable.const 1) |
| intro a n |
| simp only [Nat.cast_one] |
| apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one |
| intro x |
| simpa only [one_mul, PiLp.proj_apply] using PiLp.norm_apply_le x (idx a n) |
|
|
| lemma cutoff_scaled : Scaled (fun _ : Unit => fun _ => 1) (fun _ _ => Spatial.cutoff) := by |
| have h₁ := transition_scaled.affine (fun _ _ => zero_le_one) |
| (fun _ _ => -1) (fun _ _ => 3) (fun _ => 1) (Computable.const 1) (by intros; norm_num) |
| have h₂ := transition_scaled.affine (fun _ _ => zero_le_one) |
| (fun _ _ => 1) (fun _ _ => 3) (fun _ => 1) (Computable.const 1) (by intros; norm_num) |
| have h := h₁.mul (E := ℝ) (fun _ _ => zero_le_one) h₂ |
| have hi (i : Fin 3) := h.coord (fun _ _ => zero_le_one) (fun _ _ => i) |
| exact (((hi 0).mul (E := Space) (fun _ _ => zero_le_one) (hi 1)).mul |
| (E := Space) (fun _ _ => zero_le_one) (hi 2)).congr |
| (by intro p n x; simp [Spatial.cutoff, Fin.prod_univ_succ, mul_assoc, sub_eq_add_neg, |
| add_comm]) |
|
|
| lemma coord_jet_on_box (i : Fin 3) (r : ℕ) (x : Space) (hx : x ∈ Spatial.box) : |
| ‖iteratedFDeriv ℝ r (fun x : Space => x i) x‖ ≤ 3 := by |
| cases r with |
| | zero => simpa using hx i |
| | succ r => |
| let L := PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) i |
| have hd : fderiv ℝ (fun x : Space => x i) = fun _ => L := by |
| funext x; exact (Spatial.coord_hasFDeriv i x).fderiv |
| rw [← norm_iteratedFDeriv_fderiv, hd] |
| cases r with |
| | zero => |
| simp only [norm_iteratedFDeriv_zero] |
| have hL : ‖L‖ ≤ 1 := ContinuousLinearMap.opNorm_le_bound _ zero_le_one |
| (fun y => by simpa only [L, PiLp.proj_apply, one_mul] using PiLp.norm_apply_le y i) |
| linarith |
| | succ r => rw [iteratedFDeriv_const_of_ne (Nat.succ_ne_zero _), Pi.zero_apply, norm_zero]; norm_num |
|
|
| lemma cutoff_coordinate_scaled (idx : A → ℕ → Fin 3) : |
| Scaled (fun _ _ => 1) (fun a n (x : Space) => Spatial.cutoff x * x (idx a n)) := by |
| obtain ⟨_,B,hB,hcut⟩ := cutoff_scaled |
| have hc : Computable (fun r => B ((),r)) := hB.comp ((Computable.const ()).pair Computable.id) |
| let C := fun r => ∑ i ∈ Finset.range (r+1), r.choose i * B ((),i) * 3 |
| have hi : Computable₂ (fun r i : ℕ => r.choose i * B ((),i) * 3) := |
| Primrec.nat_mul.to_comp.comp (Primrec.nat_mul.to_comp.comp |
| (choose.to_comp.comp Computable.fst Computable.snd) (hc.comp Computable.snd)) (Computable.const 3) |
| have hC : Computable C := (nat_sum_range hi).comp Computable.id Computable.succ |
| refine ⟨fun a n => Spatial.cutoff_smooth.mul (Spatial.coord_smooth (idx a n)), |
| fun z => C z.2, hC.comp Computable.snd, fun a r n x => ?_⟩ |
| simp only [one_pow, mul_one] |
| by_cases hx : x ∈ Spatial.box |
| · apply (norm_iteratedFDeriv_mul_le Spatial.cutoff_smooth (Spatial.coord_smooth (idx a n)) x |
| (WithTop.coe_le_coe.mpr le_top : (r : ℕ∞ω) ≤ ∞)).trans |
| simp only [C, Nat.cast_sum, Nat.cast_mul, Nat.cast_ofNat] |
| apply Finset.sum_le_sum |
| intro i _ |
| exact mul_le_mul (mul_le_mul_of_nonneg_left (by simpa using hcut () i 0 x) (Nat.cast_nonneg _)) |
| (coord_jet_on_box _ _ _ hx) (norm_nonneg _) (by positivity) |
| · have hn : x ∉ tsupport (fun x : Space => Spatial.cutoff x * x (idx a n)) := |
| fun h => hx (Spatial.cutoff_support (tsupport_mul_subset_left h)) |
| rw [image_eq_zero_of_notMem_tsupport (fun h => hn (tsupport_iteratedFDeriv_subset r h)), norm_zero] |
| positivity |
|
|
| lemma fixedPotential_scaled : Scaled (fun _ : Unit => fun _ => 1) (fun _ => Bounds.fixedPotential) := |
| ((cutoff_coordinate_scaled (fun _ : Unit => Construction.receiverIndex)).cmul |
| (fun _ _ => zero_le_one) (-1) 1 (by norm_num)).congr (by intros; simp [Bounds.fixedPotential]) |
|
|
| lemma Scaled.grow {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| {s : A → ℕ → ℝ} (hs : ∀ a n, 1 ≤ s a n) {f : A → ℕ → E → F} |
| (hf : Scaled (fun _ _ => 1) f) : Scaled s f := by |
| obtain ⟨sf,B,hB,hfB⟩ := hf |
| refine ⟨sf,B,hB,fun a r n x => ?_⟩ |
| have h : ‖iteratedFDeriv ℝ r (f a n) x‖ ≤ (B (a,r) : ℝ) := by simpa using hfB a r n x |
| exact h.trans (le_mul_of_one_le_right (Nat.cast_nonneg _) (one_le_pow₀ (hs a n))) |
|
|
| lemma corePotential_scaled : Scaled (fun p : Machine × ℕ => Bounds.readScale p.1 p.2) |
| (fun p => Bounds.corePotential p.1 p.2) := by |
| have hs := fun p : Machine × ℕ => Bounds.readScale_nonneg p.1 p.2 |
| have h (idx : (Machine × ℕ) → ℕ → Fin 3) := |
| (cutoff_coordinate_scaled idx).grow (A := Machine × ℕ) (E := Space) (F := ℝ) (s := fun p => Bounds.readScale p.1 p.2) (fun p => Bounds.readScale_ge_one p.1 p.2) |
| have hw := writeCore_scaled.coord hs (fun _ => Construction.donorIndex) |
| have hh := (haltWeight_scaled.coord hs (fun _ => Construction.donorIndex)).cmul hs 2 2 (by norm_num) |
| exact ((h (fun _ _ => 0)).mul (E := Space) hs hw).sub |
| ((h (fun _ => Construction.receiverIndex)).mul (E := Space) hs hh) |
|
|
| end AlternatingNS.Effective |
|
|
| end ConstructiveBoundsDevelopment |
|
|
| end OAI |
|
|
