| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped ContDiff ENNReal Pointwise Classical |
|
|
| namespace PackingSufficiencySupport |
|
|
| abbrev Ambient (n : ℕ) := Fin n → ℂ |
|
|
| def capacity {n : ℕ} (z : Ambient n) : ℝ := |
| Real.pi * ∑ j, Complex.normSq (z j) |
|
|
| def closedBall (n : ℕ) (R : ℝ) : Set (Ambient n) := |
| {z | capacity z ≤ R} |
|
|
| def openBall (n : ℕ) (R : ℝ) : Set (Ambient n) := |
| {z | capacity z < R} |
|
|
| def standardForm {n : ℕ} (v w : Ambient n) : ℝ := |
| ∑ j, ((v j).re * (w j).im - (v j).im * (w j).re) |
|
|
| def IsBallEmbedding {n : ℕ} (r : ℝ) (f : Ambient n → Ambient n) : Prop := |
| ∃ U : Set (Ambient n), IsOpen U ∧ closedBall n r ⊆ U ∧ |
| ContDiffOn ℝ ∞ f U ∧ |
| Topology.IsEmbedding (fun x : U => f x) ∧ |
| ∀ x ∈ U, ∀ v w : Ambient n, |
| standardForm (fderiv ℝ f x v) (fderiv ℝ f x w) = standardForm v w |
|
|
| def HasPacking (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop := |
| ∃ f : Fin k → Ambient n → Ambient n, |
| (∀ i, IsBallEmbedding (r i) (f i)) ∧ |
| (∀ i, f i '' closedBall n (r i) ⊆ openBall n R) ∧ |
| (∀ i j, i ≠ j → Disjoint (f i '' closedBall n (r i)) |
| (f j '' closedBall n (r j))) |
|
|
| theorem isBallEmbedding_id (n : ℕ) (r : ℝ) : |
| IsBallEmbedding r (id : Ambient n → Ambient n) := by |
| refine ⟨Set.univ, isOpen_univ, Set.subset_univ _, contDiff_id.contDiffOn, ?_, ?_⟩ |
| · simpa only [id_eq] using (Topology.IsEmbedding.subtypeVal (p := fun x : Ambient n => x ∈ (Set.univ : Set (Ambient n)))) |
| · intro x _ v w |
| simp |
|
|
| def realCoordinates (n : ℕ) : Ambient n ≃ₗ[ℝ] ((Fin n ⊕ Fin n) → ℝ) where |
| toFun z := Sum.elim (fun j => (z j).re) (fun j => (z j).im) |
| invFun v := fun j => ⟨v (Sum.inl j), v (Sum.inr j)⟩ |
| left_inv z := by rfl |
| right_inv v := by funext i; cases i <;> rfl |
| map_add' z w := by funext i; cases i <;> rfl |
| map_smul' r z := by funext i; cases i <;> simp |
|
|
| def realBasis (n : ℕ) : Module.Basis (Fin n ⊕ Fin n) ℝ (Ambient n) := |
| Module.Basis.ofEquivFun (realCoordinates n) |
|
|
| @[simp] |
| theorem realBasis_repr {n : ℕ} (v : Ambient n) (i : Fin n ⊕ Fin n) : |
| (realBasis n).repr v i = realCoordinates n v i := by |
| exact Module.Basis.ofEquivFun_repr_apply _ _ _ |
|
|
| theorem matrix_J_pairing {n : ℕ} (A : Matrix (Fin n ⊕ Fin n) (Fin n ⊕ Fin n) ℝ) |
| (i j : Fin n ⊕ Fin n) : |
| (A.transpose * Matrix.J (Fin n) ℝ * A) i j = |
| ∑ k, (A (Sum.inr k) i * A (Sum.inl k) j - |
| A (Sum.inl k) i * A (Sum.inr k) j) := by |
| simp [Matrix.mul_apply, Matrix.J, Fintype.sum_sum_type, Matrix.fromBlocks, |
| Matrix.one_apply, Finset.sum_add_distrib, sub_eq_add_neg] |
|
|
| theorem det_eq_one_of_preserves_standardForm {n : ℕ} |
| (L : Ambient n →ₗ[ℝ] Ambient n) |
| (hL : ∀ v w, standardForm (L v) (L w) = standardForm v w) : |
| LinearMap.det L = 1 := by |
| let b := realBasis n |
| let M := LinearMap.toMatrix b b L |
| have pair (T : Ambient n →ₗ[ℝ] Ambient n) (i j : Fin n ⊕ Fin n) : |
| ((LinearMap.toMatrix b b T).transpose * Matrix.J (Fin n) ℝ * |
| LinearMap.toMatrix b b T) i j = - standardForm (T (b i)) (T (b j)) := by |
| rw [matrix_J_pairing] |
| simp only [LinearMap.toMatrix_apply, b, realBasis_repr] |
| change (∑ k, ((T (realBasis n i) k).im * (T (realBasis n j) k).re - |
| (T (realBasis n i) k).re * (T (realBasis n j) k).im)) = |
| -(∑ k, ((T (realBasis n i) k).re * (T (realBasis n j) k).im - |
| (T (realBasis n i) k).im * (T (realBasis n j) k).re)) |
| rw [← Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro k _ |
| ring |
| have hM : M ∈ Matrix.symplecticGroup (Fin n) ℝ := by |
| apply SymplecticGroup.mem_iff'.mpr |
| ext i j |
| change (M.transpose * Matrix.J (Fin n) ℝ * M) i j = _ |
| rw [show (M.transpose * Matrix.J (Fin n) ℝ * M) i j = |
| -standardForm (L (b i)) (L (b j)) from pair L i j, hL] |
| simpa using (pair LinearMap.id i j).symm |
| rw [← LinearMap.det_toMatrix b L] |
| exact SymplecticGroup.det_eq_one hM |
|
|
| @[fun_prop] |
| theorem continuous_capacity (n : ℕ) : Continuous (capacity : Ambient n → ℝ) := by |
| unfold capacity |
| fun_prop |
|
|
| theorem closedBall_isClosed (n : ℕ) (R : ℝ) : IsClosed (closedBall n R) := |
| isClosed_le (continuous_capacity n) continuous_const |
|
|
| theorem openBall_isOpen (n : ℕ) (R : ℝ) : IsOpen (openBall n R) := |
| isOpen_lt (continuous_capacity n) continuous_const |
|
|
| theorem closedBall_isCompact (n : ℕ) (R : ℝ) : IsCompact (closedBall n R) := by |
| apply (isCompact_closedBall (0 : Ambient n) (max R 0 + 1)).of_isClosed_subset |
| (closedBall_isClosed n R) |
| intro z hz |
| rw [Metric.mem_closedBall, dist_zero_right] |
| apply (pi_norm_le_iff_of_nonneg (by positivity : 0 ≤ max R 0 + 1)).mpr |
| intro j |
| have hj : Complex.normSq (z j) ≤ ∑ k, Complex.normSq (z k) := |
| Finset.single_le_sum (fun k _ => Complex.normSq_nonneg (z k)) (Finset.mem_univ j) |
| have hj' := mul_le_mul_of_nonneg_left hj Real.pi_pos.le |
| have hq : 0 ≤ Complex.normSq (z j) := Complex.normSq_nonneg (z j) |
| have hs : (∑ k, Complex.normSq (z k)) * Real.pi ≤ R := by |
| simpa [closedBall, capacity, mul_comm] using hz |
| have hb : Complex.normSq (z j) ≤ max R 0 := by |
| nlinarith [Real.pi_gt_three, le_max_left R 0] |
| rw [Complex.normSq_eq_norm_sq] at hb |
| have hm := le_max_right R 0 |
| nlinarith [sq_nonneg (‖z j‖ - 1)] |
|
|
| open MeasureTheory |
|
|
| theorem IsBallEmbedding.volume_image {n : ℕ} {r : ℝ} |
| {f : Ambient n → Ambient n} (hf : IsBallEmbedding r f) : |
| volume (f '' closedBall n r) = volume (closedBall n r) := by |
| rcases hf with ⟨U, hU, hsub, hsmooth, hembed, hform⟩ |
| have hdiff : ∀ x ∈ closedBall n r, |
| HasFDerivWithinAt f (fderiv ℝ f x) (closedBall n r) x := by |
| intro x hx |
| exact ((hsmooth.differentiableOn (by simp)).differentiableAt |
| (hU.mem_nhds (hsub hx))).hasFDerivAt.hasFDerivWithinAt |
| have hinj : Set.InjOn f (closedBall n r) := by |
| intro x hx y hy hxy |
| exact congrArg Subtype.val (hembed.injective |
| (show f (⟨x, hsub hx⟩ : U) = f (⟨y, hsub hy⟩ : U) from hxy)) |
| have hs := (closedBall_isClosed n r).measurableSet |
| calc |
| volume (f '' closedBall n r) = ∫⁻ x in closedBall n r, |
| ENNReal.ofReal |(fderiv ℝ f x).det| := |
| (lintegral_abs_det_fderiv_eq_addHaar_image volume hs hdiff hinj).symm |
| _ = ∫⁻ _ in closedBall n r, (1 : ℝ≥0∞) := by |
| apply setLIntegral_congr_fun hs |
| intro x hx |
| have hd := det_eq_one_of_preserves_standardForm (fderiv ℝ f x).toLinearMap |
| (hform x (hsub hx)) |
| simp [show (fderiv ℝ f x).det = 1 from hd] |
| _ = volume (closedBall n r) := by simp |
|
|
| @[simp] |
| theorem capacity_zero (n : ℕ) : capacity (0 : Ambient n) = 0 := by |
| simp [capacity] |
|
|
| theorem capacity_smul {n : ℕ} (t : ℝ) (z : Ambient n) : |
| capacity (t • z) = t ^ 2 * capacity z := by |
| simp only [capacity, Pi.smul_apply, Complex.normSq_eq_norm_sq, norm_smul, |
| Real.norm_eq_abs, mul_pow, sq_abs, ← Finset.mul_sum] |
| ring |
|
|
| theorem closedBall_eq_smul {n : ℕ} {r : ℝ} (hr : 0 < r) : |
| closedBall n r = Real.sqrt r • closedBall n 1 := by |
| ext z |
| constructor |
| · intro hz |
| refine ⟨(Real.sqrt r)⁻¹ • z, ?_, ?_⟩ |
| · change capacity ((Real.sqrt r)⁻¹ • z) ≤ 1 |
| rw [capacity_smul, inv_pow, Real.sq_sqrt hr.le, ← div_eq_inv_mul, |
| div_le_iff₀ hr] |
| simpa [closedBall] using hz |
| · simp [smul_smul, ne_of_gt (Real.sqrt_pos.mpr hr)] |
| · rintro ⟨w, hw, rfl⟩ |
| change capacity (Real.sqrt r • w) ≤ r |
| rw [capacity_smul, Real.sq_sqrt hr.le] |
| simpa using mul_le_mul_of_nonneg_left hw hr.le |
|
|
| theorem volume_closedBall {n : ℕ} {r : ℝ} (hr : 0 < r) : |
| volume (closedBall n r) = ENNReal.ofReal (r ^ n) * volume (closedBall n 1) := by |
| rw [closedBall_eq_smul hr, Measure.addHaar_smul] |
| have hd : Module.finrank ℝ (Ambient n) = 2 * n := by |
| simp [Ambient, Module.finrank_pi_fintype, Complex.finrank_real_complex, mul_comm] |
| rw [hd, pow_mul, Real.sq_sqrt hr.le, abs_of_pos (pow_pos hr n)] |
|
|
| theorem capacity_nonneg {n : ℕ} (z : Ambient n) : 0 ≤ capacity z := |
| mul_nonneg Real.pi_pos.le (Finset.sum_nonneg fun j _ => Complex.normSq_nonneg (z j)) |
|
|
| theorem unitBall_volume_pos (n : ℕ) : 0 < volume (closedBall n 1) := by |
| have hp : 0 < volume (openBall n 1) := |
| (openBall_isOpen n 1).measure_pos volume ⟨0, by simp [openBall]⟩ |
| exact hp.trans_le (measure_mono (fun _ hx => (show capacity _ < 1 from hx).le)) |
|
|
| theorem unitBall_volume_ne_top (n : ℕ) : volume (closedBall n 1) ≠ ⊤ := |
| (closedBall_isCompact n 1).measure_lt_top.ne |
|
|
| theorem IsBallEmbedding.closedBall_continuousOn {n : ℕ} {r : ℝ} |
| {f : Ambient n → Ambient n} (hf : IsBallEmbedding r f) : |
| ContinuousOn f (closedBall n r) := by |
| rcases hf with ⟨U, _, hsub, hsmooth, _, _⟩ |
| exact hsmooth.continuousOn.mono hsub |
|
|
| theorem IsBallEmbedding.isCompact_image {n : ℕ} {r : ℝ} |
| {f : Ambient n → Ambient n} (hf : IsBallEmbedding r f) : |
| IsCompact (f '' closedBall n r) := |
| (closedBall_isCompact n r).image_of_continuousOn hf.closedBall_continuousOn |
|
|
| theorem HasPacking.exists_smaller_target {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hR : 0 < R) (hp : HasPacking n k R r) : |
| ∃ σ, 0 < σ ∧ σ < R ∧ HasPacking n k σ r := by |
| rcases hp with ⟨f, hf, htarget, hdisj⟩ |
| let S : Set (Ambient n) := ⋃ i, f i '' closedBall n (r i) |
| have hc : IsCompact (insert 0 S) := |
| (isCompact_iUnion (fun i => (hf i).isCompact_image)).insert 0 |
| obtain ⟨z, hz, hmax⟩ := hc.exists_isMaxOn (Set.insert_nonempty 0 S) |
| (continuous_capacity n).continuousOn |
| have hS : insert (0 : Ambient n) S ⊆ openBall n R := by |
| intro y hy |
| rcases hy with rfl | hy |
| · simpa [openBall] using hR |
| · rcases Set.mem_iUnion.mp hy with ⟨i, hi⟩ |
| exact htarget i hi |
| have hzR : capacity z < R := hS hz |
| refine ⟨(capacity z + R) / 2, ?_, ?_, f, hf, ?_, hdisj⟩ |
| · linarith [capacity_nonneg z] |
| · linarith |
| · intro i y hy |
| have hm : capacity y ≤ capacity z := hmax (Set.mem_insert_of_mem 0 |
| (Set.mem_iUnion.mpr ⟨i, hy⟩)) |
| change capacity y < (capacity z + R) / 2 |
| linarith |
|
|
| theorem HasPacking.volume_le {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hR : 0 < R) (hr : ∀ i, 0 < r i) (hp : HasPacking n k R r) : |
| ∑ i, (r i) ^ n ≤ R ^ n := by |
| rcases hp with ⟨f, hf, htarget, hdisj⟩ |
| have hm : volume (⋃ i, f i '' closedBall n (r i)) ≤ volume (closedBall n R) := by |
| apply measure_mono |
| intro z hz |
| rcases Set.mem_iUnion.mp hz with ⟨i, hi⟩ |
| exact (show capacity z < R from htarget i hi).le |
| rw [measure_iUnion hdisj (fun i => (hf i).isCompact_image.measurableSet), |
| tsum_fintype] at hm |
| simp_rw [(hf _).volume_image, volume_closedBall (hr _)] at hm |
| rw [volume_closedBall hR, ← Finset.sum_mul] at hm |
| have he := (ENNReal.mul_le_mul_iff_left (unitBall_volume_pos n).ne' |
| (unitBall_volume_ne_top n)).mp hm |
| rw [← ENNReal.ofReal_sum_of_nonneg (fun i _ => pow_nonneg (hr i).le n)] at he |
| exact (ENNReal.ofReal_le_ofReal_iff (pow_nonneg hR.le n)).mp he |
|
|
| theorem HasPacking.volume_lt {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hn : 0 < n) (hR : 0 < R) (hr : ∀ i, 0 < r i) |
| (hp : HasPacking n k R r) : ∑ i, (r i) ^ n < R ^ n := by |
| obtain ⟨σ, hσ, hσR, hpσ⟩ := hp.exists_smaller_target hR |
| exact (hpσ.volume_le hσ hr).trans_lt (pow_lt_pow_left₀ hσR hσ.le hn.ne') |
|
|
| def dilation (n : ℕ) (t : ℝ) (ht : t ≠ 0) : Ambient n ≃L[ℝ] Ambient n := |
| (LinearEquiv.smulOfNeZero ℝ (Ambient n) t ht).toContinuousLinearEquiv |
|
|
| @[simp] theorem dilation_apply (n : ℕ) (t : ℝ) (ht : t ≠ 0) (z : Ambient n) : |
| dilation n t ht z = t • z := rfl |
|
|
| @[simp] theorem dilation_symm_apply (n : ℕ) (t : ℝ) (ht : t ≠ 0) (z : Ambient n) : |
| (dilation n t ht).symm z = t⁻¹ • z := rfl |
|
|
| theorem IsBallEmbedding.dilate {n : ℕ} {r t : ℝ} {f : Ambient n → Ambient n} |
| (hf : IsBallEmbedding r f) (ht : t ≠ 0) : |
| IsBallEmbedding (t ^ 2 * r) (fun z => t • f (t⁻¹ • z)) := by |
| let e := dilation n t ht |
| rcases hf with ⟨U, hU, hsub, hsmooth, hembed, hform⟩ |
| have hmaps : Set.MapsTo e.symm (e '' U) U := by |
| rintro _ ⟨x, hx, rfl⟩ |
| simpa using hx |
| refine ⟨e '' U, e.isOpenMap _ hU, ?_, ?_, ?_, ?_⟩ |
| · intro z hz |
| refine ⟨e.symm z, hsub ?_, e.apply_symm_apply z⟩ |
| change capacity (t⁻¹ • z) ≤ r |
| rw [capacity_smul, inv_pow, ← div_eq_inv_mul, div_le_iff₀ (sq_pos_of_ne_zero ht)] |
| simpa [closedBall, mul_comm] using hz |
| · exact (hsmooth.comp e.symm.contDiff.contDiffOn hmaps).const_smul t |
| · exact e.toHomeomorph.isEmbedding.comp (hembed.comp (e.toHomeomorph.image U).symm.isEmbedding) |
| · intro z hz v w |
| have hd := ((hsmooth.differentiableOn (by simp)).differentiableAt |
| (hU.mem_nhds (hmaps hz))).hasFDerivAt |
| have hchain := (e.hasFDerivAt.comp z (hd.comp z e.symm.hasFDerivAt)) |
| have heq : e.toContinuousLinearMap.comp |
| ((fderiv ℝ f (e.symm z)).comp e.symm.toContinuousLinearMap) = |
| fderiv ℝ f (e.symm z) := by |
| apply ContinuousLinearMap.ext |
| intro a |
| change t • (fderiv ℝ f (e.symm z) (t⁻¹ • a)) = _ |
| rw [map_smul, smul_smul, mul_inv_cancel₀ ht, one_smul] |
| rw [heq] at hchain |
| have hdg : fderiv ℝ (fun z => t • f (t⁻¹ • z)) z = fderiv ℝ f (e.symm z) := |
| hchain.fderiv |
| rw [hdg] |
| exact hform _ (hmaps hz) v w |
|
|
| theorem HasPacking.dilate {n k : ℕ} {R t : ℝ} {r : Fin k → ℝ} |
| (hp : HasPacking n k R r) (ht : t ≠ 0) : |
| HasPacking n k (t ^ 2 * R) (fun i => t ^ 2 * r i) := by |
| rcases hp with ⟨f, hf, htarget, hdisj⟩ |
| have hsource {a : ℝ} {z : Ambient n} (hz : z ∈ closedBall n (t ^ 2 * a)) : |
| t⁻¹ • z ∈ closedBall n a := by |
| change capacity (t⁻¹ • z) ≤ a |
| rw [capacity_smul, inv_pow, ← div_eq_inv_mul, div_le_iff₀ (sq_pos_of_ne_zero ht)] |
| simpa [closedBall, mul_comm] using hz |
| refine ⟨fun i z => t • f i (t⁻¹ • z), fun i => (hf i).dilate ht, ?_, ?_⟩ |
| · intro i z hz |
| rcases hz with ⟨x, hx, rfl⟩ |
| change capacity (t • f i (t⁻¹ • x)) < t ^ 2 * R |
| rw [capacity_smul] |
| exact mul_lt_mul_of_pos_left (htarget i ⟨_, hsource hx, rfl⟩) (sq_pos_of_ne_zero ht) |
| · intro i j hij |
| apply Set.disjoint_left.mpr |
| rintro z ⟨x, hx, rfl⟩ ⟨y, hy, heq⟩ |
| have heq' : f j (t⁻¹ • y) = f i (t⁻¹ • x) := by |
| have := congrArg (fun z : Ambient n => t⁻¹ • z) heq |
| simpa [smul_smul, ht] using this |
| exact Set.disjoint_left.mp (hdisj i j hij) |
| ⟨_, hsource hx, rfl⟩ ⟨_, hsource hy, heq'⟩ |
|
|
| theorem hasPacking_normalize {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} (hR : 0 < R) : |
| HasPacking n k R r ↔ HasPacking n k 1 (fun i => r i / R) := by |
| constructor |
| · intro hp |
| have ht : Real.sqrt R⁻¹ ≠ 0 := (Real.sqrt_pos.mpr (inv_pos.mpr hR)).ne' |
| have h := hp.dilate ht |
| simpa only [Real.sq_sqrt (inv_nonneg.mpr hR.le), inv_mul_cancel₀ hR.ne', |
| div_eq_inv_mul] using h |
| · intro hp |
| have ht : Real.sqrt R ≠ 0 := (Real.sqrt_pos.mpr hR).ne' |
| have h := hp.dilate ht |
| simpa only [Real.sq_sqrt hR.le, mul_one, mul_div_cancel₀ _ hR.ne'] using h |
|
|
| theorem IsBallEmbedding.mono {n : ℕ} {r s : ℝ} {f : Ambient n → Ambient n} |
| (hf : IsBallEmbedding r f) (hs : s ≤ r) : IsBallEmbedding s f := by |
| rcases hf with ⟨U, hU, hsub, hsmooth, hembed, hform⟩ |
| exact ⟨U, hU, fun _ hx => hsub (le_trans hx hs), hsmooth, hembed, hform⟩ |
|
|
| theorem HasPacking.mono {n k : ℕ} {R S : ℝ} {r s : Fin k → ℝ} |
| (hp : HasPacking n k R r) (hR : R ≤ S) (hr : ∀ i, s i ≤ r i) : |
| HasPacking n k S s := by |
| rcases hp with ⟨f, hf, htarget, hdisj⟩ |
| have hsub (i) : closedBall n (s i) ⊆ closedBall n (r i) := fun _ hx => le_trans hx (hr i) |
| refine ⟨f, fun i => (hf i).mono (hr i), ?_, ?_⟩ |
| · intro i z hz |
| exact lt_of_lt_of_le (htarget i (Set.image_mono (hsub i) hz)) hR |
| · intro i j hij |
| exact (hdisj i j hij).mono (Set.image_mono (hsub i)) (Set.image_mono (hsub j)) |
|
|
| theorem exists_larger_closedBall_subset {n : ℕ} {r : ℝ} {U : Set (Ambient n)} |
| (hU : IsOpen U) (hsub : closedBall n r ⊆ U) : |
| ∃ s, r < s ∧ closedBall n s ⊆ U := by |
| let S := closedBall n (r + 1) ∩ Uᶜ |
| have hc : IsCompact S := (closedBall_isCompact n (r + 1)).inter_right hU.isClosed_compl |
| by_cases hne : S.Nonempty |
| · obtain ⟨z, hz, hmin⟩ := hc.exists_isMinOn hne (continuous_capacity n).continuousOn |
| have hzcap : r < capacity z := by |
| by_contra h |
| exact hz.2 (hsub (le_of_not_gt h)) |
| obtain ⟨s, hrs, hsm⟩ := exists_between (lt_min (by linarith : r < r + 1) hzcap) |
| refine ⟨s, hrs, ?_⟩ |
| intro x hx |
| by_contra hxU |
| have hxS : x ∈ S := ⟨le_trans hx (min_le_left _ _ |>.trans' hsm.le), hxU⟩ |
| have := hmin hxS |
| have hs : s < capacity z := hsm.trans_le (min_le_right _ _) |
| exact (not_le_of_gt hs) (le_trans this hx) |
| · refine ⟨r + 1, by linarith, ?_⟩ |
| intro x hx |
| by_contra hxU |
| exact hne ⟨x, hx, hxU⟩ |
|
|
| theorem HasPacking.exists_larger_sources {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hp : HasPacking n k R r) : |
| ∃ s : Fin k → ℝ, (∀ i, r i < s i) ∧ HasPacking n k R s := by |
| classical |
| rcases hp with ⟨f, hf, htarget, hdisj⟩ |
| have hdf : Pairwise (fun i j => Disjoint |
| (nhdsSet (f i '' closedBall n (r i))) (nhdsSet (f j '' closedBall n (r j)))) := by |
| intro i j hij |
| exact disjoint_nhdsSet_nhdsSet (hf i).isCompact_image.isClosed |
| (hf j).isCompact_image.isClosed (hdisj i j hij) |
| obtain ⟨O, hO, hOd⟩ := hdf.exists_mem_filter_basis_of_disjoint |
| (fun i => hasBasis_nhdsSet (f i '' closedBall n (r i))) |
| choose U hU hsub hsmooth hembed hform using hf |
| let W (i : Fin k) := U i ∩ f i ⁻¹' (O i ∩ openBall n R) |
| have hW (i : Fin k) : IsOpen (W i) := |
| (hsmooth i).continuousOn.isOpen_inter_preimage (hU i) |
| ((hO i).1.inter (openBall_isOpen n R)) |
| have hWsub (i : Fin k) : closedBall n (r i) ⊆ W i := by |
| intro z hz |
| exact ⟨hsub i hz, (hO i).2 ⟨z, hz, rfl⟩, htarget i ⟨z, hz, rfl⟩⟩ |
| choose s hs hssub using fun i => exists_larger_closedBall_subset (hW i) (hWsub i) |
| refine ⟨s, hs, f, ?_, ?_, ?_⟩ |
| · intro i |
| exact ⟨U i, hU i, fun _ hx => (hssub i hx).1, hsmooth i, hembed i, hform i⟩ |
| · intro i z hz |
| rcases hz with ⟨x, hx, rfl⟩ |
| exact (hssub i hx).2.2 |
| · intro i j hij |
| apply (hOd hij).mono |
| · rintro z ⟨x, hx, rfl⟩ |
| exact (hssub i hx).2.1 |
| · rintro z ⟨x, hx, rfl⟩ |
| exact (hssub j hx).2.1 |
|
|
| theorem hasPacking_one_iff {n : ℕ} {R r : ℝ} (hn : 0 < n) |
| (hR : 0 < R) (hr : 0 < r) : |
| HasPacking n 1 R (fun _ => r) ↔ r < R := by |
| constructor |
| · intro hp |
| have h := hp.volume_lt hn hR (fun _ => hr) |
| simp only [Fin.sum_univ_one] at h |
| exact lt_of_pow_lt_pow_left₀ n hR.le h |
| · intro h |
| refine ⟨fun _ => id, fun _ => isBallEmbedding_id n r, ?_, ?_⟩ |
| · intro i z hz |
| rcases hz with ⟨x, hx, rfl⟩ |
| exact lt_of_le_of_lt hx h |
| · intro i j hij |
| exact False.elim (hij (Subsingleton.elim i j)) |
|
|
| namespace Comparison |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| def convexFunctionSet (S : Set E) (hS : Convex ℝ S) : Set C(S, ℝ) := |
| {f | ∀ (x y : S) (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1), |
| f ⟨a • (x : E) + b • (y : E), hS x.property y.property ha hb hab⟩ ≤ |
| a * f x + b * f y} |
|
|
| abbrev ConvexMaps (S : Set E) (hS : Convex ℝ S) := ↥(convexFunctionSet S hS) |
|
|
| theorem isClosed_convexFunctionSet (S : Set E) (hS : Convex ℝ S) : |
| IsClosed (convexFunctionSet S hS) := by |
| unfold convexFunctionSet |
| simp only [Set.ofPred_forall] |
| repeat' apply isClosed_iInter; intro |
| exact isClosed_le (ContinuousMap.evalCLM ℝ _).continuous |
| (((ContinuousMap.evalCLM ℝ _).continuous.const_mul _).add |
| ((ContinuousMap.evalCLM ℝ _).continuous.const_mul _)) |
|
|
| instance convexMaps_nonempty (S : Set E) (hS : Convex ℝ S) : Nonempty (ConvexMaps S hS) := |
| ⟨⟨0, by simp [convexFunctionSet]⟩⟩ |
|
|
| instance convexMaps_completeSpace (S : Set E) (hS : Convex ℝ S) [CompactSpace S] : |
| CompleteSpace (ConvexMaps S hS) := |
| (isClosed_convexFunctionSet S hS).isComplete.completeSpace_coe |
|
|
| def affineStep {S : Set E} {hS : Convex ℝ S} (lam : ℝ) (hlam : 0 ≤ lam) |
| (Q F : ConvexMaps S hS) : ConvexMaps S hS := |
| ⟨lam • (F : C(S, ℝ)) + (Q : C(S, ℝ)), by |
| intro x y a b ha hb hab |
| have hF := mul_le_mul_of_nonneg_left (F.property x y a b ha hb hab) hlam |
| have hQ := Q.property x y a b ha hb hab |
| change lam * F.val _ + Q.val _ ≤ a * (lam * F.val x + Q.val x) + |
| b * (lam * F.val y + Q.val y) |
| nlinarith⟩ |
|
|
| theorem exists_convex_fixedPoint {S : Set E} {hS : Convex ℝ S} [CompactSpace S] |
| (Q : ConvexMaps S hS) (R : ConvexMaps S hS → ConvexMaps S hS) |
| (hR : ∀ F G, dist (R F) (R G) ≤ dist F G) |
| {lam : ℝ} (hlam : 0 ≤ lam) (hlam1 : lam < 1) : |
| ∃ K : ConvexMaps S hS, R (affineStep lam hlam Q K) = K := by |
| let T : ConvexMaps S hS → ConvexMaps S hS := fun F => R (affineStep lam hlam Q F) |
| have hT : ContractingWith ⟨lam, hlam⟩ T := by |
| refine ⟨hlam1, LipschitzWith.of_dist_le_mul ?_⟩ |
| intro F G |
| apply (hR _ _).trans |
| change dist (lam • (F : C(S, ℝ)) + (Q : C(S, ℝ))) |
| (lam • (G : C(S, ℝ)) + (Q : C(S, ℝ))) ≤ lam * dist (F : C(S, ℝ)) (G : C(S, ℝ)) |
| rw [dist_add_right] |
| simpa [Real.norm_eq_abs, abs_of_nonneg hlam] using dist_smul_le lam F.val G.val |
| exact ⟨hT.fixedPoint T, hT.fixedPoint_isFixedPt⟩ |
|
|
| theorem fixedPoint_negative_maximum {S : Set E} {hS : Convex ℝ S} [CompactSpace S] |
| (h0 : (0 : E) ∈ S) (Q K : ConvexMaps S hS) |
| (R : ConvexMaps S hS → ConvexMaps S hS) (μ : C(S, ℝ) →ₗ[ℝ] ℝ) |
| (hμlower : ∀ (F : C(S, ℝ)) (c : ℝ), (∀ x, c ≤ F x) → c ≤ μ F) |
| (hRmean : ∀ F, μ (R F).val = μ F.val) |
| (hRmin : ∀ F x, (R F).val ⟨0, h0⟩ ≤ (R F).val x) |
| (hRbound : ∀ F (c : ℝ), (∀ x, F.val x ≤ c) → ∀ x, (R F).val x ≤ c) |
| {lam τ m d c MQ : ℝ} (hlam : 0 < lam) (hlam1 : lam < 1) |
| (hτ : 0 < τ) (hτ1 : τ < 1) (hdc : d < c) |
| (hμQ : μ Q.val = -m) (hQbound : ∀ x, Q.val x ≤ MQ) |
| (houter : ∀ x : S, (x : E) ∉ τ • S → Q.val x ≤ -c) |
| (hgap : (1 - lam) * (d + MQ) < lam * (1 - τ) * (m - d)) |
| (hfix : R (affineStep lam hlam.le Q K) = K) : |
| ∀ x, K.val x < -d / (1 - lam) := by |
| let : Nonempty S := ⟨⟨0, h0⟩⟩ |
| have hden : 0 < 1 - lam := sub_pos.mpr hlam1 |
| have hmean : μ K.val = -m / (1 - lam) := by |
| have heq := congrArg (fun F : ConvexMaps S hS => μ F.val) hfix |
| rw [hRmean] at heq |
| change μ (lam • K.val + Q.val) = μ K.val at heq |
| rw [map_add, map_smul, hμQ] at heq |
| apply (eq_div_iff hden.ne').mpr |
| change lam * μ K.val + -m = μ K.val at heq |
| nlinarith |
| have hzero : K.val ⟨0, h0⟩ ≤ μ K.val := by |
| apply hμlower |
| intro x |
| rw [← hfix] |
| exact hRmin _ x |
| obtain ⟨z, _, hz⟩ := isCompact_univ.exists_isMaxOn |
| (Set.univ_nonempty : (Set.univ : Set S).Nonempty) K.val.continuous.continuousOn |
| have hmax (x : S) : K.val x ≤ K.val z := hz (Set.mem_univ x) |
| have hmaxlt : K.val z < -d / (1 - lam) := by |
| by_contra hh |
| have hM : -d / (1 - lam) ≤ K.val z := le_of_not_gt hh |
| have hlamM : lam * K.val z ≤ K.val z + d := by |
| have := (div_le_iff₀ hden).mp hM |
| nlinarith |
| have hgap' : d + MQ < lam * ((1 - τ) * (m - d) / (1 - lam)) := by |
| rw [← mul_div_assoc, lt_div_iff₀ hden] |
| nlinarith [hgap] |
| have hall (x : S) : (affineStep lam hlam.le Q K).val x < K.val z := by |
| change lam * K.val x + Q.val x < K.val z |
| by_cases hx : (x : E) ∈ τ • S |
| · rcases hx with ⟨v, hv, hvx⟩ |
| have hcv : K.val x ≤ (1 - τ) * K.val ⟨0, h0⟩ + τ * K.val ⟨v, hv⟩ := by |
| simpa [hvx] using K.property ⟨0, h0⟩ ⟨v, hv⟩ (1 - τ) τ |
| (sub_nonneg.mpr hτ1.le) hτ.le (by ring) |
| have hinner : K.val x ≤ K.val z - (1 - τ) * (m - d) / (1 - lam) := by |
| calc |
| K.val x ≤ (1 - τ) * (-m / (1 - lam)) + τ * K.val z := |
| hcv.trans (add_le_add |
| (mul_le_mul_of_nonneg_left (hzero.trans_eq hmean) (sub_nonneg.mpr hτ1.le)) |
| (mul_le_mul_of_nonneg_left (hmax _) hτ.le)) |
| _ = K.val z - (1 - τ) * (K.val z + m / (1 - lam)) := by ring |
| _ ≤ K.val z - (1 - τ) * ((m - d) / (1 - lam)) := by |
| have hm : (m - d) / (1 - lam) ≤ K.val z + m / (1 - lam) := by |
| rw [sub_div] |
| have hM' := hM |
| rw [neg_div] at hM' |
| linarith |
| exact sub_le_sub_left |
| (mul_le_mul_of_nonneg_left hm (sub_nonneg.mpr hτ1.le)) _ |
| _ = _ := by ring |
| have hxmul := mul_le_mul_of_nonneg_left hinner hlam.le |
| have hqx := hQbound x |
| nlinarith |
| · have hxmul := mul_le_mul_of_nonneg_left (hmax x) hlam.le |
| have hqx := houter x hx |
| linarith |
| obtain ⟨w, _, hw⟩ := isCompact_univ.exists_isMaxOn |
| (Set.univ_nonempty : (Set.univ : Set S).Nonempty) |
| (affineStep lam hlam.le Q K).val.continuous.continuousOn |
| have hr := hRbound (affineStep lam hlam.le Q K) |
| ((affineStep lam hlam.le Q K).val w) (fun x => hw (Set.mem_univ x)) z |
| rw [hfix] at hr |
| exact (not_lt_of_ge hr) (hall w) |
| exact fun x => (hmax x).trans_lt hmaxlt |
|
|
| end Comparison |
| end PackingSufficiencySupport |
| end |
|
|
| end OAI |
|
|
