| import Mathlib | |
| import OAI.Geometry.BallPacking.DiskMaps.ParameterRelativeDiskMoser | |
| namespace OAI | |
| noncomputable section | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Topology | |
| open Set Function | |
| open MeasureTheory | |
| open Metric | |
| section | |
| variable (P : Type*) [NormedAddCommGroup P] [NormedSpace ℝ P] | |
| structure ParametricDiskEmbedding (O : Set P) where | |
| radius : ℝ | |
| radius_pos : 0 < radius | |
| map : P × ℂ → ℂ | |
| smooth : ContDiff ℝ ∞ map | |
| domain : Set ℂ | |
| open_domain : IsOpen domain | |
| convex_domain : Convex ℝ domain | |
| subset_domain : Metric.closedBall 0 radius ⊆ domain | |
| injective : ∀ y ∈ O, InjOn (fun x => map (y,x)) domain | |
| nonsingular : ∀ y ∈ O, ∀ x ∈ domain, | |
| (fderiv ℝ (fun x => map (y,x)) x).IsInvertible | |
| orientation : ∀ y ∈ O, 0 < (fderiv ℝ (fun x => map (y,x)) 0).det | |
| variable {P} | |
| namespace ParametricDiskEmbedding | |
| variable {O : Set P} | |
| def carrier (D : ParametricDiskEmbedding P O) (y : P) : Set ℂ := | |
| (fun x => D.map (y,x)) '' Metric.closedBall 0 D.radius | |
| def NestedOn (Y : Set P) (D E : ParametricDiskEmbedding P O) : Prop := | |
| ∀ y ∈ Y, E.carrier y ⊆ interior (D.carrier y) | |
| def eval (D : ParametricDiskEmbedding P O) (y : P) (hy : y ∈ O) : PlanarDiskEmbedding where | |
| radius := D.radius | |
| radius_pos := D.radius_pos | |
| map := fun x => D.map (y,x) | |
| smooth := D.smooth.comp (contDiff_const.prodMk contDiff_id) | |
| domain := D.domain | |
| open_domain := D.open_domain | |
| convex_domain := D.convex_domain | |
| subset_domain := D.subset_domain | |
| injective := D.injective y hy | |
| nonsingular := D.nonsingular y hy | |
| orientation := D.orientation y hy | |
| @[simp] theorem eval_carrier (D : ParametricDiskEmbedding P O) (y : P) (hy : y ∈ O) : | |
| (D.eval y hy).carrier = D.carrier y := rfl | |
| def pull {W : Set ℂ} (D : ParametricDiskEmbedding P O) | |
| (Φ : SupportedSmoothIsotopyFamily P ℂ W) : ParametricDiskEmbedding P O where | |
| radius := D.radius | |
| radius_pos := D.radius_pos | |
| map := fun p => (Φ.map p.1 1).symm (D.map p) | |
| smooth := Φ.endpoint_inverse_smooth.comp (contDiff_fst.prodMk D.smooth) | |
| domain := D.domain | |
| open_domain := D.open_domain | |
| convex_domain := D.convex_domain | |
| subset_domain := D.subset_domain | |
| injective := fun y hy => (Φ.map y 1).symm.injective.injOn.comp (D.injective y hy) (mapsTo_univ _ _) | |
| nonsingular := by | |
| intro y hy x hx | |
| have hd : ContDiff ℝ ∞ (fun x : ℂ => D.map (y,x)) := | |
| D.smooth.comp (contDiff_const.prodMk contDiff_id) | |
| have hdi : ContDiff ℝ ∞ (Φ.map y 1).symm := (Φ.eval y).symm_smooth 1 | |
| change (fderiv ℝ ((Φ.map y 1).symm ∘ (fun x => D.map (y,x))) x).IsInvertible | |
| rw [fderiv_comp x (hdi.differentiable (by simp) _) (hd.differentiable (by simp) x)] | |
| exact ((Φ.eval y).symm.fderiv_isInvertible 1 (D.map (y,x))).comp (D.nonsingular y hy x hx) | |
| orientation := by | |
| intro y hy | |
| have hd : ContDiff ℝ ∞ (fun x : ℂ => D.map (y,x)) := | |
| D.smooth.comp (contDiff_const.prodMk contDiff_id) | |
| have hdi : ContDiff ℝ ∞ (Φ.map y 1).symm := (Φ.eval y).symm_smooth 1 | |
| change 0 < (fderiv ℝ ((Φ.map y 1).symm ∘ (fun x => D.map (y,x))) 0).det | |
| rw [fderiv_comp 0 (hdi.differentiable (by simp) _) (hd.differentiable (by simp) 0), | |
| ContinuousLinearMap.det,ContinuousLinearMap.toLinearMap_comp,LinearMap.det_comp] | |
| exact mul_pos ((Φ.eval y).symm.det_fderiv_pos 1 (D.map (y,0))) (D.orientation y hy) | |
| @[simp] theorem pull_radius {W : Set ℂ} (D : ParametricDiskEmbedding P O) | |
| (Φ : SupportedSmoothIsotopyFamily P ℂ W) : (D.pull Φ).radius = D.radius := rfl | |
| @[simp] theorem pull_carrier {W : Set ℂ} (D : ParametricDiskEmbedding P O) | |
| (Φ : SupportedSmoothIsotopyFamily P ℂ W) (y : P) : | |
| (D.pull Φ).carrier y = (Φ.map y 1).symm '' D.carrier y := by | |
| exact image_comp (Φ.map y 1).symm (fun x => D.map (y,x)) _ | |
| theorem nested_pull {W : Set ℂ} {Y : Set P} {D E : ParametricDiskEmbedding P O} | |
| (h : NestedOn Y D E) (Φ : SupportedSmoothIsotopyFamily P ℂ W) : | |
| NestedOn Y (D.pull Φ) (E.pull Φ) := by | |
| intro y hy | |
| simp only [pull_carrier] | |
| rw [← (Φ.map y 1).symm.image_interior] | |
| exact image_mono (h y hy) | |
| end ParametricDiskEmbedding | |
| theorem supported_homeomorph_image {E : Type*} [TopologicalSpace E] | |
| (φ : E ≃ₜ E) (S : Set E) (h : ∀ x ∉ S, φ x = x) : φ '' S = S := by | |
| apply Subset.antisymm | |
| · rintro x ⟨y,hy,rfl⟩ | |
| by_contra hn | |
| have hh : φ (φ y) = φ y := h (φ y) hn | |
| apply hn | |
| rw [φ.injective hh] | |
| exact hy | |
| · intro x hx | |
| refine ⟨φ.symm x,?_,φ.apply_symm_apply x⟩ | |
| by_contra hn | |
| have hh := h (φ.symm x) hn | |
| rw [φ.apply_symm_apply] at hh | |
| exact hn (hh ▸ hx) | |
| variable [CompleteSpace P] [FiniteDimensional ℝ P] | |
| theorem exists_nested_disk_family_transport | |
| (O : Set P) (hO : IsOpen O) (hcO : Convex ℝ O) | |
| (Y : Set P) (hY : IsCompact Y) (hcY : Convex ℝ Y) (hYO : Y ⊆ O) | |
| (y₀ : P) (hy₀ : y₀ ∈ Y) | |
| (L : List (ParametricDiskEmbedding P O)) | |
| (hL : L.Pairwise (ParametricDiskEmbedding.NestedOn Y)) | |
| (W : Set ℂ) (hW : IsOpen W) (hLW : ∀ D ∈ L, ∀ y ∈ Y, D.carrier y ⊆ W) : | |
| ∃ Φ : SupportedSmoothIsotopyFamily P ℂ W, | |
| ∀ D ∈ L, ∀ y ∈ Y, Φ.map y 1 '' D.carrier y₀ = D.carrier y := by | |
| induction hn : L.length using Nat.strong_induction_on generalizing L W with | |
| | h n ih => | |
| cases L with | |
| | nil => exact ⟨SupportedSmoothIsotopyFamily.refl _,by simp⟩ | |
| | cons D L => | |
| obtain ⟨Φ,hΦ⟩ := exists_embedding_family_transport D.map D.smooth O hO hcO | |
| D.domain W D.open_domain hW D.injective D.nonsingular Y hY hcY hYO y₀ hy₀ | |
| (Metric.closedBall 0 D.radius) (isCompact_closedBall _ _) D.subset_domain | |
| (fun y hy x hx => hLW D (by simp) y hy ⟨x,hx,rfl⟩) | |
| have hΦim (y : P) (hy : y ∈ Y) : Φ.map y 1 '' D.carrier y₀ = D.carrier y := by | |
| rw [ParametricDiskEmbedding.carrier,ParametricDiskEmbedding.carrier,Set.image_image] | |
| exact image_congr (hΦ y hy) | |
| have hΦfix (x : ℂ) (hx : x ∈ D.carrier y₀) : Φ.map y₀ 1 x = x := by | |
| obtain ⟨z,hz,rfl⟩ := hx | |
| exact hΦ y₀ hy₀ z hz | |
| let L' := L.map (fun E => E.pull Φ) | |
| have hLL : L.Pairwise (ParametricDiskEmbedding.NestedOn Y) := hL.of_cons | |
| have hDL : ∀ E ∈ L, ParametricDiskEmbedding.NestedOn Y D E := | |
| fun _ h => List.rel_of_pairwise_cons hL h | |
| have hL' : L'.Pairwise (ParametricDiskEmbedding.NestedOn Y) := by | |
| exact List.Pairwise.map (fun E => E.pull Φ) | |
| (fun _ _ h => ParametricDiskEmbedding.nested_pull h Φ) hLL | |
| have hW' : ∀ E ∈ L', ∀ y ∈ Y, E.carrier y ⊆ interior (D.carrier y₀) := by | |
| intro E hE y hy | |
| change E ∈ L.map (fun E => E.pull Φ) at hE | |
| obtain ⟨E0,hE0,he⟩ := List.mem_map.mp hE | |
| subst E | |
| rw [ParametricDiskEmbedding.pull_carrier] | |
| have hsub := image_mono (f := (Φ.map y 1).symm) (hDL E0 hE0 y hy) | |
| rw [(Φ.map y 1).symm.image_interior,← hΦim y hy] at hsub | |
| simpa only [Set.image_image,(Φ.map y 1).symm_apply_apply,Set.image_id'] using hsub | |
| have hlen : L'.length < n := by | |
| simp only [L',List.length_map] | |
| simp only [List.length_cons] at hn | |
| omega | |
| obtain ⟨Ψ,hΨ⟩ := ih L'.length hlen L' hL' (interior (D.carrier y₀)) isOpen_interior hW' rfl | |
| let Ψ' := Ψ.mono (interior_subset.trans (hLW D (by simp) y₀ hy₀)) | |
| refine ⟨Ψ'.trans Φ,?_⟩ | |
| intro E hE y hy | |
| rcases List.mem_cons.mp hE with hE | hE | |
| · subst E | |
| change (fun x => Φ.map y 1 (Ψ.map y 1 x)) '' D.carrier y₀ = D.carrier y | |
| have hΨim : Ψ.map y 1 '' D.carrier y₀ = D.carrier y₀ := | |
| supported_homeomorph_image _ _ (fun x hx => Ψ.fixed y 1 x | |
| (fun h => hx (interior_subset (Ψ.support_subset h)))) | |
| rw [← Set.image_image,hΨim,hΦim y hy] | |
| · have he := hΨ (E.pull Φ) (List.mem_map.mpr ⟨E,hE,rfl⟩) y hy | |
| have hE0 : (E.pull Φ).carrier y₀ = E.carrier y₀ := by | |
| rw [ParametricDiskEmbedding.pull_carrier] | |
| calc | |
| (Φ.map y₀ 1).symm '' E.carrier y₀ = id '' E.carrier y₀ := by | |
| apply image_congr | |
| intro x hx | |
| apply (Φ.map y₀ 1).injective | |
| rw [(Φ.map y₀ 1).apply_symm_apply] | |
| exact (hΦfix x (interior_subset (hDL E hE y₀ hy₀ hx))).symm | |
| _ = E.carrier y₀ := image_id _ | |
| rw [hE0] at he | |
| change (fun x => Φ.map y 1 (Ψ.map y 1 x)) '' E.carrier y₀ = E.carrier y | |
| rw [← Set.image_image,he,ParametricDiskEmbedding.pull_carrier] | |
| simp only [Set.image_image,(Φ.map y 1).apply_symm_apply,Set.image_id'] | |
| theorem exists_ordinary_nested_disk_family | |
| (O : Set P) (hO : IsOpen O) (hcO : Convex ℝ O) | |
| (Y : Set P) (hY : IsCompact Y) (hcY : Convex ℝ Y) (hYO : Y ⊆ O) | |
| (y₀ : P) (hy₀ : y₀ ∈ Y) | |
| (L : List (ParametricDiskEmbedding P O)) | |
| (hL : L.Pairwise (ParametricDiskEmbedding.NestedOn Y)) | |
| (hr : L.Pairwise (fun D E => E.radius < D.radius)) | |
| (R : ℝ) (hR : ∀ D ∈ L, D.radius < R) | |
| (hLW : ∀ D ∈ L, ∀ y ∈ Y, D.carrier y ⊆ Metric.ball 0 R) : | |
| ∃ Φ : SupportedSmoothIsotopyFamily P ℂ (Metric.ball 0 R), | |
| ∀ D ∈ L, ∀ y ∈ Y, | |
| Φ.map y 1 '' Metric.closedBall 0 D.radius = D.carrier y := by | |
| let L₀ := L.map (fun D => D.eval y₀ (hYO hy₀)) | |
| have hL₀ : L₀.Pairwise PlanarDiskEmbedding.Nested := by | |
| apply List.Pairwise.map _ _ (hr.and hL) | |
| intro D E h | |
| exact ⟨h.1,h.2 y₀ hy₀⟩ | |
| have hR₀ : ∀ D ∈ L₀, D.radius < R := by | |
| intro D hD | |
| change D ∈ L.map _ at hD | |
| obtain ⟨E,hE,he⟩ := List.mem_map.mp hD | |
| subst D | |
| exact hR E hE | |
| have hW₀ : ∀ D ∈ L₀, D.carrier ⊆ Metric.ball 0 R := by | |
| intro D hD | |
| change D ∈ L.map _ at hD | |
| obtain ⟨E,hE,he⟩ := List.mem_map.mp hD | |
| subst D | |
| exact hLW E hE y₀ hy₀ | |
| obtain ⟨Φ₀,hΦ₀⟩ := exists_nested_disk_isotopy L₀ hL₀ R hR₀ hW₀ | |
| obtain ⟨Ψ,hΨ⟩ := exists_nested_disk_family_transport O hO hcO Y hY hcY hYO y₀ hy₀ | |
| L hL (Metric.ball 0 R) Metric.isOpen_ball hLW | |
| refine ⟨(SupportedSmoothIsotopyFamily.constant Φ₀).trans Ψ,?_⟩ | |
| intro D hD y hy | |
| have hh := hΦ₀ (D.eval y₀ (hYO hy₀)) (List.mem_map.mpr ⟨D,hD,rfl⟩) | |
| change Φ₀.map 1 '' Metric.closedBall 0 D.radius = D.carrier y₀ at hh | |
| change (fun x => Ψ.map y 1 (Φ₀.map 1 x)) '' Metric.closedBall 0 D.radius = D.carrier y | |
| rw [← Set.image_image,hh,hΨ D hD y hy] | |
| end | |
| section | |
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] | |
| theorem exists_hamiltonian_nested_disk_family | |
| (O : Set P) (hO : IsOpen O) (hcO : Convex ℝ O) | |
| (Y : Set P) (hY : IsCompact Y) (hcY : Convex ℝ Y) (hYO : Y ⊆ O) | |
| (y₀ : P) (hy₀ : y₀ ∈ Y) | |
| {m : ℕ} (D : Fin m → ParametricDiskEmbedding P O) | |
| (hfamily : ∀ ⦃i j⦄, i < j → ParametricDiskEmbedding.NestedOn Y (D i) (D j)) | |
| (hr : StrictAnti (fun i => (D i).radius)) | |
| (R : ℝ) (hR : 0 < R) (hrR : ∀ i, (D i).radius < R) | |
| (hDW : ∀ i y, y ∈ Y → (D i).carrier y ⊆ Metric.ball 0 R) | |
| (harea : ∀ i y, y ∈ Y → volume ((D i).carrier y) = | |
| volume (Metric.closedBall (0:ℂ) (D i).radius)) : | |
| ∃ Ψ : HamiltonianDiskIsotopyFamily P R, ∀ i y, y ∈ Y → | |
| Ψ.isotopy.map y 1 '' closedRoundDisk (D i).radius = | |
| Complex.equivRealProdCLM '' (D i).carrier y := by | |
| have hL : (List.ofFn D).Pairwise (ParametricDiskEmbedding.NestedOn Y) := | |
| List.pairwise_ofFn.mpr hfamily | |
| have hLr : (List.ofFn D).Pairwise (fun D E => E.radius < D.radius) := | |
| List.pairwise_ofFn.mpr hr | |
| obtain ⟨Φ,hΦ⟩ := exists_ordinary_nested_disk_family O hO hcO Y hY hcY hYO y₀ hy₀ | |
| (List.ofFn D) hL hLr R | |
| (by intro E hE; obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hE; exact hrR i) | |
| (by intro E hE; obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hE; exact hDW i) | |
| let e := Complex.equivRealProdCLM | |
| let Φreal : SupportedSmoothIsotopyFamily P Plane (roundDisk R) := | |
| (Φ.conjugate e).mono (by rw [complex_plane_image_ball hR.le]) | |
| have himage (i : Fin m) (y : P) (hy : y ∈ Y) : | |
| Φreal.map y 1 '' closedRoundDisk (D i).radius = e '' (D i).carrier y := by | |
| rw [← complex_plane_image_closedBall (D i).radius_pos.le] | |
| change (Φ.conjugate e).map y 1 '' (e '' Metric.closedBall 0 (D i).radius) = _ | |
| rw [Φ.conjugate_image e y 1,hΦ (D i) (List.mem_ofFn.mpr ⟨i,rfl⟩) y hy] | |
| obtain ⟨Ψ,hΨ⟩ := exists_hamiltonian_disk_isotopy hR Φreal Y hY | |
| (fun i => (D i).radius) (fun i => (D i).radius_pos) hrR hr.injective (by | |
| intro i y hy | |
| rw [himage i y hy] | |
| change volume (Complex.equivRealProdCLM '' (D i).carrier y) = _ | |
| rw [complex_plane_volume_image,harea i y hy, | |
| ← complex_plane_image_closedBall (D i).radius_pos.le,complex_plane_volume_image]) | |
| refine ⟨Ψ,?_⟩ | |
| intro i y hy | |
| rw [hΨ i y hy,himage i y hy] | |
| end | |
| section | |
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] | |
| theorem exists_parametric_disk_representative | |
| {Y A : Set P} (hY : IsCompact Y) (hcY : Convex ℝ Y) | |
| (hA : IsOpen A) (hYA : Y ⊆ A) {r : ℝ} (hr : 0 < r) | |
| (f : P × ℂ → ℂ) (hf : ContDiffOn ℝ ∞ f (A ×ˢ univ)) | |
| (hi : ∀ y ∈ A, Injective (fun x => f (y,x))) | |
| (hd : ∀ y ∈ A, ∀ x, (fderiv ℝ (fun x => f (y,x)) x).IsInvertible) | |
| (ho : ∀ y ∈ A, 0 < (fderiv ℝ (fun x => f (y,x)) 0).det) : | |
| ∃ O : Set P, IsOpen O ∧ Convex ℝ O ∧ Y ⊆ O ∧ O ⊆ A ∧ | |
| ∃ D : ParametricDiskEmbedding P O, D.radius = r ∧ | |
| ∀ y ∈ O, ∀ x ∈ Metric.closedBall (0:ℂ) r, D.map (y,x) = f (y,x) := by | |
| let K := Y ×ˢ Metric.closedBall (0:ℂ) r | |
| have hK : IsCompact K := hY.prod (isCompact_closedBall _ _) | |
| obtain ⟨χ,_,_,_,_,_,hg,_,he⟩ := exists_smooth_compact_extension hK | |
| (hA.prod isOpen_univ) (by | |
| rintro ⟨y,x⟩ ⟨hy,_⟩ | |
| exact ⟨hYA hy,mem_univ _⟩) hf | |
| let g : P × ℂ → ℂ := fun p => χ p • f p | |
| obtain ⟨W,hW,hKW,hWe⟩ := mem_nhdsSet_iff_exists.mp he | |
| obtain ⟨U,V,hU,hV,hYU,hBV,hUV⟩ := | |
| generalized_tube_lemma hY (isCompact_closedBall (0:ℂ) r) hW hKW | |
| obtain ⟨δ,hδ,hδO⟩ := hY.exists_thickening_subset_open (hU.inter hA) | |
| (subset_inter hYU hYA) | |
| let O := thickening δ Y | |
| obtain ⟨ε,hε,hεV⟩ := (isCompact_closedBall (0:ℂ) r).exists_thickening_subset_open hV hBV | |
| have hball : ball (0:ℂ) (r+ε) ⊆ V := by | |
| rw [add_comm r ε,← thickening_closedBall hε hr.le (0:ℂ)] | |
| exact hεV | |
| have hEq (y : P) (hy : y ∈ O) (x : ℂ) (hx : x ∈ ball (0:ℂ) (r+ε)) : | |
| g (y,x) = f (y,x) := hWe (hUV ⟨(hδO hy).1,hball hx⟩) | |
| have hfder (y : P) (hy : y ∈ O) (x : ℂ) (hx : x ∈ ball (0:ℂ) (r+ε)) : | |
| fderiv ℝ (fun x => g (y,x)) x = fderiv ℝ (fun x => f (y,x)) x := by | |
| apply Filter.EventuallyEq.fderiv_eq | |
| filter_upwards [isOpen_ball.mem_nhds hx] with z hz | |
| exact hEq y hy z hz | |
| let D : ParametricDiskEmbedding P O := { | |
| radius := r | |
| radius_pos := hr | |
| map := g | |
| smooth := hg | |
| domain := ball 0 (r+ε) | |
| open_domain := isOpen_ball | |
| convex_domain := convex_ball _ _ | |
| subset_domain := closedBall_subset_ball (by linarith) | |
| injective := by | |
| intro y hy x hx z hz heq | |
| apply hi y (hδO hy).2 | |
| change f (y,x) = f (y,z) | |
| rw [← hEq y hy x hx,← hEq y hy z hz] | |
| exact heq | |
| nonsingular := by | |
| intro y hy x hx | |
| rw [hfder y hy x hx] | |
| exact hd y (hδO hy).2 x | |
| orientation := by | |
| intro y hy | |
| rw [hfder y hy 0 (mem_ball_self (by linarith))] | |
| exact ho y (hδO hy).2 } | |
| refine ⟨O,isOpen_thickening,hcY.thickening δ,self_subset_thickening hδ Y, | |
| fun _ hy => (hδO hy).2,D,rfl,?_⟩ | |
| intro y hy x hx | |
| exact hEq y hy x (closedBall_subset_ball (by linarith) hx) | |
| end | |
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P] | |
| namespace ParametricDiskEmbedding | |
| def restrictParam {O U : Set P} (D : ParametricDiskEmbedding P O) (hU : U ⊆ O) : | |
| ParametricDiskEmbedding P U where | |
| radius := D.radius | |
| radius_pos := D.radius_pos | |
| map := D.map | |
| smooth := D.smooth | |
| domain := D.domain | |
| open_domain := D.open_domain | |
| convex_domain := D.convex_domain | |
| subset_domain := D.subset_domain | |
| injective := fun y hy => D.injective y (hU hy) | |
| nonsingular := fun y hy => D.nonsingular y (hU hy) | |
| orientation := fun y hy => D.orientation y (hU hy) | |
| end ParametricDiskEmbedding | |
| theorem exists_hamiltonian_disk_germs {m : ℕ} {Y A : Set P} | |
| (hY : IsCompact Y) (hcY : Convex ℝ Y) (hA : IsOpen A) (hYA : Y ⊆ A) | |
| (y₀ : P) (hy₀ : y₀ ∈ Y) (r : Fin m → ℝ) (hr : ∀ i, 0 < r i) | |
| (hrmono : StrictMono r) (f : Fin m → P × ℂ → ℂ) | |
| (hf : ∀ i, ContDiffOn ℝ ∞ (f i) (A ×ˢ univ)) | |
| (hi : ∀ i y, y ∈ A → Injective (fun x => f i (y,x))) | |
| (hd : ∀ i y, y ∈ A → ∀ x, (fderiv ℝ (fun x => f i (y,x)) x).IsInvertible) | |
| (ho : ∀ i y, y ∈ A → 0 < (fderiv ℝ (fun x => f i (y,x)) 0).det) | |
| (hnest : ∀ ⦃i j⦄, i < j → ∀ y ∈ Y, | |
| (fun x => f i (y,x)) '' Metric.closedBall 0 (r i) ⊆ | |
| interior ((fun x => f j (y,x)) '' Metric.closedBall 0 (r j))) | |
| (R : ℝ) (hR : 0 < R) (hrR : ∀ i, r i < R) | |
| (hfit : ∀ i y, y ∈ Y → | |
| (fun x => f i (y,x)) '' Metric.closedBall 0 (r i) ⊆ Metric.ball 0 R) | |
| (harea : ∀ i y, y ∈ Y → volume ((fun x => f i (y,x)) '' Metric.closedBall 0 (r i)) = | |
| volume (Metric.closedBall (0:ℂ) (r i))) : | |
| ∃ Ψ : HamiltonianDiskIsotopyFamily P R, ∀ i y, y ∈ Y → | |
| Ψ.isotopy.map y 1 '' closedRoundDisk (r i) = | |
| Complex.equivRealProdCLM '' ((fun x => f i (y,x)) '' Metric.closedBall 0 (r i)) := by | |
| classical | |
| have hex (i : Fin m) := exists_parametric_disk_representative hY hcY hA hYA (hr i) | |
| (f i) (hf i) (hi i) (hd i) (ho i) | |
| choose O hO hcO hYO hOA D hDr hDf using hex | |
| let U : Set P := ⋂ i, O i | |
| have hU : IsOpen U := isOpen_iInter_of_finite hO | |
| have hcU : Convex ℝ U := convex_iInter hcO | |
| have hYU : Y ⊆ U := by intro y hy; exact mem_iInter.mpr (fun i => hYO i hy) | |
| have hUO (i : Fin m) : U ⊆ O i := iInter_subset _ i | |
| let E (i : Fin m) : ParametricDiskEmbedding P U := (D i).restrictParam (hUO i) | |
| have hEr (i : Fin m) : (E i).radius = r i := hDr i | |
| have hEc (i : Fin m) (y : P) (hy : y ∈ Y) : | |
| (E i).carrier y = (fun x => f i (y,x)) '' Metric.closedBall 0 (r i) := by | |
| change (fun x => (D i).map (y,x)) '' Metric.closedBall 0 (D i).radius = _ | |
| rw [hDr i] | |
| apply image_congr | |
| intro x hx | |
| exact hDf i y (hYO i hy) x hx | |
| let Erev (i : Fin m) := E i.rev | |
| obtain ⟨Ψ,hΨ⟩ := exists_hamiltonian_nested_disk_family U hU hcU Y hY hcY hYU y₀ hy₀ | |
| Erev (by | |
| intro i j hij y hy | |
| change (E j.rev).carrier y ⊆ interior ((E i.rev).carrier y) | |
| rw [hEc _ y hy,hEc _ y hy] | |
| exact hnest (Fin.rev_lt_rev.mpr hij) y hy) | |
| (by | |
| intro i j hij | |
| change (E j.rev).radius < (E i.rev).radius | |
| rw [hEr,hEr] | |
| exact hrmono (Fin.rev_lt_rev.mpr hij)) | |
| R hR (by intro i; change (E i.rev).radius < R; rw [hEr]; exact hrR _) | |
| (by intro i y hy; change (E i.rev).carrier y ⊆ _; rw [hEc _ y hy]; exact hfit _ y hy) | |
| (by | |
| intro i y hy | |
| change volume ((E i.rev).carrier y) = volume (Metric.closedBall (0:ℂ) (E i.rev).radius) | |
| rw [hEc _ y hy,hEr] | |
| exact harea _ y hy) | |
| refine ⟨Ψ,?_⟩ | |
| intro i y hy | |
| have hh := hΨ i.rev y hy | |
| change Ψ.isotopy.map y 1 '' closedRoundDisk (E i.rev.rev).radius = | |
| Complex.equivRealProdCLM '' (E i.rev.rev).carrier y at hh | |
| simpa only [Fin.rev_rev,hEr,hEc _ y hy] using hh | |
| theorem exists_hamiltonian_plane_disk_germs {m : ℕ} {Y A : Set P} | |
| (hY : IsCompact Y) (hcY : Convex ℝ Y) (hA : IsOpen A) (hYA : Y ⊆ A) | |
| (y₀ : P) (hy₀ : y₀ ∈ Y) (r : Fin m → ℝ) (hr : ∀ i, 0 < r i) | |
| (hrmono : StrictMono r) (f : Fin m → P × Plane → Plane) | |
| (hf : ∀ i, ContDiffOn ℝ ∞ (f i) (A ×ˢ univ)) | |
| (hi : ∀ i y, y ∈ A → Injective (fun x => f i (y,x))) | |
| (hd : ∀ i y, y ∈ A → ∀ x, 0 < (fderiv ℝ (fun x => f i (y,x)) x).det) | |
| (hnest : ∀ ⦃i j⦄, i < j → ∀ y ∈ Y, | |
| (fun x => f i (y,x)) '' closedRoundDisk (r i) ⊆ | |
| interior ((fun x => f j (y,x)) '' closedRoundDisk (r j))) | |
| (R : ℝ) (hR : 0 < R) (hrR : ∀ i, r i < R) | |
| (hfit : ∀ i y, y ∈ Y → | |
| (fun x => f i (y,x)) '' closedRoundDisk (r i) ⊆ roundDisk R) | |
| (harea : ∀ i y, y ∈ Y → volume ((fun x => f i (y,x)) '' closedRoundDisk (r i)) = | |
| volume (closedRoundDisk (r i))) : | |
| ∃ Ψ : HamiltonianDiskIsotopyFamily P R, ∀ i y, y ∈ Y → | |
| Ψ.isotopy.map y 1 '' closedRoundDisk (r i) = | |
| (fun x => f i (y,x)) '' closedRoundDisk (r i) := by | |
| let e := Complex.equivRealProdCLM | |
| let g (i : Fin m) (p : P × ℂ) := e.symm (f i (p.1,e p.2)) | |
| have hs (i : Fin m) : ContDiffOn ℝ ∞ (g i) (A ×ˢ univ) := | |
| e.symm.contDiff.comp_contDiffOn ((hf i).comp | |
| (contDiff_fst.prodMk (e.contDiff.comp contDiff_snd)).contDiffOn (by | |
| intro p hp; exact ⟨hp.1,mem_univ _⟩)) | |
| have hder (i : Fin m) (y : P) (hy : y ∈ A) (x : ℂ) : | |
| (fderiv ℝ (fun x => g i (y,x)) x).det = | |
| (fderiv ℝ (fun x => f i (y,x)) (e x)).det := by | |
| change (fderiv ℝ (fun x => e.symm (f i (y,e x))) x).det = _ | |
| apply det_fderiv_conjugate e (f := fun x => f i (y,x)) (x := x) | |
| have hh : ContDiffAt ℝ ∞ (f i) (y,e x) := | |
| (hf i).contDiffAt ((hA.prod isOpen_univ).mem_nhds ⟨hy,mem_univ _⟩) | |
| exact (hh.comp _ (contDiff_const.prodMk contDiff_id).contDiffAt).differentiableAt (by simp) | |
| have himage (i : Fin m) (y : P) : | |
| e '' ((fun x => g i (y,x)) '' Metric.closedBall 0 (r i)) = | |
| (fun x => f i (y,x)) '' closedRoundDisk (r i) := by | |
| rw [←complex_plane_image_closedBall (hr i).le] | |
| simp only [image_image,g,e.apply_symm_apply] | |
| rfl | |
| obtain ⟨Ψ,hΨ⟩ := exists_hamiltonian_disk_germs hY hcY hA hYA y₀ hy₀ r hr hrmono g hs | |
| (fun i y hy => e.symm.injective.comp ((hi i y hy).comp e.injective)) | |
| (fun i y hy x => isInvertible_of_det_ne_zero (by rw [hder i y hy x]; exact (hd i y hy _).ne')) | |
| (fun i y hy => by rw [hder i y hy 0]; exact hd i y hy _) | |
| (by | |
| intro i j hij y hy x hx | |
| have hh := hnest hij y hy | |
| rw [←himage i y,←himage j y] at hh | |
| have he : interior (e '' ((fun x => g j (y,x)) '' Metric.closedBall 0 (r j))) = | |
| e '' interior ((fun x => g j (y,x)) '' Metric.closedBall 0 (r j)) := | |
| (e.toHomeomorph.image_interior _).symm | |
| rw [he] at hh | |
| have hh' := hh (mem_image_of_mem e hx) | |
| exact e.injective.mem_set_image.mp hh') R hR hrR | |
| (by | |
| intro i y hy x hx | |
| have hh := hfit i y hy | |
| rw [←himage i y,←complex_plane_image_ball hR.le] at hh | |
| exact e.injective.mem_set_image.mp (hh (mem_image_of_mem e hx))) | |
| (by | |
| intro i y hy | |
| rw [←complex_plane_volume_image, himage i y,harea i y hy, | |
| ←complex_plane_image_closedBall (hr i).le,complex_plane_volume_image]) | |
| refine ⟨Ψ,?_⟩ | |
| intro i y hy | |
| exact (hΨ i y hy).trans (himage i y) | |
| end PackingSufficiencySupport.Hamiltonian | |
| namespace PackingSufficiencySupport.Comparison | |
| open Set | |
| theorem exists_positive_area_grid {A δ : ℝ} (_hA : 0 ≤ A) (hδ : 0 < δ) : | |
| ∃ (m : ℕ) (h : Fin m → ℝ), StrictMono h ∧ (∀ i, 0 < h i) ∧ | |
| ∀ w ∈ Icc (0:ℝ) A, ∃ i, w ≤ h i ∧ h i-w < δ := by | |
| obtain ⟨N,hN⟩ := exists_nat_gt (A/(δ/2)) | |
| have hhalf : 0 < δ/2 := by positivity | |
| let h (i : Fin (N+1)) : ℝ := ((i:ℕ)+1 : ℝ)*(δ/2) | |
| refine ⟨N+1,h,?_,?_,?_⟩ | |
| · intro i j hij | |
| apply mul_lt_mul_of_pos_right _ hhalf | |
| have he : (i:ℝ) < (j:ℝ) := by exact_mod_cast hij | |
| linarith | |
| · intro i | |
| apply mul_pos _ hhalf | |
| positivity | |
| · intro w hw | |
| let k := ⌊w/(δ/2)⌋₊ | |
| have hk : (k:ℝ) ≤ w/(δ/2) := Nat.floor_le (div_nonneg hw.1 hhalf.le) | |
| have hk' : w/(δ/2) < (k:ℝ)+1 := Nat.lt_floor_add_one _ | |
| have hkn : (k:ℝ) < N := hk.trans_lt ((div_le_div_of_nonneg_right hw.2 hhalf.le).trans_lt hN) | |
| have hkN : k < N+1 := by | |
| have : k < N := by exact_mod_cast hkn | |
| omega | |
| refine ⟨⟨k,hkN⟩,?_,?_⟩ | |
| · change w ≤ ((k:ℝ)+1)*(δ/2) | |
| exact ((div_lt_iff₀ hhalf).mp hk').le | |
| · change ((k:ℝ)+1)*(δ/2)-w < δ | |
| have hkw := (le_div_iff₀ hhalf).mp hk | |
| nlinarith | |
| end PackingSufficiencySupport.Comparison | |
| end | |
| end OAI | |