| import Mathlib |
| import OAI.Geometry.BallPacking.Necessity.DensityExistence |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped ContDiff Topology |
| open Set Function Filter |
| open scoped ContDiff Topology Manifold |
| open Set Function Filter MeasureTheory |
| open Set Function MeasureTheory |
| open Set Function |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl) |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm radiusSq planarArea planarArea_apply) |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm) |
| open SymplecticBallPacking.Hamiltonian (Plane angularOneForm) |
| open SymplecticBallPacking.Hamiltonian |
| open SymplecticBallPacking.Hamiltonian (Plane) |
| open Set Filter Function |
| open Set Filter MeasureTheory |
| open scoped Topology |
| open Set Filter Finset |
| open scoped ContDiff Topology Classical |
| open Set Filter |
| open scoped BoundedContinuousFunction ContDiff Topology |
| open Set Function Filter Topology |
| open scoped NNReal |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Function |
| open scoped Topology ContDiff |
| open scoped ContDiff Topology Convolution |
| open Set Filter Function MeasureTheory _root_.ContinuousLinearMap _root_.OAI.ContinuousLinearMap |
| open Set Filter Function MeasureTheory |
|
|
| open scoped ContDiff Topology |
| open Set Function Filter |
| namespace HigherDimensionalBallPacking |
| section |
| open Rigidity |
|
|
| theorem normalized_two_ball_obstruction (n : ℕ) (hn : 3 ≤ n) |
| (a b : ℝ) (ha : 0 < a) (hb : 0 < b) (hp : HasPacking n 2 1 ![a,b]) : a+b ≤ 1 := by |
| obtain ⟨J,p,q,hJs,hJ,hJc,hJinside,hpq,harea⟩ := packing_two_line_reduction ha hb hp |
| obtain ⟨u,hu⟩ := actual_affine_line_exists n hn J hJs hJ hJc hJinside p q hpq |
| exact harea u hu |
|
|
| end |
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped ENNReal NNReal Topology ContDiff Pointwise |
| open Set MeasureTheory |
| namespace Rigidity |
|
|
| private def symplecticBilin (n : ℕ) : LinearMap.BilinForm ℝ (Phase n) where |
| toFun u := |
| { toFun := standardForm u |
| map_add' := by |
| intro v w |
| simp only [standardForm, Pi.add_apply, Complex.add_re, Complex.add_im] |
| simp only [mul_add, ← Finset.sum_add_distrib] |
| congr 1 |
| funext i |
| ring |
| map_smul' := by |
| intro c v |
| simp [standardForm, Finset.mul_sum, mul_sub, mul_left_comm] } |
| map_add' := by |
| intro u v |
| apply LinearMap.ext |
| intro w |
| change standardForm (u + v) w = standardForm u w + standardForm v w |
| simp only [standardForm, Pi.add_apply, Complex.add_re, Complex.add_im] |
| simp only [add_mul, ← Finset.sum_add_distrib] |
| congr 1 |
| funext i |
| ring |
| map_smul' := by |
| intro c u |
| apply LinearMap.ext |
| intro v |
| change standardForm (c • u) v = c * standardForm u v |
| simp [standardForm, Finset.mul_sum, mul_sub, mul_assoc] |
|
|
| private theorem symplecticBilin_nondegenerate (n : ℕ) : |
| (symplecticBilin n).Nondegenerate := by |
| apply LinearMap.BilinForm.Nondegenerate.ofSeparatingLeft |
| intro v hv |
| by_contra hn |
| have hp := standardForm_J_pos hn |
| have he := hv (standardJ n v) |
| change standardForm v (standardJ n v) = 0 at he |
| linarith |
|
|
| |
|
|
| theorem abs_det_of_standardForm {n : ℕ} (L : Phase n →L[ℝ] Phase n) |
| (hL : ∀u v, standardForm (L u) (L v) = standardForm u v) : |
| |L.det| = 1 := by |
| let b := Module.Free.chooseBasis ℝ (Phase n) |
| have hB : (symplecticBilin n).comp L.toLinearMap L.toLinearMap = symplecticBilin n := by |
| apply LinearMap.ext |
| intro u |
| apply LinearMap.ext |
| intro v |
| exact hL u v |
| have hdet := congrArg Matrix.det |
| (LinearMap.BilinForm.toMatrix_comp b b (symplecticBilin n) L.toLinearMap L.toLinearMap) |
| rw [hB, Matrix.det_mul, Matrix.det_mul, Matrix.det_transpose, |
| LinearMap.det_toMatrix] at hdet |
| have hn := (LinearMap.BilinForm.nondegenerate_iff_det_ne_zero b).mp |
| (symplecticBilin_nondegenerate n) |
| have hs : L.det ^ 2 = 1 := by |
| change (L.toLinearMap.det) ^ 2 = 1 |
| apply mul_right_cancel₀ hn |
| nlinarith [hdet] |
| nlinarith [sq_abs L.det, abs_nonneg L.det] |
|
|
| |
| theorem symplecticOn_volume_closedBall {n : ℕ} {r : ℝ} |
| {U : Set (Phase n)} {f : Phase n → Phase n} |
| (hf : SymplecticOn U f) (hU : closedBall n r ⊆ U) : |
| volume (f '' closedBall n r) = volume (closedBall n r) := by |
| have hd : ∀ x ∈ closedBall n r, HasFDerivWithinAt f (fderiv ℝ f x) |
| (closedBall n r) x := by |
| intro x hx |
| exact ((hf.2.1.contDiffAt (hf.1.mem_nhds (hU hx))).differentiableAt |
| (by simp)).hasFDerivAt.hasFDerivWithinAt |
| have hi : InjOn f (closedBall n r) := by |
| intro x hx y hy hxy |
| have he := hf.2.2.1.injective (a₁ := ⟨x, hU hx⟩) (a₂ := ⟨y, hU hy⟩) hxy |
| exact congrArg Subtype.val he |
| rw [← lintegral_abs_det_fderiv_eq_addHaar_image volume |
| (closedBall_isClosed n r).measurableSet hd hi] |
| calc |
| (∫⁻ x in closedBall n r, ENNReal.ofReal |(fderiv ℝ f x).det|) = |
| ∫⁻ _ in closedBall n r, (1 : ℝ≥0∞) := by |
| apply setLIntegral_congr_fun (closedBall_isClosed n r).measurableSet |
| intro x hx |
| change ENNReal.ofReal |(fderiv ℝ f x).det| = 1 |
| rw [abs_det_of_standardForm _ (hf.2.2.2 x (hU hx)), ENNReal.ofReal_one] |
| _ = volume (closedBall n r) := by simp |
|
|
| private theorem capacity_real_smul {n : ℕ} (c : ℝ) (z : Phase n) : |
| capacity (c • z) = c ^ 2 * capacity z := by |
| rw [show c • z = (c : ℂ) • z by ext i; simp] |
| rw [capacity_smul_complex] |
| simp [Complex.normSq_ofReal, pow_two] |
|
|
| private theorem closedBall_eq_smul_unit (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_real_smul, inv_pow, Real.sq_sqrt hr.le] |
| change capacity z ≤ r at hz |
| exact (inv_mul_le_iff₀ hr).mpr (by simpa using hz) |
| · exact smul_inv_smul₀ (ne_of_gt (Real.sqrt_pos.mpr hr)) z |
| · rintro ⟨y, hy, rfl⟩ |
| change capacity (Real.sqrt r • y) ≤ r |
| rw [capacity_real_smul, Real.sq_sqrt hr.le] |
| change capacity y ≤ 1 at hy |
| nlinarith |
|
|
| theorem volume_closedBall_capacity (n : ℕ) {r : ℝ} (hr : 0 < r) : |
| volume (closedBall n r) = ENNReal.ofReal (r ^ n) * volume (closedBall n 1) := by |
| rw [closedBall_eq_smul_unit n hr, |
| Measure.addHaar_smul_of_nonneg volume (Real.sqrt_nonneg r)] |
| have hd : Module.finrank ℝ (Phase n) = 2 * n := by |
| simp [Phase, Module.finrank_pi_fintype, Complex.finrank_real_complex, Nat.mul_comm] |
| rw [hd, pow_mul, Real.sq_sqrt hr.le] |
|
|
| private theorem unit_capacity_volume_pos (n : ℕ) : 0 < volume (closedBall n 1) := by |
| apply lt_of_lt_of_le ((openBall_isOpen n 1).measure_pos volume ?_) |
| (measure_mono (show openBall n 1 ⊆ closedBall n 1 from fun _ hz => (show capacity _ ≤ 1 from le_of_lt hz))) |
| exact ⟨0, by simp [openBall, capacity]⟩ |
|
|
| |
| theorem packing_exists_smaller_capacity {n k : ℕ} (hk : 1 ≤ k) |
| {R : ℝ} {r : Fin k → ℝ} (hr : ∀ i, 0 < r i) |
| {U : Fin k → Set (Phase n)} {f : Fin k → Phase n → Phase n} |
| (hf : ∀ i, closedBall n (r i) ⊆ U i ∧ SymplecticOn (U i) (f i) ∧ |
| MapsTo (f i) (closedBall n (r i)) (openBall n R)) : |
| ∃ σ, 0 < σ ∧ σ < R ∧ (⋃ i, f i '' closedBall n (r i)) ⊆ closedBall n σ := by |
| let K := ⋃ i, f i '' closedBall n (r i) |
| have hK : IsCompact K := isCompact_iUnion fun i => |
| (closedBall_isCompact n (r i)).image_of_continuousOn |
| ((hf i).2.1.2.1.continuousOn.mono (hf i).1) |
| have hne : K.Nonempty := by |
| let i : Fin k := ⟨0, by omega⟩ |
| refine ⟨f i 0, mem_iUnion.mpr ⟨i, ⟨0, ?_, rfl⟩⟩⟩ |
| simp only [closedBall, mem_ofPred_eq, capacity, Pi.zero_apply, |
| map_zero, Finset.sum_const_zero, mul_zero] |
| exact (hr i).le |
| obtain ⟨x, hx, hm⟩ := hK.exists_isMaxOn hne (capacity_smooth n).continuous.continuousOn |
| have hxR : capacity x < R := by |
| obtain ⟨i, y, hy, rfl⟩ := mem_iUnion.mp hx |
| exact (hf i).2.2 hy |
| have hx0 : 0 ≤ capacity x := mul_nonneg Real.pi_pos.le |
| (Finset.sum_nonneg fun i _ => Complex.normSq_nonneg _) |
| refine ⟨(capacity x + R) / 2, by linarith, by linarith, ?_⟩ |
| intro y hy |
| have hxy : capacity y ≤ capacity x := hm hy |
| change capacity y ≤ (capacity x + R) / 2 |
| linarith |
|
|
| end Rigidity |
|
|
| |
|
|
| theorem packing_volume_obstruction (n k : ℕ) (hn : 3 ≤ n) (hk : 1 ≤ 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 |
| classical |
| obtain ⟨U, f, hf, hdisj⟩ := hp |
| obtain ⟨σ, hσ, hσR, hsub⟩ := Rigidity.packing_exists_smaller_capacity hk hr hf |
| have hmeas : ∀ i, MeasurableSet (f i '' closedBall n (r i)) := by |
| intro i |
| exact ((Rigidity.closedBall_isCompact n (r i)).image_of_continuousOn |
| ((hf i).2.1.2.1.continuousOn.mono (hf i).1)).measurableSet |
| have hvol : (∑ i, ENNReal.ofReal (r i ^ n)) * volume (closedBall n 1) ≤ |
| ENNReal.ofReal (σ ^ n) * volume (closedBall n 1) := by |
| calc |
| _ = ∑ i, volume (f i '' closedBall n (r i)) := by |
| rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Rigidity.symplecticOn_volume_closedBall (hf i).2.1 (hf i).1, |
| Rigidity.volume_closedBall_capacity n (hr i)] |
| _ = volume (⋃ i, f i '' closedBall n (r i)) := by |
| rw [measure_iUnion hdisj hmeas, tsum_fintype] |
| _ ≤ volume (closedBall n σ) := measure_mono hsub |
| _ = _ := Rigidity.volume_closedBall_capacity n hσ |
| have hV0 := ne_of_gt (Rigidity.unit_capacity_volume_pos n) |
| have hVtop := (Rigidity.closedBall_isCompact n 1).measure_ne_top (μ := volume) |
| rw [mul_comm _ (volume (closedBall n 1)), mul_comm _ (volume (closedBall n 1))] at hvol |
| have hsum := (ENNReal.mul_le_mul_iff_right hV0 hVtop).mp hvol |
| rw [← ENNReal.ofReal_sum_of_nonneg (fun i _ => pow_nonneg (hr i).le n)] at hsum |
| have hreal := ENNReal.toReal_mono ENNReal.ofReal_ne_top hsum |
| simp only [ENNReal.toReal_ofReal (pow_nonneg hσ.le n), |
| ENNReal.toReal_ofReal (Finset.sum_nonneg (fun i _ => pow_nonneg (hr i).le n))] at hreal |
| exact hreal.trans_lt (pow_lt_pow_left₀ hσR hσ.le (by omega)) |
|
|
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped ContDiff Topology |
| open Set Function |
| section |
| namespace Rigidity |
|
|
| def packingDilation (n : ℕ) (c : ℝ) (hc : c≠0) : Phase n ≃L[ℝ] Phase n := |
| ContinuousLinearEquiv.smulLeft (R₁ := ℝ) (M₁ := Phase n) (Units.mk0 c hc) |
|
|
| @[simp] theorem packingDilation_apply (n : ℕ) (c : ℝ) (hc : c≠0) (x : Phase n) : |
| packingDilation n c hc x=c • x := rfl |
| @[simp] theorem packingDilation_symm_apply (n : ℕ) (c : ℝ) (hc : c≠0) (x : Phase n) : |
| (packingDilation n c hc).symm x=c⁻¹ • x := rfl |
|
|
| theorem capacity_smul_real {n : ℕ} (c : ℝ) (x : Phase n) : |
| capacity (c • x)=c^2*capacity x := by |
| rw [←Complex.coe_smul,capacity_smul_complex,Complex.normSq_ofReal,pow_two] |
|
|
| theorem standardForm_smul_real_same {n : ℕ} (c : ℝ) (x v : Phase n) : |
| standardForm (c • x) (c • v)=c^2*standardForm x v := by |
| rw [←Complex.coe_smul,←Complex.coe_smul,standardForm_smul_complex_same,Complex.normSq_ofReal,pow_two] |
|
|
| theorem symplecticOn_dilation {n : ℕ} {U : Set (Phase n)} {f : Phase n → Phase n} |
| (hf : SymplecticOn U f) (c : ℝ) (hc : c≠0) : |
| SymplecticOn ((packingDilation n c hc) ⁻¹' U) |
| (fun x => (packingDilation n c hc).symm (f (packingDilation n c hc x))) := by |
| let D := packingDilation n c hc |
| have ho : IsOpen (D ⁻¹' U) := hf.1.preimage D.continuous |
| refine ⟨ho,?_,?_,?_⟩ |
| · apply ho.contDiffOn_iff.mpr |
| intro x hx |
| exact D.symm.contDiff.contDiffAt.comp x |
| ((hf.2.1.contDiffAt (hf.1.mem_nhds hx)).comp x D.contDiff.contDiffAt) |
| · let e : (D ⁻¹' U) ≃ₜ U := D.toHomeomorph.sets rfl |
| exact D.symm.toHomeomorph.isEmbedding.comp (hf.2.2.1.comp e.isEmbedding) |
| · intro x hx v w |
| have hdf : HasFDerivAt f (fderiv ℝ f (D x)) (D x) := |
| (hf.2.1.contDiffAt (hf.1.mem_nhds hx)).differentiableAt (by simp) |>.hasFDerivAt |
| have hd := D.symm.hasFDerivAt.comp x (hdf.comp x D.hasFDerivAt) |
| change standardForm (fderiv ℝ (D.symm ∘ f ∘ D) x v) (fderiv ℝ (D.symm ∘ f ∘ D) x w)=standardForm v w |
| rw [hd.fderiv] |
| change standardForm (c⁻¹ • fderiv ℝ f (D x) (c • v)) |
| (c⁻¹ • fderiv ℝ f (D x) (c • w))=standardForm v w |
| rw [standardForm_smul_real_same,hf.2.2.2 (D x) hx,standardForm_smul_real_same] |
| field_simp |
| |
| end Rigidity |
| open Rigidity |
| |
| theorem packing_dilation {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hp : HasPacking n k R r) (c : ℝ) (hc : c≠0) : |
| HasPacking n k (R/c^2) (fun i => r i/c^2) := by |
| obtain ⟨U,f,hf,hd⟩ := hp |
| let D := packingDilation n c hc |
| have hc2 : 0<c^2 := sq_pos_of_ne_zero hc |
| refine ⟨(fun i => D ⁻¹' U i),(fun i x => D.symm (f i (D x))),?_,?_⟩ |
| · intro i |
| have hmem (x : Phase n) (hx : x∈closedBall n (r i/c^2)) : D x∈closedBall n (r i) := by |
| change capacity (c • x)≤r i |
| rw [capacity_smul_real] |
| simpa only [mul_comm] using (le_div_iff₀ hc2).mp hx |
| refine ⟨fun x hx => (hf i).1 (hmem x hx),symplecticOn_dilation (hf i).2.1 c hc,?_⟩ |
| intro x hx |
| have hcap := (hf i).2.2 (hmem x hx) |
| change capacity (c⁻¹ • f i (D x))<R/c^2 |
| rw [capacity_smul_real] |
| simpa only [inv_pow,div_eq_mul_inv,mul_comm] using mul_lt_mul_of_pos_left hcap (inv_pos.mpr hc2) |
| · intro i j hij |
| apply Set.disjoint_left.mpr |
| rintro y ⟨x,hx,rfl⟩ ⟨z,hz,he⟩ |
| have hx' : D x∈closedBall n (r i) := by |
| change capacity (c • x)≤r i |
| rw [capacity_smul_real,mul_comm] |
| exact (le_div_iff₀ hc2).mp hx |
| have hz' : D z∈closedBall n (r j) := by |
| change capacity (c • z)≤r j |
| rw [capacity_smul_real,mul_comm] |
| exact (le_div_iff₀ hc2).mp hz |
| exact Set.disjoint_left.mp (hd i j hij) (mem_image_of_mem _ hx') |
| ⟨D z,hz',D.symm.injective he⟩ |
|
|
| end |
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped ContDiff Topology |
| open Set Function |
| open Rigidity |
|
|
| theorem packing_reindex {n k l : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hp : HasPacking n k R r) (e : Fin l → Fin k) (he : Injective e) : |
| HasPacking n l R (r ∘ e) := by |
| obtain ⟨U,f,hf,hd⟩ := hp |
| exact ⟨U ∘ e,f ∘ e,fun i => hf (e i),fun i j hij => hd (e i) (e j) (he.ne hij)⟩ |
|
|
| theorem packing_two_of_pair {n k : ℕ} {R : ℝ} {r : Fin k → ℝ} |
| (hp : HasPacking n k R r) (i j : Fin k) (hij : i≠j) : |
| HasPacking n 2 R ![r i,r j] := by |
| have he : Injective (![i,j] : Fin 2 → Fin k) := by |
| intro x y hxy |
| fin_cases x <;> fin_cases y <;> simp_all |
| have hr : (r ∘ (![i,j] : Fin 2 → Fin k))=![r i,r j] := by |
| funext x |
| fin_cases x <;> rfl |
| simpa only [hr] using packing_reindex hp (![i,j] : Fin 2 → Fin k) he |
|
|
| theorem two_ball_obstruction (n : ℕ) (hn : 3≤n) (R a b : ℝ) |
| (hR : 0<R) (ha : 0<a) (hb : 0<b) (hp : HasPacking n 2 R ![a,b]) : |
| a+b≤R := by |
| have hsq := Real.sq_sqrt hR.le |
| have hc : Real.sqrt R≠0 := (Real.sqrt_pos.mpr hR).ne' |
| have hp' := packing_dilation hp (Real.sqrt R) hc |
| rw [hsq,div_self hR.ne'] at hp' |
| have hr : (fun i : Fin 2 => ![a,b] i/R)=![a/R,b/R] := by |
| funext i |
| fin_cases i <;> rfl |
| rw [hr] at hp' |
| have h := normalized_two_ball_obstruction n hn (a/R) (b/R) (div_pos ha hR) (div_pos hb hR) hp' |
| rw [←add_div] at h |
| exact (div_le_one hR).mp h |
|
|
| theorem packing_pair_obstruction (n k : ℕ) (hn : 3≤n) (hk : 1≤k) |
| (R : ℝ) (r : Fin k → ℝ) (hr : ∀ i,0<r i) (hp : HasPacking n k R r) : |
| ∀ i j, i≠j → r i+r j<R := by |
| obtain ⟨U,f,hf,hd⟩ := hp |
| obtain ⟨σ,hσ,hσR,hσbound⟩ := packing_exists_smaller_capacity hk hr hf |
| let τ : ℝ := (σ+R)/2 |
| have hστ : σ<τ := by dsimp [τ]; linarith |
| have hτR : τ<R := by dsimp [τ]; linarith |
| have hτ : 0<τ := hσ.trans hστ |
| have hpτ : HasPacking n k τ r := by |
| refine ⟨U,f,?_,hd⟩ |
| intro i |
| refine ⟨(hf i).1,(hf i).2.1,?_⟩ |
| intro x hx |
| have hb := hσbound (mem_iUnion.mpr ⟨i,mem_image_of_mem (f i) hx⟩) |
| exact hb.trans_lt hστ |
| intro i j hij |
| exact (two_ball_obstruction n hn τ (r i) (r j) hτ (hr i) (hr j) |
| (packing_two_of_pair hpτ i j hij)).trans_lt hτR |
|
|
| |
| theorem packing_necessity (n k : ℕ) (hn : 3≤n) (hk : 1≤k) |
| (R : ℝ) (r : Fin k → ℝ) (hR : 0<R) (hr : ∀ i,0<r i) |
| (hp : HasPacking n k R r) : PackingInequalities n k R r := |
| ⟨packing_volume_obstruction n k hn hk R r hR hr hp, |
| packing_pair_obstruction n k hn hk R r hr hp⟩ |
|
|
| end HigherDimensionalBallPacking |
|
|
| end |
|
|
| end OAI |
|
|
