import Mathlib import OAI.Geometry.BallPacking.Holder.NonlinearCR namespace OAI noncomputable section namespace HigherDimensionalBallPacking.Rigidity section open scoped ContDiff Topology open Set Filter MeasureTheory lemma smoothCauchyKernel_second_directional {δ : ℝ} (hδ : 0 < δ) (z v w : ℂ) : fderiv ℝ (fun y => fderiv ℝ (smoothCauchyKernel δ) y v) z w = (-(2 * inner ℝ z w) / (‖z‖ ^ 2 + δ) ^ 2) • star v - (2 * inner ℝ w v / (‖z‖ ^ 2 + δ) ^ 2 - 8 * inner ℝ z v * inner ℝ z w / (‖z‖ ^ 2 + δ) ^ 3) • star z - (2 * inner ℝ z v / (‖z‖ ^ 2 + δ) ^ 2) • star w := by have hq : 0 < ‖z‖ ^ 2 + δ := add_pos_of_nonneg_of_pos (sq_nonneg _) hδ have hqi := (hasDerivAt_inv hq.ne').comp_hasFDerivAt z ((hasStrictFDerivAt_norm_sq z).hasFDerivAt.add_const δ) have hi : HasFDerivAt (fun y : ℂ => inner ℝ y v) (innerSL ℝ v) z := by convert! (innerSL ℝ v).hasFDerivAt using 1 ext y simpa only [innerSL_apply_apply] using (real_inner_comm y v).symm have ht := (hi.const_mul 2).mul (hqi.pow 2) have hd := (hqi.smul_const (star v)).sub (ht.smul (starL ℝ : ℂ ≃L[ℝ] ℂ).hasFDerivAt) have he : (fun y => fderiv ℝ (smoothCauchyKernel δ) y v) = (fun y => (‖y‖ ^ 2 + δ)⁻¹ • star v - (2 * inner ℝ y v * ((‖y‖ ^ 2 + δ)⁻¹) ^ 2) • star y) := by funext y rw [smoothCauchyKernel_fderiv hδ, div_eq_mul_inv, inv_pow] rw [he] change HasFDerivAt (fun y : ℂ => (‖y‖ ^ 2 + δ)⁻¹ • star v - (2 * inner ℝ y v * ((‖y‖ ^ 2 + δ)⁻¹) ^ 2) • star y) _ z at hd rw [hd.fderiv] simp only [sub_apply, add_apply, smul_apply, ContinuousLinearMap.smulRight_apply, innerSL_apply_apply, two_smul, smul_eq_mul, Function.comp_apply] simp only [Pi.mul_apply, Nat.reduceSub, pow_one, div_eq_mul_inv, inv_pow, ContinuousLinearEquiv.coe_coe] rw [real_inner_comm v w] change (-((‖z‖ ^ 2 + δ) ^ 2)⁻¹ * (inner ℝ z w + inner ℝ z w)) • star v - ((2 * inner ℝ z v * ((‖z‖ ^ 2 + δ) ^ 2)⁻¹) • star w + (2 * inner ℝ z v * (((‖z‖ ^ 2 + δ)⁻¹ + (‖z‖ ^ 2 + δ)⁻¹) * (-((‖z‖ ^ 2 + δ) ^ 2)⁻¹ * (inner ℝ z w + inner ℝ z w))) + ((‖z‖ ^ 2 + δ) ^ 2)⁻¹ * (inner ℝ v w + inner ℝ v w)) • star z) = _ simp only [← inv_pow] module lemma smoothCauchyKernel_second_norm {δ : ℝ} (hδ : 0 < δ) {z : ℂ} (hz : z ≠ 0) (v w : ℂ) : ‖fderiv ℝ (fun y => fderiv ℝ (smoothCauchyKernel δ) y v) z w‖ ≤ (14 / ‖z‖^3) * ‖v‖ * ‖w‖ := by have hp : 0 < ‖z‖ := norm_pos_iff.mpr hz have hq : 0 < ‖z‖^2+δ := add_pos_of_nonneg_of_pos (sq_nonneg _) hδ have hq2 : ‖z‖^4 ≤ (‖z‖^2+δ)^2 := by calc _ = (‖z‖^2)^2 := by ring _ ≤ _ := by gcongr; linarith have hq3 : ‖z‖^6 ≤ (‖z‖^2+δ)^3 := by calc _ = (‖z‖^2)^3 := by ring _ ≤ _ := by gcongr; linarith rw [smoothCauchyKernel_second_directional hδ] calc _ ≤ ‖(-(2*inner ℝ z w)/(‖z‖^2+δ)^2) • star v‖ + ‖(2*inner ℝ w v/(‖z‖^2+δ)^2 - 8*inner ℝ z v*inner ℝ z w/(‖z‖^2+δ)^3) • star z‖ + ‖(2*inner ℝ z v/(‖z‖^2+δ)^2) • star w‖ := (norm_sub_le _ _).trans (add_le_add (norm_sub_le _ _) le_rfl) _ ≤ (2*|inner ℝ z w|/(‖z‖^2+δ)^2)*‖v‖ + ((2*|inner ℝ w v|/(‖z‖^2+δ)^2) + (8*|inner ℝ z v| *|inner ℝ z w|/(‖z‖^2+δ)^3))*‖z‖ + (2*|inner ℝ z v|/(‖z‖^2+δ)^2)*‖w‖ := by simp only [norm_smul, norm_star, Real.norm_eq_abs, abs_div, abs_neg, abs_mul, abs_pow, abs_of_pos hq, abs_of_nonneg (by norm_num : (0:ℝ) ≤ 2)] gcongr apply (abs_sub _ _).trans_eq simp only [abs_div, abs_mul, abs_pow, abs_of_pos hq, abs_of_nonneg (by norm_num : (0:ℝ) ≤ 2), abs_of_nonneg (by norm_num : (0:ℝ) ≤ 8)] _ ≤ (2*(‖z‖*‖w‖)/‖z‖^4)*‖v‖ + ((2*(‖w‖*‖v‖)/‖z‖^4) + (8*(‖z‖*‖v‖)*(‖z‖*‖w‖)/‖z‖^6))*‖z‖ + (2*(‖z‖*‖v‖)/‖z‖^4)*‖w‖ := by gcongr <;> exact abs_real_inner_le_norm _ _ _ = _ := by field_simp; ring end section open scoped ContDiff Topology open Set Filter MeasureTheory variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] lemma second_directional_eq {f : ℂ → E} (hf : ContDiff ℝ ∞ f) (z v w : ℂ) : fderiv ℝ (fun y => fderiv ℝ f y v) z w = fderiv ℝ (fderiv ℝ f) z w v := by rw [fderiv_clm_apply ((hf.fderiv_right (m := ∞) (by simp)).differentiable (by simp) z) (differentiableAt_const v)] simp only [fderiv_const_apply, ContinuousLinearMap.comp_zero, zero_add, ContinuousLinearMap.flip_apply] lemma norm_second_jet (f : ℂ → E) (z : ℂ) : ‖iteratedFDeriv ℝ 2 f z‖ = ‖fderiv ℝ (fderiv ℝ f) z‖ := by rw [← norm_iteratedFDeriv_fderiv (n := 1), norm_iteratedFDeriv_one] lemma second_directional_norm_le {f : ℂ → E} (hf : ContDiff ℝ ∞ f) (z v w : ℂ) : ‖fderiv ℝ (fun y => fderiv ℝ f y v) z w‖ ≤ ‖iteratedFDeriv ℝ 2 f z‖ * ‖v‖ * ‖w‖ := by rw [second_directional_eq hf, norm_second_jet] apply (ContinuousLinearMap.le_opNorm _ _).trans calc _ ≤ (‖fderiv ℝ (fderiv ℝ f) z‖ * ‖w‖)*‖v‖ := mul_le_mul_of_nonneg_right (ContinuousLinearMap.le_opNorm _ _) (norm_nonneg _) _ = _ := by ring lemma norm_first_smul_le {b : ℂ → ℝ} {K : ℂ → E} (hb : ContDiff ℝ ∞ b) (hK : ContDiff ℝ ∞ K) (z : ℂ) : ‖fderiv ℝ (fun w => b w • K w) z‖ ≤ ‖b z‖*‖fderiv ℝ K z‖ + ‖fderiv ℝ b z‖*‖K z‖ := by have he := norm_iteratedFDeriv_smul_le hb hK z (by simp : (1:ℕ) ≤ (∞ : ℕ∞ω)) simpa only [Finset.sum_range_succ, Finset.sum_range_zero, zero_add, Nat.choose_zero_right, Nat.choose_self, Nat.cast_one, one_mul, Nat.sub_zero, Nat.sub_self, Nat.reduceSub, norm_iteratedFDeriv_one, norm_iteratedFDeriv_zero] using he lemma norm_second_smul_le {b : ℂ → ℝ} {K : ℂ → E} (hb : ContDiff ℝ ∞ b) (hK : ContDiff ℝ ∞ K) (z : ℂ) : ‖iteratedFDeriv ℝ 2 (fun w => b w • K w) z‖ ≤ ‖b z‖*‖iteratedFDeriv ℝ 2 K z‖ + 2*‖fderiv ℝ b z‖*‖fderiv ℝ K z‖ + ‖iteratedFDeriv ℝ 2 b z‖*‖K z‖ := by have he := norm_iteratedFDeriv_smul_le hb hK z (show (2:ℕ) ≤ (∞ : ℕ∞ω) from WithTop.coe_le_coe.mpr le_top) simpa only [Finset.sum_range_succ, Finset.sum_range_zero, zero_add, Nat.choose_zero_right, Nat.choose_self, Nat.choose_one_right, Nat.cast_one, one_mul, Nat.sub_zero, Nat.sub_self, Nat.reduceSub, Nat.cast_ofNat, norm_iteratedFDeriv_one, norm_iteratedFDeriv_zero] using he lemma norm_first_rescale {f : ℂ → E} (hf : ContDiff ℝ ∞ f) {r : ℝ} (hr : 0 < r) (z : ℂ) : ‖fderiv ℝ (fun w => f (r⁻¹ • w)) z‖ = r⁻¹ * ‖fderiv ℝ f (r⁻¹ • z)‖ := by have he := congrArg (fun g => ‖g z‖) (iteratedFDeriv_comp_const_smul r⁻¹ (hf.of_le (by simp : (1:ℕ∞ω) ≤ ∞))) simpa only [norm_iteratedFDeriv_one, pow_one, norm_smul, Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] using he lemma norm_second_rescale {f : ℂ → E} (hf : ContDiff ℝ ∞ f) {r : ℝ} (_hr : 0 < r) (z : ℂ) : ‖iteratedFDeriv ℝ 2 (fun w => f (r⁻¹ • w)) z‖ = (r^2)⁻¹ * ‖iteratedFDeriv ℝ 2 f (r⁻¹ • z)‖ := by have he := congrArg (fun g => ‖g z‖) (iteratedFDeriv_comp_const_smul r⁻¹ (hf.of_le (show (2:ℕ∞ω) ≤ ∞ from WithTop.coe_le_coe.mpr le_top))) simpa only [norm_smul, inv_pow, Real.norm_of_nonneg (inv_nonneg.mpr (sq_nonneg r))] using he end section open scoped ContDiff Topology open Set Filter MeasureTheory def schauderBump : ContDiffBump (0:ℂ) where rIn := 3/2 rOut := 2 rIn_pos := by norm_num rIn_lt_rOut := by norm_num def scaledSchauderBump (r : ℝ) (z : ℂ) : ℝ := schauderBump (r⁻¹ • z) lemma scaledSchauderBump_smooth (r : ℝ) : ContDiff ℝ ∞ (scaledSchauderBump r) := schauderBump.contDiff.comp (contDiff_id.const_smul r⁻¹) lemma scaledSchauderBump_compact {r : ℝ} (hr : 0 < r) : HasCompactSupport (scaledSchauderBump r) := schauderBump.hasCompactSupport.comp_smul (inv_ne_zero hr.ne') lemma scaledSchauderBump_range (r : ℝ) (z : ℂ) : scaledSchauderBump r z ∈ Icc (0:ℝ) 1 := ⟨schauderBump.nonneg, schauderBump.le_one⟩ lemma scaledSchauderBump_tsupport {r : ℝ} (hr : 0 < r) : tsupport (scaledSchauderBump r) ⊆ Metric.closedBall (0:ℂ) (2*r) := by apply closure_minimal _ Metric.isClosed_closedBall intro z hz have hz' : r⁻¹ • z ∈ Function.support schauderBump := hz rw [schauderBump.support_eq] at hz' simp only [Metric.mem_ball, dist_zero_right, norm_smul, Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] at hz' change r⁻¹ * ‖z‖ < 2 at hz' rw [Metric.mem_closedBall, dist_zero_right] rw [inv_mul_eq_div, div_lt_iff₀ hr] at hz' exact hz'.le lemma scaledSchauderBump_eventually_one {r : ℝ} (hr : 0 < r) {z : ℂ} (hz : ‖z‖ ≤ r) : scaledSchauderBump r =ᶠ[𝓝 z] (fun _ => 1) := by have ht : r⁻¹ • z ∈ Metric.ball (0:ℂ) schauderBump.rIn := by simp only [Metric.mem_ball, dist_zero_right, norm_smul, Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] change r⁻¹ * ‖z‖ < 3/2 have : r⁻¹ * ‖z‖ ≤ 1 := by rwa [inv_mul_eq_div, div_le_one hr] linarith exact (schauderBump.eventuallyEq_one_of_mem_ball ht).comp_tendsto ((continuous_id.const_smul r⁻¹).tendsto z) lemma scaledSchauderBump_homogeneous_bounds : ∃ M : ℝ, 0 ≤ M ∧ ∀ r : ℝ, 0 < r → ∀ z : ℂ, z ≠ 0 → ‖fderiv ℝ (scaledSchauderBump r) z‖ ≤ 2*M/‖z‖ ∧ ‖iteratedFDeriv ℝ 2 (scaledSchauderBump r) z‖ ≤ 4*M/‖z‖^2 := by obtain ⟨M,hM,h0,h1,h2,h3⟩ := (HolderCompletion.boundedCThree_of_compactSupport schauderBump.contDiff schauderBump.hasCompactSupport).bounded refine ⟨M,hM,?_⟩ intro r hr z hz have hp : 0 < ‖z‖ := norm_pos_iff.mpr hz by_cases ht : z ∈ tsupport (scaledSchauderBump r) · have hz2 : ‖z‖ ≤ 2*r := by simpa only [Metric.mem_closedBall, dist_zero_right] using scaledSchauderBump_tsupport hr ht constructor · change ‖fderiv ℝ (fun w => schauderBump (r⁻¹ • w)) z‖ ≤ _ rw [norm_first_rescale schauderBump.contDiff hr] calc _ ≤ r⁻¹*M := mul_le_mul_of_nonneg_left (h1 _) (inv_nonneg.mpr hr.le) _ ≤ _ := by rw [inv_mul_eq_div, div_le_div_iff₀ hr hp]; nlinarith · change ‖iteratedFDeriv ℝ 2 (fun w => schauderBump (r⁻¹ • w)) z‖ ≤ _ rw [norm_second_rescale schauderBump.contDiff hr] calc _ ≤ (r^2)⁻¹*M := mul_le_mul_of_nonneg_left (by rw [norm_second_jet]; exact h2 _) (inv_nonneg.mpr (sq_nonneg r)) _ ≤ _ := by rw [inv_mul_eq_div, div_le_div_iff₀ (sq_pos_of_pos hr) (sq_pos_of_pos hp)] have : ‖z‖^2 ≤ 4*r^2 := by nlinarith nlinarith [mul_le_mul_of_nonneg_left this hM] · have hd : fderiv ℝ (scaledSchauderBump r) z = 0 := fderiv_of_notMem_tsupport (𝕜 := ℝ) ht have hd2 : iteratedFDeriv ℝ 2 (scaledSchauderBump r) z = 0 := by apply image_eq_zero_of_notMem_tsupport exact fun h => ht (tsupport_iteratedFDeriv_subset 2 h) simp only [hd, hd2, norm_zero] constructor <;> positivity lemma smoothCauchyKernel_first_opNorm {δ : ℝ} (hδ : 0 < δ) {z : ℂ} (hz : z ≠ 0) : ‖fderiv ℝ (smoothCauchyKernel δ) z‖ ≤ 3/‖z‖^2 := ContinuousLinearMap.opNorm_le_bound _ (by positivity) (smoothCauchyKernel_fderiv_norm hδ hz) lemma smoothCauchyKernel_second_opNorm {δ : ℝ} (hδ : 0 < δ) {z : ℂ} (hz : z ≠ 0) : ‖iteratedFDeriv ℝ 2 (smoothCauchyKernel δ) z‖ ≤ 14/‖z‖^3 := by rw [norm_second_jet] apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) intro w apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) intro v rw [← second_directional_eq (smoothCauchyKernel_smooth hδ)] convert! smoothCauchyKernel_second_norm hδ hz v w using 1; ring lemma cutoff_smoothCauchyKernel_jet_bounds (b : ContDiffBump (0:ℂ)) : ∃ C₁ C₂ : ℝ, 0 ≤ C₁ ∧ 0 ≤ C₂ ∧ ∀ δ : ℝ, 0 < δ → ∀ z : ℂ, z ≠ 0 → ‖b z • smoothCauchyKernel δ z‖ ≤ ‖z‖⁻¹ ∧ ‖fderiv ℝ (fun w => b w • smoothCauchyKernel δ w) z‖ ≤ C₁/‖z‖^2 ∧ ‖iteratedFDeriv ℝ 2 (fun w => b w • smoothCauchyKernel δ w) z‖ ≤ C₂/‖z‖^3 := by obtain ⟨M,hM,h0,h1,h2,h3⟩ := (HolderCompletion.boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport).bounded have hR := b.rOut_pos refine ⟨M*b.rOut+3, M*b.rOut^2+6*M*b.rOut+14, by positivity, by positivity, ?_⟩ intro δ hδ z hz have hp : 0 < ‖z‖ := norm_pos_iff.mpr hz have hbn : ‖b z‖ ≤ 1 := by simpa only [Real.norm_of_nonneg b.nonneg] using b.le_one refine ⟨?_, ?_⟩ · rw [norm_smul] exact (mul_le_mul hbn (smoothCauchyKernel_norm hδ z) (norm_nonneg _) zero_le_one).trans_eq (one_mul _) by_cases ht : z ∈ tsupport (fun w => b w • smoothCauchyKernel δ w) · have ht' : ‖z‖ ≤ b.rOut := by have := tsupport_smul_subset_left b (smoothCauchyKernel δ) ht simpa only [b.tsupport_eq, Metric.mem_closedBall, dist_zero_right] using this constructor · calc _ ≤ ‖b z‖*‖fderiv ℝ (smoothCauchyKernel δ) z‖ + ‖fderiv ℝ b z‖*‖smoothCauchyKernel δ z‖ := norm_first_smul_le b.contDiff (smoothCauchyKernel_smooth hδ) z _ ≤ 1*(3/‖z‖^2) + M*‖z‖⁻¹ := by exact add_le_add (mul_le_mul hbn (smoothCauchyKernel_first_opNorm hδ hz) (norm_nonneg _) zero_le_one) (mul_le_mul (h1 z) (smoothCauchyKernel_norm hδ z) (norm_nonneg _) hM) _ = (3+M*‖z‖)/‖z‖^2 := by field_simp _ ≤ _ := by apply div_le_div_of_nonneg_right _ (sq_nonneg _) nlinarith [mul_le_mul_of_nonneg_left ht' hM] · calc _ ≤ ‖b z‖*‖iteratedFDeriv ℝ 2 (smoothCauchyKernel δ) z‖ + 2*‖fderiv ℝ b z‖*‖fderiv ℝ (smoothCauchyKernel δ) z‖ + ‖iteratedFDeriv ℝ 2 b z‖*‖smoothCauchyKernel δ z‖ := norm_second_smul_le b.contDiff (smoothCauchyKernel_smooth hδ) z _ ≤ 1*(14/‖z‖^3) + 2*M*(3/‖z‖^2) + M*‖z‖⁻¹ := by apply add_le_add _ (mul_le_mul (by rw [norm_second_jet]; exact h2 z) (smoothCauchyKernel_norm hδ z) (norm_nonneg _) hM) exact add_le_add (mul_le_mul hbn (smoothCauchyKernel_second_opNorm hδ hz) (norm_nonneg _) zero_le_one) (mul_le_mul (mul_le_mul_of_nonneg_left (h1 z) (by norm_num)) (smoothCauchyKernel_first_opNorm hδ hz) (norm_nonneg _) (by positivity)) _ = (14+6*M*‖z‖+M*‖z‖^2)/‖z‖^3 := by field_simp; ring _ ≤ _ := by have hh : ‖z‖^2 ≤ b.rOut^2 := by nlinarith [b.rOut_pos] have ha := mul_le_mul_of_nonneg_left ht' (show 0 ≤ 6*M from by positivity) have hb := mul_le_mul_of_nonneg_left hh hM apply div_le_div_of_nonneg_right _ (by positivity) linarith · have hdz := fderiv_of_notMem_tsupport (𝕜 := ℝ) ht have hd2 : iteratedFDeriv ℝ 2 (fun w => b w • smoothCauchyKernel δ w) z = 0 := by apply image_eq_zero_of_notMem_tsupport exact fun h => ht (tsupport_iteratedFDeriv_subset 2 h) simp only [hdz, hd2, norm_zero] constructor <;> positivity end section open scoped Topology open Set Filter MeasureTheory def schauderNearWeight (z : ℂ) : ℝ := (Metric.closedBall (0:ℂ) 2).indicator (fun w => ‖w‖ ^ (-(5:ℝ)/3)) z def schauderFarWeight (z : ℂ) : ℝ := (Ioi (1:ℝ)).indicator (fun r => r ^ (-(8:ℝ)/3)) ‖z‖ lemma schauderNearWeight_nonneg (z : ℂ) : 0 ≤ schauderNearWeight z := by exact indicator_nonneg (fun w _ => Real.rpow_nonneg (norm_nonneg w) _) z lemma schauderFarWeight_nonneg (z : ℂ) : 0 ≤ schauderFarWeight z := by apply indicator_nonneg _ ‖z‖ intro r hr exact Real.rpow_nonneg (zero_le_one.trans hr.le) _ lemma schauderNearWeight_integrable : Integrable schauderNearWeight := by apply IntegrableOn.integrable_indicator _ measurableSet_closedBall apply LocallyIntegrable.integrableOn_isCompact _ (isCompact_closedBall _ _) apply locallyIntegrable_of_norm_le_rpow (C := 1) (α := (5:ℝ)/3) (by simp) (by norm_num) · exact Eventually.of_forall fun z => by rw [Real.norm_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _), one_mul] norm_num · exact (measurable_norm.pow_const _).aestronglyMeasurable lemma schauderFarWeight_integrable : Integrable schauderFarWeight := by unfold schauderFarWeight rw [integrable_fun_norm_addHaar (volume : Measure ℂ)] have h : Integrable ((Ioi (1:ℝ)).indicator (fun r => r ^ (-(5:ℝ)/3))) := (integrableOn_Ioi_rpow_of_lt (by norm_num : -(5:ℝ)/3 < -1) zero_lt_one).integrable_indicator measurableSet_Ioi apply h.integrableOn.congr_fun _ measurableSet_Ioi intro r hr simp only [Complex.finrank_real_complex, Nat.reduceSub, pow_one, smul_eq_mul] by_cases h1 : 1 < r · rw [indicator_of_mem (show r ∈ Ioi (1:ℝ) from h1), indicator_of_mem (show r ∈ Ioi (1:ℝ) from h1)] have he := Real.rpow_add (show 0 < r from hr) (1:ℝ) (-(8:ℝ)/3) norm_num at he simpa only [neg_div] using he · simp only [indicator_of_notMem (show r ∉ Ioi (1:ℝ) from h1), mul_zero] def scaledSchauderWeight (β : ℝ) (W : ℂ → ℝ) (r : ℝ) (z : ℂ) : ℝ := r ^ β * W (r⁻¹ • z) lemma scaledSchauderWeight_integrable {W : ℂ → ℝ} (hW : Integrable W) (β : ℝ) {r : ℝ} (hr : 0 < r) : Integrable (scaledSchauderWeight β W r) := (hW.comp_smul (inv_ne_zero hr.ne')).const_mul _ lemma integral_scaledSchauderWeight (β : ℝ) (W : ℂ → ℝ) {r : ℝ} (hr : 0 < r) : (∫ z, scaledSchauderWeight β W r z) = r ^ (β+2) * ∫ z, W z := by unfold scaledSchauderWeight rw [integral_const_mul, Measure.integral_comp_inv_smul_of_nonneg volume W hr.le] simp only [Complex.finrank_real_complex, smul_eq_mul] rw [← mul_assoc, ← Real.rpow_two, ← Real.rpow_add hr] lemma scaledNearWeight_value {r : ℝ} (hr : 0 < r) (z : ℂ) : scaledSchauderWeight (-(5:ℝ)/3) schauderNearWeight r z = (Metric.closedBall (0:ℂ) (2*r)).indicator (fun w => ‖w‖^(-(5:ℝ)/3)) z := by have hn : ‖r⁻¹ • z‖ = r⁻¹ * ‖z‖ := by rw [norm_smul, Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] have hm : r⁻¹ • z ∈ Metric.closedBall (0:ℂ) 2 ↔ z ∈ Metric.closedBall (0:ℂ) (2*r) := by simp only [Metric.mem_closedBall, dist_zero_right, hn] rw [inv_mul_eq_div, div_le_iff₀ hr] simp only [scaledSchauderWeight, schauderNearWeight] by_cases hz : z ∈ Metric.closedBall (0:ℂ) (2*r) · rw [indicator_of_mem (hm.mpr hz), indicator_of_mem hz, hn, Real.mul_rpow (inv_nonneg.mpr hr.le) (norm_nonneg z), Real.inv_rpow hr.le, ← mul_assoc, mul_inv_cancel₀ (Real.rpow_pos_of_pos hr _).ne', one_mul] · rw [indicator_of_notMem (fun h => hz (hm.mp h)), indicator_of_notMem hz, mul_zero] lemma scaledFarWeight_value {r : ℝ} (hr : 0 < r) (z : ℂ) : scaledSchauderWeight (-(8:ℝ)/3) schauderFarWeight r z = (Ioi r).indicator (fun t => t^(-(8:ℝ)/3)) ‖z‖ := by have hn : ‖r⁻¹ • z‖ = r⁻¹ * ‖z‖ := by rw [norm_smul, Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] have hm : 1 < ‖r⁻¹ • z‖ ↔ r < ‖z‖ := by rw [hn, inv_mul_eq_div, lt_div_iff₀ hr, one_mul] simp only [scaledSchauderWeight, schauderFarWeight] by_cases hz : r < ‖z‖ · rw [indicator_of_mem (show ‖r⁻¹ • z‖ ∈ Ioi (1:ℝ) from hm.mpr hz), indicator_of_mem (show ‖z‖ ∈ Ioi r from hz), hn, Real.mul_rpow (inv_nonneg.mpr hr.le) (norm_nonneg z), Real.inv_rpow hr.le, ← mul_assoc, mul_inv_cancel₀ (Real.rpow_pos_of_pos hr _).ne', one_mul] · rw [indicator_of_notMem (show ‖r⁻¹ • z‖ ∉ Ioi (1:ℝ) from fun h => hz (hm.mp h)), indicator_of_notMem (show ‖z‖ ∉ Ioi r from hz), mul_zero] end open scoped ContDiff Topology open Set Filter MeasureTheory variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] omit [CompleteSpace E] in lemma compact_kernel_convolution_direction {K : ℂ → ℂ} (hK : ContDiff ℝ ∞ K) (hc : HasCompactSupport K) {g : ℂ → E} (hg : Continuous g) (x v : ℂ) : fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x v = convolution (fun w => fderiv ℝ K w v) g (ContinuousLinearMap.lsmul ℝ ℂ) volume x := by rw [compact_kernel_convolution_fderiv hK hc hg] rfl lemma compact_kernel_convolution_derivative_lipschitz {K : ℂ → ℂ} (hK : ContDiff ℝ ∞ K) (hc : HasCompactSupport K) {g : ℂ → E} (hg : Continuous g) {W : ℂ → ℝ} (hW : Integrable W) (hW0 : ∀ w, 0 ≤ W w) (hb : ∀ x w v t : ℂ, ‖fderiv ℝ (fun y => fderiv ℝ K y v) w t‖ * ‖g (x-w)-g x‖ ≤ W w * ‖v‖ * ‖t‖) (x y : ℂ) : ‖fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x - fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) y‖ ≤ (∫ w, W w) * ‖x-y‖ := by apply ContinuousLinearMap.opNorm_le_bound _ (mul_nonneg (integral_nonneg hW0) (norm_nonneg _)) intro v simp only [sub_apply, compact_kernel_convolution_direction hK hc hg] have hKv : ContDiff ℝ ∞ (fun w => fderiv ℝ K w v) := (hK.fderiv_right (m := ∞) (by simp)).clm_apply contDiff_const have hcKv : HasCompactSupport (fun w => fderiv ℝ K w v) := hc.fderiv_apply (𝕜 := ℝ) v have hMv (z : ℂ) : ‖fderiv ℝ (convolution (fun w => fderiv ℝ K w v) g (ContinuousLinearMap.lsmul ℝ ℂ) volume) z‖ ≤ (∫ w, W w) * ‖v‖ := by have he := compact_kernel_convolution_derivative_bound hKv hcKv hg (hW.mul_const ‖v‖) (fun a w t => hb a w v t) z simpa only [integral_mul_const] using he have he := Convex.norm_image_sub_le_of_norm_fderiv_le (𝕜 := ℝ) (s := (univ : Set ℂ)) (fun z _ => (hcKv.hasFDerivAt_convolution_left (ContinuousLinearMap.lsmul ℝ ℂ) (hKv.of_le (by simp)) hg.locallyIntegrable z).differentiableAt) (fun z _ => hMv z) convex_univ (mem_univ y) (mem_univ x) convert! he using 1 ring omit [CompleteSpace E] in lemma compact_convolution_split_fderiv {K N F : ℂ → ℂ} (hN : ContDiff ℝ ∞ N) (hcN : HasCompactSupport N) (hF : ContDiff ℝ ∞ F) (hcF : HasCompactSupport F) (hKF : ∀ w, K w = N w + F w) {g : ℂ → E} (hg : Continuous g) (x : ℂ) : fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x = fderiv ℝ (convolution N g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x + fderiv ℝ (convolution F g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x := by have he : convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume = convolution N g (ContinuousLinearMap.lsmul ℝ ℂ) volume + convolution F g (ContinuousLinearMap.lsmul ℝ ℂ) volume := by funext z simp only [convolution, hKF, ContinuousLinearMap.map_add, add_apply, Pi.add_apply] exact integral_add (hcN.convolutionExists_left _ hN.continuous hg.locallyIntegrable z) (hcF.convolutionExists_left _ hF.continuous hg.locallyIntegrable z) rw [he] exact fderiv_add (hcN.hasFDerivAt_convolution_left _ (hN.of_le (by simp)) hg.locallyIntegrable x).differentiableAt (hcF.hasFDerivAt_convolution_left _ (hF.of_le (by simp)) hg.locallyIntegrable x).differentiableAt lemma compact_convolution_split_derivative_bound {K N F : ℂ → ℂ} (hN : ContDiff ℝ ∞ N) (hcN : HasCompactSupport N) (hF : ContDiff ℝ ∞ F) (hcF : HasCompactSupport F) (hKF : ∀ w, K w = N w + F w) {g : ℂ → E} (hg : Continuous g) {WN WF : ℂ → ℝ} (hWN : Integrable WN) (hWF : Integrable WF) (hWF0 : ∀ w, 0 ≤ WF w) (hbN : ∀ x w v : ℂ, ‖fderiv ℝ N w v‖ * ‖g (x-w)-g x‖ ≤ WN w * ‖v‖) (hbF : ∀ x w v t : ℂ, ‖fderiv ℝ (fun y => fderiv ℝ F y v) w t‖ * ‖g (x-w)-g x‖ ≤ WF w * ‖v‖ * ‖t‖) (x y : ℂ) : ‖fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) x - fderiv ℝ (convolution K g (ContinuousLinearMap.lsmul ℝ ℂ) volume) y‖ ≤ 2*(∫ w, WN w) + (∫ w, WF w)*‖x-y‖ := by rw [compact_convolution_split_fderiv hN hcN hF hcF hKF hg x, compact_convolution_split_fderiv hN hcN hF hcF hKF hg y] have hbr := compact_kernel_convolution_derivative_lipschitz hF hcF hg hWF hWF0 hbF x y have hx := compact_kernel_convolution_derivative_bound hN hcN hg hWN hbN x have hy := compact_kernel_convolution_derivative_bound hN hcN hg hWN hbN y have halg {A B C D : ℂ →L[ℝ] E} : ‖(A+B)-(C+D)‖ ≤ ‖A‖+‖C‖+‖B-D‖ := by calc _ = ‖(A-C)+(B-D)‖ := by congr 1; abel _ ≤ ‖A-C‖+‖B-D‖ := norm_add_le _ _ _ ≤ _ := add_le_add (norm_sub_le A C) le_rfl exact halg.trans (by linarith) end HigherDimensionalBallPacking.Rigidity end end OAI