| import OAI.Analysis.C0Absorption.Localization |
|
|
| namespace OAI |
|
|
| open Set Filter Topology |
| open scoped NNReal BigOperators ZeroAtInfty |
|
|
| namespace C0Absorption |
| noncomputable section |
|
|
| abbrev C0Ball := Metric.closedBall (0 : C0) 1 |
|
|
| abbrev Cube (I : Finset ℕ) := (i : I) → Icc (-1 : ℝ) 1 |
|
|
| theorem c0_norm_apply_le (s : C0) (i : ℕ) : |s i| ≤ ‖s‖ := by |
| exact s.toBCF.norm_coe_le_norm i |
|
|
| theorem c0_norm_le (s : C0) {a : ℝ} (ha : 0 ≤ a) (hs : ∀ i, |s i| ≤ a) : ‖s‖ ≤ a := by |
| exact (s.toBCF.norm_le ha).mpr hs |
|
|
| def c0Eval (i : ℕ) : C0 →L[ℝ] ℝ := |
| LinearMap.mkContinuous |
| { toFun := fun s : C0 => s i |
| map_add' := fun _ _ => rfl |
| map_smul' := fun _ _ => rfl } 1 (fun s => by simpa using c0_norm_apply_le s i) |
|
|
| @[simp] theorem c0Eval_apply (i : ℕ) (s : C0) : c0Eval i s = s i := rfl |
|
|
| def cubeRestrict (I : Finset ℕ) (s : C0Ball) : Cube I := fun i => |
| ⟨s.val i, by |
| have hnorm : ‖s.val‖ ≤ 1 := by |
| have hh := s.property |
| change dist s.val 0 ≤ 1 at hh |
| rwa [dist_zero_right] at hh |
| exact abs_le.mp ((c0_norm_apply_le s.val i).trans hnorm)⟩ |
|
|
| def finsuppToC0 (f : ℕ →₀ ℝ) : C0 where |
| toFun := f |
| continuous_toFun := continuous_of_discreteTopology |
| zero_at_infty' := (HasCompactSupport.of_support_subset_isCompact |
| f.hasFiniteSupport.isCompact (Set.Subset.refl _)).is_zero_at_infty |
|
|
| @[simp] theorem finsuppToC0_apply (f : ℕ →₀ ℝ) (i : ℕ) : finsuppToC0 f i = f i := rfl |
|
|
| def atom (i : ℕ) : C0 := finsuppToC0 (Finsupp.single i 1) |
|
|
| @[simp] theorem atom_apply (i j : ℕ) : atom i j = if i=j then 1 else 0 := by |
| simp [atom, Finsupp.single_apply] |
|
|
| @[simp] theorem atom_norm (i : ℕ) : ‖atom i‖ = 1 := by |
| apply le_antisymm |
| · apply c0_norm_le _ zero_le_one |
| intro j |
| simp only [atom_apply] |
| split <;> norm_num |
| · simpa using c0_norm_apply_le (atom i) i |
|
|
| def truncate (N : ℕ) (s : C0) : C0 := ∑ i ∈ Finset.range N, s i • atom i |
|
|
| @[simp] theorem truncate_apply (N : ℕ) (s : C0) (i : ℕ) : |
| truncate N s i = if i < N then s i else 0 := by |
| classical |
| change c0Eval i (∑ j ∈ Finset.range N, s j • atom j) = _ |
| simp only [map_sum, map_smul, smul_eq_mul, c0Eval_apply, atom_apply] |
| by_cases hi : i < N |
| · rw [ite_eq_left hi, Finset.sum_eq_single i] |
| · simp |
| · intro j hj hji; simp [hji] |
| · intro hnot; exact (hnot (Finset.mem_range.mpr hi)).elim |
| · rw [ite_eq_right hi] |
| apply Finset.sum_eq_zero |
| intro j hj |
| have hji : j ≠ i := by intro h; subst j; exact hi (Finset.mem_range.mp hj) |
| simp [hji] |
|
|
| theorem c0_tendsto_zero (s : C0) : Tendsto s atTop (nhds 0) := by |
| simpa only [cocompact_eq_cofinite, Nat.cofinite_eq_atTop] using zero_at_infty s |
|
|
| theorem truncate_tendsto (s : C0) : Tendsto (fun N => truncate N s) atTop (nhds s) := by |
| rw [Metric.tendsto_nhds] |
| intro ε hε |
| have he : ∀ᶠ i in atTop, |s i| < ε/2 := by |
| simpa only [Real.dist_eq, sub_zero] using |
| (Metric.tendsto_nhds.mp (c0_tendsto_zero s) (ε/2) (by positivity)) |
| obtain ⟨N, hN⟩ := eventually_atTop.mp he |
| filter_upwards [eventually_ge_atTop N] with n hn |
| rw [dist_eq_norm] |
| apply lt_of_le_of_lt ?_ (half_lt_self hε) |
| apply c0_norm_le _ (by positivity : 0 ≤ ε/2) |
| intro i |
| simp only [ZeroAtInftyContinuousMap.sub_apply, truncate_apply] |
| by_cases hi : i < n |
| · simp [hi]; positivity |
| · simp only [ite_eq_right hi, zero_sub, abs_neg] |
| exact (hN i (hn.trans (Nat.le_of_not_gt hi))).le |
|
|
| theorem truncate_mem_span (N : ℕ) (s : C0) : |
| truncate N s ∈ Submodule.span ℝ (Set.range atom) := by |
| apply Submodule.sum_mem |
| intro i hi |
| exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨i, rfl⟩) |
|
|
| theorem c0_span_dense : Dense (↑(Submodule.span ℝ (Set.range atom)) : Set C0) := by |
| intro s |
| exact mem_closure_of_tendsto (truncate_tendsto s) |
| (Filter.Eventually.of_forall (fun N => truncate_mem_span N s)) |
|
|
| instance c0_separable : TopologicalSpace.SeparableSpace C0 := by |
| apply TopologicalSpace.isSeparable_univ_iff.mp |
| have hh := (Set.countable_range atom).isSeparable.span (R := ℝ) |
| rw [← c0_span_dense.closure_eq] |
| exact hh.closure |
|
|
| def extendFinite (I : Finset ℕ) (x : I → ℝ) : C0 := by |
| classical |
| exact finsuppToC0 (Finsupp.onFinset I (fun j => if h : j ∈ I then x ⟨j,h⟩ else 0) |
| (by intro j hj; by_contra h; simp [h] at hj)) |
|
|
| @[simp] theorem extendFinite_apply (I : Finset ℕ) (x : I → ℝ) (j : ℕ) : |
| extendFinite I x j = if h : j ∈ I then x ⟨j,h⟩ else 0 := by |
| classical |
| rfl |
|
|
| theorem extendFinite_norm_le (I : Finset ℕ) (x : I → ℝ) {a : ℝ} |
| (ha : 0 ≤ a) (hx : ∀ i, |x i| ≤ a) : ‖extendFinite I x‖ ≤ a := by |
| classical |
| apply c0_norm_le _ ha |
| intro j |
| rw [extendFinite_apply] |
| split |
| · exact hx _ |
| · simpa using ha |
|
|
| def cubeExtend (I : Finset ℕ) (x : Cube I) : C0Ball := |
| ⟨extendFinite I (fun i => (x i).val), by |
| rw [Metric.mem_closedBall, dist_zero_right] |
| apply extendFinite_norm_le _ _ zero_le_one |
| intro i |
| exact abs_le.mpr (x i).property⟩ |
|
|
| @[simp] theorem cubeRestrict_extend (I : Finset ℕ) (x : Cube I) : |
| cubeRestrict I (cubeExtend I x) = x := by |
| classical |
| ext i |
| change extendFinite I (fun i => (x i).val) i = (x i).val |
| simp |
|
|
| theorem cubeRestrict_lipschitz (I : Finset ℕ) : LipschitzWith 1 (cubeRestrict I) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [NNReal.coe_one, one_mul] |
| apply (dist_pi_le_iff dist_nonneg).mpr |
| intro i |
| change dist (s.val i) (t.val i) ≤ dist s.val t.val |
| exact BoundedContinuousFunction.dist_coe_le_dist (f := s.val.toBCF) (g := t.val.toBCF) i |
|
|
| theorem cubeExtend_lipschitz (I : Finset ℕ) : LipschitzWith 1 (cubeExtend I) := by |
| classical |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [NNReal.coe_one, one_mul, Subtype.dist_eq, dist_eq_norm] |
| apply c0_norm_le _ dist_nonneg |
| intro j |
| change |extendFinite I (fun i => (s i).val) j-extendFinite I (fun i => (t i).val) j| ≤ dist s t |
| simp only [extendFinite_apply] |
| split |
| · exact dist_le_pi_dist s t _ |
| · simp |
|
|
| theorem cubeExtend_isometry (I : Finset ℕ) : Isometry (cubeExtend I) := by |
| rw [isometry_iff_dist_eq] |
| intro x y |
| apply le_antisymm |
| · simpa using (cubeExtend_lipschitz I).dist_le_mul x y |
| · simpa using (cubeRestrict_lipschitz I).dist_le_mul (cubeExtend I x) (cubeExtend I y) |
|
|
| abbrev GridIndex (n : ℕ) := Icc (-(n : ℤ)) (n : ℤ) |
|
|
| def gridPoint (n : ℕ) (hn : 0 < n) (z : GridIndex n) : Icc (-1 : ℝ) 1 := |
| ⟨(z.val : ℝ) / n, by |
| have hn' : (0 : ℝ) < n := by exact_mod_cast hn |
| have hl : -(n : ℝ) ≤ (z.val : ℝ) := by exact_mod_cast z.property.1 |
| have hu : (z.val : ℝ) ≤ (n : ℝ) := by exact_mod_cast z.property.2 |
| constructor |
| · apply (le_div_iff₀ hn').mpr; simpa using hl |
| · apply (div_le_iff₀ hn').mpr; simpa using hu⟩ |
|
|
| def nearestGridIndex (n : ℕ) (_hn : 0 < n) (x : Icc (-1 : ℝ) 1) : GridIndex n := |
| ⟨round ((n : ℝ) * x.val), by |
| have hb := abs_le.mp (abs_sub_round ((n : ℝ) * x.val)) |
| have hxlo : -(n : ℝ) ≤ (n : ℝ) * x.val := by nlinarith [x.property.1, Nat.cast_nonneg (α := ℝ) n] |
| have hxhi : (n : ℝ) * x.val ≤ n := by nlinarith [x.property.2, Nat.cast_nonneg (α := ℝ) n] |
| constructor |
| · by_contra h |
| have hh : round ((n : ℝ) * x.val) ≤ -(n : ℤ)-1 := by omega |
| have hh' : (round ((n : ℝ) * x.val) : ℝ) ≤ -(n : ℝ)-1 := by exact_mod_cast hh |
| linarith |
| · by_contra h |
| have hh : (n : ℤ)+1 ≤ round ((n : ℝ) * x.val) := by omega |
| have hh' : (n : ℝ)+1 ≤ (round ((n : ℝ) * x.val) : ℝ) := by exact_mod_cast hh |
| linarith⟩ |
|
|
| theorem nearestGrid_dist (n : ℕ) (hn : 0 < n) (x : Icc (-1 : ℝ) 1) : |
| dist x (gridPoint n hn (nearestGridIndex n hn x)) ≤ 1 / (2*(n : ℝ)) := by |
| have hn' : (0 : ℝ) < n := by exact_mod_cast hn |
| change |x.val - (round ((n : ℝ)*x.val) : ℝ)/(n : ℝ)| ≤ _ |
| rw [show x.val - (round ((n : ℝ)*x.val) : ℝ)/(n : ℝ) = |
| ((n : ℝ)*x.val-(round ((n : ℝ)*x.val) : ℝ))/(n : ℝ) by field_simp, |
| abs_div, abs_of_pos hn', div_le_iff₀ hn'] |
| have hb := abs_sub_round ((n : ℝ)*x.val) |
| have he : 1 / (2*(n : ℝ)) * (n : ℝ) = (1 : ℝ)/2 := by field_simp |
| rwa [he] |
|
|
| def dyadic (a : ℕ) : ℝ := ((2 : ℝ)^a)⁻¹ |
|
|
| theorem dyadic_pos (a : ℕ) : 0 < dyadic a := by unfold dyadic; positivity |
|
|
| theorem dyadic_tendsto : Tendsto dyadic atTop (nhds 0) := by |
| change Tendsto (fun a : ℕ => ((2 : ℝ)^a)⁻¹) atTop (nhds 0) |
| simpa only [inv_pow] using tendsto_pow_atTop_nhds_zero_of_lt_one |
| (by norm_num : (0 : ℝ) ≤ 2⁻¹) (by norm_num : (2 : ℝ)⁻¹ < 1) |
|
|
| abbrev OperationGrid (I : Finset ℕ) (a : ℕ) := I → GridIndex (2^(a+3)) |
|
|
| def operationGridPoint (I : Finset ℕ) (a : ℕ) (q : OperationGrid I a) : Cube I := |
| fun i => gridPoint _ (by positivity) (q i) |
|
|
| def nearestOperationGrid (I : Finset ℕ) (a : ℕ) (x : Cube I) : OperationGrid I a := |
| fun i => nearestGridIndex _ (by positivity) (x i) |
|
|
| theorem operationGrid_mesh (a : ℕ) : (1 : ℝ) / (2^(a+3)) = dyadic a / 8 := by |
| rw [dyadic, pow_add]; norm_num; ring |
|
|
| theorem nearestOperationGrid_dist (I : Finset ℕ) (a : ℕ) (x : Cube I) : |
| dist x (operationGridPoint I a (nearestOperationGrid I a x)) ≤ dyadic a / 16 := by |
| apply (dist_pi_le_iff (div_nonneg (dyadic_pos a).le (by norm_num) : 0 ≤ dyadic a / 16)).mpr |
| intro i |
| have hh := nearestGrid_dist (2^(a+3)) (by positivity) (x i) |
| change dist (x i) (gridPoint _ _ (nearestGridIndex _ _ (x i))) ≤ _ |
| refine hh.trans_eq ?_ |
| push_cast |
| rw [dyadic, pow_add] |
| norm_num |
| ring |
|
|
| def coordinateTail (N : ℕ) (s : C0) : C0 := s - truncate (N+1) s |
|
|
| @[simp] theorem coordinateTail_apply (N : ℕ) (s : C0) (i : ℕ) : |
| coordinateTail N s i = if N < i then s i else 0 := by |
| simp only [coordinateTail, ZeroAtInftyContinuousMap.sub_apply, truncate_apply] |
| split_ifs <;> simp_all; omega |
|
|
| def tau (N : ℕ) (s : C0) : ℝ := ‖coordinateTail N s‖ |
|
|
| theorem tau_nonneg (N : ℕ) (s : C0) : 0 ≤ tau N s := norm_nonneg _ |
|
|
| theorem coordinateTail_sub (N : ℕ) (s t : C0) : |
| coordinateTail N (s-t) = coordinateTail N s-coordinateTail N t := by |
| ext i |
| simp only [coordinateTail_apply, ZeroAtInftyContinuousMap.sub_apply] |
| split_ifs <;> simp |
|
|
| theorem tau_le_norm (N : ℕ) (s : C0) : tau N s ≤ ‖s‖ := by |
| apply c0_norm_le _ (norm_nonneg s) |
| intro i |
| rw [coordinateTail_apply] |
| split_ifs |
| · exact c0_norm_apply_le s i |
| · simp |
|
|
| theorem tau_lipschitz (N : ℕ) : LipschitzWith 1 (tau N) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [NNReal.coe_one, one_mul, Real.dist_eq] |
| calc |
| |tau N s-tau N t| ≤ ‖coordinateTail N s-coordinateTail N t‖ := abs_norm_sub_norm_le _ _ |
| _ = tau N (s-t) := by rw [tau, coordinateTail_sub] |
| _ ≤ ‖s-t‖ := tau_le_norm _ _ |
| _ = dist s t := (dist_eq_norm _ _).symm |
|
|
| theorem tau_antitone (s : C0) : Antitone (fun N => tau N s) := by |
| intro M N hMN |
| apply c0_norm_le _ (tau_nonneg M s) |
| intro i |
| rw [coordinateTail_apply] |
| split_ifs with hi |
| · have hh := c0_norm_apply_le (coordinateTail M s) i |
| simpa [tau, coordinateTail_apply, lt_of_le_of_lt hMN hi] using hh |
| · simpa using tau_nonneg M s |
|
|
| theorem tau_tendsto_zero (s : C0) : Tendsto (fun N => tau N s) atTop (nhds 0) := by |
| have hh := ((show Tendsto (fun _ : ℕ => s) atTop (nhds s) from tendsto_const_nhds).sub (truncate_tendsto s)).norm |
| have hshift : Tendsto (fun N : ℕ => N+1) atTop atTop := tendsto_add_atTop_nat 1 |
| simpa [Function.comp_def, tau, coordinateTail] using hh.comp hshift |
|
|
| def tailFactor (c : ℝ) (N : ℕ) (s : C0) : ℝ := min 1 (max (2-tau N s/c) 0) |
|
|
| theorem tailFactor_nonneg (c : ℝ) (N : ℕ) (s : C0) : 0 ≤ tailFactor c N s := by |
| exact le_min zero_le_one (le_max_right _ _) |
|
|
| theorem tailFactor_le_one (c : ℝ) (N : ℕ) (s : C0) : tailFactor c N s ≤ 1 := min_le_left _ _ |
|
|
| theorem tailFactor_eq_one {c : ℝ} (hc : 0 < c) (N : ℕ) (s : C0) (hs : tau N s ≤ c) : |
| tailFactor c N s = 1 := by |
| apply min_eq_left |
| apply (le_max_left _ _).trans' |
| have hdiv := (div_le_one hc).mpr hs |
| linarith |
|
|
| theorem tailFactor_eq_zero {c : ℝ} (hc : 0 < c) (N : ℕ) (s : C0) (hs : 2*c ≤ tau N s) : |
| tailFactor c N s = 0 := by |
| have hdiv : 2 ≤ tau N s/c := (le_div_iff₀ hc).mpr hs |
| simp [tailFactor, max_eq_right (show 2-tau N s/c ≤ 0 by linarith)] |
|
|
| theorem tailFactor_lipschitz {c : ℝ} (hc : 0 < c) (N : ℕ) : |
| LipschitzWith ⟨c⁻¹, inv_nonneg.mpr hc.le⟩ (tailFactor c N) := by |
| have ht : LipschitzWith ⟨c⁻¹, inv_nonneg.mpr hc.le⟩ (fun s => (2 : ℝ)-tau N s/c) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [Real.dist_eq] |
| change |(2-tau N s/c)-(2-tau N t/c)| ≤ c⁻¹ * dist s t |
| calc |
| _ = |tau N s-tau N t| / c := by |
| rw [← abs_neg, neg_sub, show (2-tau N t/c)-(2-tau N s/c) = (tau N s-tau N t)/c by ring, |
| abs_div, abs_of_pos hc] |
| _ ≤ dist s t/c := div_le_div_of_nonneg_right |
| (by simpa [Real.dist_eq] using (tau_lipschitz N).dist_le_mul s t) hc.le |
| _ = _ := by ring |
| have hh := (LipschitzWith.const (1 : ℝ)).min (ht.max (LipschitzWith.const (0 : ℝ))) |
| change LipschitzWith _ (fun s => min 1 (max (2-tau N s/c) 0)) |
| apply hh.weaken |
| exact max_le bot_le (max_le le_rfl bot_le) |
|
|
| theorem tailFactor_tendsto_one {c : ℝ} (hc : 0 < c) (s : C0) : |
| Tendsto (fun N => tailFactor c N s) atTop (nhds 1) := by |
| have hh : ∀ᶠ N in atTop, tau N s ≤ c := |
| (tau_tendsto_zero s).eventually (eventually_le_nhds hc) |
| apply tendsto_const_nhds.congr' |
| filter_upwards [hh] with N hN |
| exact (tailFactor_eq_one hc N s hN).symm |
|
|
| theorem tailFactor_support {c : ℝ} (hc : 0 < c) (N : ℕ) : |
| tsupport (tailFactor c N) ⊆ {s | tau N s ≤ 2*c} := by |
| apply closure_minimal |
| · intro s hs |
| by_contra hh |
| exact hs (tailFactor_eq_zero hc N s (le_of_not_ge hh)) |
| · exact isClosed_le (tau_lipschitz N).continuous continuous_const |
|
|
| theorem remainderTail_support {c : ℝ} (hc : 0 < c) (N : ℕ) : |
| tsupport (fun s => tailFactor c N s-1) ⊆ {s | c ≤ tau N s} := by |
| apply closure_minimal |
| · intro s hs |
| by_contra hh |
| have he := tailFactor_eq_one hc N s (le_of_not_ge hh) |
| exact hs (by simp only [he, sub_self]) |
| · exact isClosed_le continuous_const (tau_lipschitz N).continuous |
|
|
| end |
| end C0Absorption |
|
|
| end OAI |
|
|
