| import Mathlib |
| import OAI.Geometry.BallPacking.Hamiltonian.AnnularDensityMass |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped ContDiff Topology |
| open Set Function |
| section |
|
|
| variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| @[simp] theorem planarHamiltonianField_smul (c : ℝ) (α : Plane →L[ℝ] ℝ) : |
| planarHamiltonianField (c • α) = c • planarHamiltonianField α := by |
| ext <;> simp [planarHamiltonianField] |
|
|
| theorem scaled_planar_fderiv {H : Plane → ℝ} (hH : Differentiable ℝ H) |
| {a : ℝ} (ha : a ≠ 0) (c : ℝ) (x : Plane) : |
| fderiv ℝ (fun z => (c*a^2)*H (a⁻¹ • z)) x = |
| (c*a) • fderiv ℝ H (a⁻¹ • x) := by |
| have hd := ((hH (a⁻¹ • x)).hasFDerivAt.comp x |
| ((hasFDerivAt_id (𝕜 := ℝ) x).const_smul a⁻¹)).const_mul (c*a^2) |
| change fderiv ℝ (fun z => (c*a^2)*(H ∘ HSMul.hSMul a⁻¹) z) x = _ |
| rw [hd.fderiv] |
| apply ContinuousLinearMap.ext |
| intro w |
| simp only [smul_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.id_apply,map_smul,smul_eq_mul] |
| field_simp [ha] |
|
|
| def scaledPlanarHamiltonian (Ψ : PlanarHamiltonianMotion P) (a χ : P → ℝ) |
| (p : (P × ℝ) × Plane) : ℝ := |
| ((χ p.1.1 * deriv Real.smoothTransition p.1.2)*(a p.1.1)^2) * |
| Ψ.hamiltonian ((p.1.1,χ p.1.1 * Real.smoothTransition p.1.2),(a p.1.1)⁻¹ • p.2) |
|
|
| def scaledPlanarTrace (Ψ : PlanarHamiltonianMotion P) (a χ : P → ℝ) |
| (y : P) (t : ℝ) (x : Plane) : Plane := |
| a y • Ψ.trace y (χ y * Real.smoothTransition t) ((a y)⁻¹ • x) |
|
|
| theorem scaledPlanarHamiltonian_smooth (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (ha : ContDiff ℝ ∞ a) (hn : ∀ y, a y ≠ 0) (hχ : ContDiff ℝ ∞ χ) : |
| ContDiff ℝ ∞ (scaledPlanarHamiltonian Ψ a χ) := by |
| have hai : ContDiff ℝ ∞ (fun y => (a y)⁻¹) := ha.inv hn |
| have hβ : ContDiff ℝ ∞ (deriv Real.smoothTransition) := |
| (contDiff_infty_iff_deriv.mp Real.smoothTransition.contDiff).2 |
| unfold scaledPlanarHamiltonian |
| exact (((hχ.comp contDiff_fst.fst).mul (hβ.comp contDiff_fst.snd)).mul |
| ((ha.comp contDiff_fst.fst).pow 2)).mul (Ψ.smooth.comp |
| ((contDiff_fst.fst.prodMk ((hχ.comp contDiff_fst.fst).mul |
| (Real.smoothTransition.contDiff.comp contDiff_fst.snd))).prodMk |
| ((hai.comp contDiff_fst.fst).smul contDiff_snd))) |
|
|
| theorem scaledPlanarHamiltonian_compact (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (ha : Continuous a) (hn : ∀ y, a y ≠ 0) (hχ : HasCompactSupport χ) : |
| HasCompactSupport (scaledPlanarHamiltonian Ψ a χ) := by |
| let K := (tsupport χ ×ˢ tsupport (deriv Real.smoothTransition)) ×ˢ (Prod.snd '' tsupport Ψ.hamiltonian) |
| let f : (P × ℝ) × Plane → (P × ℝ) × Plane := fun p => (p.1,a p.1.1 • p.2) |
| have hK : IsCompact K := (hχ.prod smoothTransition_deriv_compact).prod |
| (Ψ.compact.image continuous_snd) |
| have hf : Continuous f := continuous_fst.prodMk ((ha.comp continuous_fst.fst).smul continuous_snd) |
| apply HasCompactSupport.intro (hK.image hf) |
| intro p hp |
| by_contra hne |
| have hc : χ p.1.1 ≠ 0 := by intro hz; apply hne; simp [scaledPlanarHamiltonian,hz] |
| have ht : deriv Real.smoothTransition p.1.2 ≠ 0 := by |
| intro hz; apply hne; simp [scaledPlanarHamiltonian,hz] |
| have hb : Ψ.hamiltonian ((p.1.1,χ p.1.1*Real.smoothTransition p.1.2),(a p.1.1)⁻¹ • p.2) ≠ 0 := by |
| intro hz; apply hne; simp [scaledPlanarHamiltonian,hz] |
| apply hp |
| refine ⟨(p.1,(a p.1.1)⁻¹ • p.2),⟨⟨subset_closure hc,subset_closure ht⟩,?_⟩,?_⟩ |
| · exact ⟨_,subset_closure hb,rfl⟩ |
| · dsimp [f] |
| rw [smul_inv_smul₀ (hn p.1.1)] |
|
|
| theorem scaledPlanarTrace_continuous (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (ha : Continuous a) (hn : ∀ y, a y ≠ 0) (hχ : Continuous χ) : |
| Continuous (fun p : (P × ℝ) × Plane => scaledPlanarTrace Ψ a χ p.1.1 p.1.2 p.2) := by |
| unfold scaledPlanarTrace |
| exact (ha.comp continuous_fst.fst).smul (Ψ.continuous.comp |
| ((continuous_fst.fst.prodMk ((hχ.comp continuous_fst.fst).mul |
| (Real.smoothTransition.continuous.comp continuous_fst.snd))).prodMk |
| (((ha.inv₀ hn).comp continuous_fst.fst).smul continuous_snd))) |
|
|
| theorem scaledPlanarTrace_zero (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (hn : ∀ y, a y ≠ 0) (y : P) (x : Plane) : |
| scaledPlanarTrace Ψ a χ y 0 x = x := by |
| simp only [scaledPlanarTrace,Real.smoothTransition.zero_of_nonpos le_rfl,mul_zero,Ψ.zero] |
| exact smul_inv_smul₀ (hn y) x |
|
|
| theorem scaledPlanarTrace_flow (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (hn : ∀ y, a y ≠ 0) (y : P) (t : ℝ) (x : Plane) : |
| HasDerivAt (fun s => scaledPlanarTrace Ψ a χ y s x) |
| (planarHamiltonianField (fderiv ℝ (fun z => scaledPlanarHamiltonian Ψ a χ ((y,t),z)) |
| (scaledPlanarTrace Ψ a χ y t x))) t := by |
| have hβ : HasDerivAt Real.smoothTransition (deriv Real.smoothTransition t) t := |
| ((Real.smoothTransition.contDiff (n := (⊤ : ℕ∞))).differentiable (by simp) t).hasDerivAt |
| have hd := ((Ψ.flow y (χ y*Real.smoothTransition t) ((a y)⁻¹ • x)).scomp t |
| (hβ.const_mul (χ y))).const_smul (a y) |
| have hs : Differentiable ℝ (fun z => Ψ.hamiltonian ((y,χ y*Real.smoothTransition t),z)) := |
| (Ψ.smooth.comp (contDiff_const.prodMk contDiff_id)).differentiable (by simp) |
| dsimp only [scaledPlanarHamiltonian] |
| rw [scaled_planar_fderiv hs (hn y),planarHamiltonianField_smul] |
| simp only [scaledPlanarTrace,inv_smul_smul₀ (hn y)] |
| convert! hd using 1 |
| simp only [smul_smul] |
| congr 1 |
| ring |
|
|
| def PlanarHamiltonianMotion.scaled (Ψ : PlanarHamiltonianMotion P) |
| (a χ : P → ℝ) (ha : ContDiff ℝ ∞ a) (hn : ∀ y, a y ≠ 0) |
| (hχ : ContDiff ℝ ∞ χ) (hχc : HasCompactSupport χ) : PlanarHamiltonianMotion P where |
| hamiltonian := scaledPlanarHamiltonian Ψ a χ |
| smooth := scaledPlanarHamiltonian_smooth Ψ ha hn hχ |
| compact := scaledPlanarHamiltonian_compact Ψ ha.continuous hn hχc |
| trace := scaledPlanarTrace Ψ a χ |
| continuous := scaledPlanarTrace_continuous Ψ ha.continuous hn hχ.continuous |
| zero := scaledPlanarTrace_zero Ψ hn |
| flow := scaledPlanarTrace_flow Ψ hn |
|
|
| end |
|
|
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| @[simp] theorem radialArea_smul (a : ℝ) (x : Plane) : |
| radialArea (a • x) = a^2*radialArea x := by |
| simp only [radialArea,radiusSq_smul] |
| ring |
|
|
| theorem scaledPlanarTrace_smooth (Ψ : PlanarHamiltonianMotion P) |
| (hΨ : ContDiff ℝ ∞ (fun p : (P × ℝ) × Plane => Ψ.trace p.1.1 p.1.2 p.2)) |
| {a χ : P → ℝ} (ha : ContDiff ℝ ∞ a) (hn : ∀ y, a y ≠ 0) (hχ : ContDiff ℝ ∞ χ) : |
| ContDiff ℝ ∞ (fun p : (P × ℝ) × Plane => scaledPlanarTrace Ψ a χ p.1.1 p.1.2 p.2) := by |
| unfold scaledPlanarTrace |
| exact (ha.comp contDiff_fst.fst).smul (hΨ.comp |
| ((contDiff_fst.fst.prodMk ((hχ.comp contDiff_fst.fst).mul |
| (Real.smoothTransition.contDiff.comp contDiff_fst.snd))).prodMk |
| (((ha.inv hn).comp contDiff_fst.fst).smul contDiff_snd))) |
|
|
| theorem scaledPlanarTrace_cutoff_zero (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (y : P) (ha : a y ≠ 0) (hχ : χ y = 0) (t : ℝ) (x : Plane) : |
| scaledPlanarTrace Ψ a χ y t x = x := by |
| simp only [scaledPlanarTrace,hχ,zero_mul,Ψ.zero] |
| exact smul_inv_smul₀ ha x |
|
|
| theorem scaledPlanarTrace_time_one (Ψ : PlanarHamiltonianMotion P) |
| {a χ : P → ℝ} (y : P) (hχ : χ y = 1) (x : Plane) : |
| scaledPlanarTrace Ψ a χ y 1 x = a y • Ψ.trace y 1 ((a y)⁻¹ • x) := by |
| simp [scaledPlanarTrace,hχ,Real.smoothTransition.one_of_one_le le_rfl] |
|
|
| theorem scaled_disk_fixed (Ψ : HamiltonianDiskIsotopyFamily P (areaRadius 1)) |
| {a χ : P → ℝ} (y : P) (ha : a y ≠ 0) (t : ℝ) (x : Plane) |
| (hx : (a y)^2 ≤ radialArea x) : scaledPlanarTrace Ψ.motion a χ y t x = x := by |
| have hs : (a y)⁻¹ • x ∉ roundDisk (areaRadius 1) := by |
| rw [mem_roundDisk_areaRadius (by norm_num),radialArea_smul,not_lt] |
| have hh := mul_le_mul_of_nonneg_left hx (sq_nonneg (a y)⁻¹) |
| have he : (a y)⁻¹^2*(a y)^2 = 1 := by field_simp |
| linarith |
| dsimp only [scaledPlanarTrace,HamiltonianDiskIsotopyFamily.motion] |
| rw [Ψ.isotopy.fixed y _ _ (fun h => hs (Ψ.isotopy.support_subset h))] |
| exact smul_inv_smul₀ ha x |
|
|
| theorem scaled_disk_mapsTo (Ψ : HamiltonianDiskIsotopyFamily P (areaRadius 1)) |
| {a χ : P → ℝ} (y : P) (ha : a y ≠ 0) (t : ℝ) (x : Plane) |
| (hx : radialArea x ≤ (a y)^2) : |
| radialArea (scaledPlanarTrace Ψ.motion a χ y t x) ≤ (a y)^2 := by |
| have hs : (a y)⁻¹ • x ∈ closedRoundDisk (areaRadius 1) := by |
| rw [mem_closedRoundDisk_areaRadius (by norm_num),radialArea_smul] |
| have hh := mul_le_mul_of_nonneg_left hx (sq_nonneg (a y)⁻¹) |
| have he : (a y)⁻¹^2*(a y)^2 = 1 := by field_simp |
| linarith |
| have hm := Ψ.mapsTo_closed y (χ y*Real.smoothTransition t) hs |
| rw [mem_closedRoundDisk_areaRadius (by norm_num)] at hm |
| dsimp only [scaledPlanarTrace,HamiltonianDiskIsotopyFamily.motion] |
| rw [radialArea_smul] |
| simpa only [mul_one] using mul_le_mul_of_nonneg_left hm (sq_nonneg (a y)) |
|
|
| theorem scaled_disk_preserves_slice (Ψ : HamiltonianDiskIsotopyFamily P (areaRadius 1)) |
| {a χ : P → ℝ} (y : P) (ha : a y ≠ 0) (t : ℝ) (x : Plane) {L : ℝ} |
| (hx : radialArea x ≤ L) (hfit : χ y ≠ 0 → (a y)^2 ≤ L) : |
| radialArea (scaledPlanarTrace Ψ.motion a χ y t x) ≤ L := by |
| by_cases hc : χ y = 0 |
| · rw [scaledPlanarTrace_cutoff_zero Ψ.motion y ha hc]; exact hx |
| · rcases le_total (radialArea x) ((a y)^2) with hl | hl |
| · exact (scaled_disk_mapsTo Ψ y ha t x hl).trans (hfit hc) |
| · rw [scaled_disk_fixed Ψ y ha t x hl]; exact hx |
|
|
| theorem HamiltonianDiskIsotopyFamily.exists_support_margin |
| (Ψ : HamiltonianDiskIsotopyFamily P (areaRadius 1)) : |
| ∃ σ : ℝ, 0 < σ ∧ σ < 1 ∧ ∀ p ∈ tsupport Ψ.hamiltonian, radialArea p.2 ≤ σ := by |
| rcases (tsupport Ψ.hamiltonian).eq_empty_or_nonempty with he | hn |
| · exact ⟨1/2,by norm_num,by norm_num,by simp [he]⟩ |
| obtain ⟨p,hp,hm⟩ := Ψ.compact.exists_isMaxOn hn |
| (radialArea_smooth.continuous.comp continuous_snd).continuousOn |
| have hp1 : radialArea p.2 < 1 := |
| (mem_roundDisk_areaRadius (by norm_num) _).mp (Ψ.support hp).2 |
| refine ⟨(radialArea p.2+1)/2,by linarith [radialArea_nonneg p.2],by linarith,?_⟩ |
| intro q hq |
| have hh : radialArea q.2 ≤ radialArea p.2 := hm hq |
| linarith |
|
|
| end PackingSufficiencySupport.Hamiltonian |
|
|
| namespace PackingSufficiencySupport.Comparison |
| open scoped Topology |
| open Set Function Filter |
| section |
|
|
| theorem exists_longer_strict_interval {f : ℝ → ℝ} (hf : Continuous f) |
| {a h c : ℝ} (ha : 0 ≤ a) (hah : a+h ≤ 1) (_hh : 0 ≤ h) (hh1 : h < 1) |
| (hla : f a < c) (hlb : f (a+h) < c) : |
| ∃ u v : ℝ, 0 < u ∧ v < 1 ∧ h < v-u ∧ f u < c ∧ f v < c := by |
| let u₀ : ℝ := (1-h)/4 |
| let v₀ : ℝ := (3+h)/4 |
| have hu₀ : 0 < u₀ := by dsimp [u₀]; linarith |
| have hv₀ : v₀ < 1 := by dsimp [v₀]; linarith |
| have huv₀ : h < v₀-u₀ := by dsimp [u₀,v₀]; linarith |
| let u (t : ℝ) := (1-t)*a+t*u₀ |
| let v (t : ℝ) := (1-t)*(a+h)+t*v₀ |
| have huc : Continuous u := by dsimp [u]; fun_prop |
| have hvc : Continuous v := by dsimp [v]; fun_prop |
| have heu : ∀ᶠ t : ℝ in 𝓝 0, f (u t) < c := |
| (hf.comp huc).continuousAt.tendsto.eventually (isOpen_Iio.mem_nhds (by simpa [u] using hla)) |
| have hev : ∀ᶠ t : ℝ in 𝓝 0, f (v t) < c := |
| (hf.comp hvc).continuousAt.tendsto.eventually (isOpen_Iio.mem_nhds (by simpa [v] using hlb)) |
| have he : ∀ᶠ t : ℝ in 𝓝 0, t < 1 ∧ f (u t) < c ∧ f (v t) < c := by |
| filter_upwards [(isOpen_Iio.mem_nhds (by norm_num : (0:ℝ) ∈ Iio 1) : Iio (1:ℝ) ∈ 𝓝 (0:ℝ)),heu,hev] with t ht hu hv |
| exact ⟨ht,hu,hv⟩ |
| obtain ⟨t,ht,htpos⟩ := ((he.filter_mono |
| (show 𝓝[>] (0:ℝ) ≤ 𝓝 0 from nhdsWithin_le_nhds)).and self_mem_nhdsWithin).exists |
| refine ⟨u t,v t,?_,?_,?_,ht.2.1,ht.2.2⟩ |
| · dsimp [u] |
| exact add_pos_of_nonneg_of_pos (mul_nonneg (by linarith [ht.1]) ha) (mul_pos htpos hu₀) |
| · dsimp [v] |
| nlinarith only [mul_nonneg (by linarith [ht.1] : 0 ≤ 1-t) (sub_nonneg.mpr hah), |
| mul_pos htpos (sub_pos.mpr hv₀)] |
| · dsimp [u,v] |
| nlinarith only [mul_pos htpos (sub_pos.mpr huv₀)] |
|
|
| variable {P : Type*} [TopologicalSpace P] {m : ℕ} |
|
|
| def IntervalRoom (V : P → Fin m → Set ℝ) (L : Fin m → ℝ) (y : P) : Prop := |
| ∀ i, ∃ a b : ℝ, a ∈ V y i ∧ b ∈ V y i ∧ L i < b-a |
|
|
| theorem intervalRoom_open (V : P → Fin m → Set ℝ) |
| (hV : ∀ i, IsOpen {p : P × ℝ | p.2 ∈ V p.1 i}) : |
| IsOpen {p : (Fin m → ℝ) × P | IntervalRoom V p.1 p.2} := by |
| have hmem (i : Fin m) (a : ℝ) : IsOpen {p : (Fin m → ℝ) × P | a ∈ V p.2 i} := |
| (hV i).preimage (continuous_snd.prodMk continuous_const) |
| change IsOpen {p : (Fin m → ℝ) × P | ∀ i, ∃ a b : ℝ, |
| a ∈ V p.2 i ∧ b ∈ V p.2 i ∧ p.1 i < b-a} |
| simp only [ofPred_forall,ofPred_exists,ofPred_and] |
| exact isOpen_iInter_of_finite (fun i => isOpen_iUnion (fun a => isOpen_iUnion (fun b => |
| (hmem i a).inter ((hmem i b).inter (isOpen_lt ((continuous_apply i).comp continuous_fst) continuous_const))))) |
|
|
| theorem strictMono_open : IsOpen {L : Fin m → ℝ | StrictMono L} := by |
| change IsOpen {L : Fin m → ℝ | ∀ i j, i < j → L i < L j} |
| simp only [ofPred_forall] |
| apply isOpen_iInter_of_finite |
| intro i |
| apply isOpen_iInter_of_finite |
| intro j |
| by_cases hij : i < j |
| · simpa [hij] using isOpen_lt (f := fun u : Fin m → ℝ => u i) (g := fun u => u j) |
| (continuous_apply i) (continuous_apply j) |
| · simp [hij] |
|
|
| theorem exists_uniform_interval_widths {Y : Set P} (hY : IsCompact Y) |
| (h : Fin m → ℝ) (hh : StrictMono h) (V : P → Fin m → Set ℝ) |
| (hV : ∀ i, IsOpen {p : P × ℝ | p.2 ∈ V p.1 i}) |
| (hroom : ∀ y ∈ Y, IntervalRoom V h y) : |
| ∃ L w : Fin m → ℝ, StrictMono L ∧ StrictMono w ∧ |
| (∀ i, 0 < w i ∧ w i < 1 ∧ L i*w i = h i) ∧ |
| ∀ y ∈ Y, IntervalRoom V L y := by |
| have hsub : ({h} : Set (Fin m → ℝ)) ×ˢ Y ⊆ {p | IntervalRoom V p.1 p.2} := by |
| rintro ⟨L,y⟩ ⟨hL,hy⟩ |
| have he : L = h := hL |
| subst L |
| exact hroom y hy |
| obtain ⟨U,W,hU,_,hhU,hYW,hUW⟩ := |
| generalized_tube_lemma isCompact_singleton hY (intervalRoom_open V hV) hsub |
| let d (i : Fin m) : ℝ := (m:ℝ)-(i:ℕ) |
| have hd (i : Fin m) : 0 < d i := by |
| dsimp [d] |
| exact sub_pos.mpr (by exact_mod_cast i.isLt) |
| let w (t : ℝ) (i : Fin m) := 1-t*d i |
| let L (t : ℝ) (i : Fin m) := h i/w t i |
| have hwc (i : Fin m) : Continuous (fun t => w t i) := by dsimp [w]; fun_prop |
| have hLc : ContinuousAt L 0 := by |
| apply continuousAt_pi.mpr |
| intro i |
| exact continuousAt_const.div (hwc i).continuousAt (by simp [w]) |
| have hL0 : L 0 = h := by ext i; simp [L,w] |
| have heU : ∀ᶠ t in 𝓝 (0:ℝ), L t ∈ U := by |
| apply hLc.tendsto.eventually |
| rw [hL0] |
| exact hU.mem_nhds (hhU rfl) |
| have hemono : ∀ᶠ t in 𝓝 (0:ℝ), StrictMono (L t) := by |
| apply hLc.tendsto.eventually |
| rw [hL0] |
| exact strictMono_open.mem_nhds hh |
| have hepos : ∀ᶠ t in 𝓝 (0:ℝ), ∀ i, 0 < w t i := by |
| rw [eventually_all] |
| intro i |
| exact (hwc i).continuousAt.tendsto.eventually (isOpen_Ioi.mem_nhds (by simp [w])) |
| obtain ⟨t,ht,htpos⟩ := (((heU.and (hemono.and hepos)).filter_mono |
| (show 𝓝[>] (0:ℝ) ≤ 𝓝 0 from nhdsWithin_le_nhds)).and self_mem_nhdsWithin).exists |
| refine ⟨L t,w t,ht.2.1,?_,?_,?_⟩ |
| · intro i j hij |
| have hij' : (i:ℝ) < (j:ℝ) := by exact_mod_cast hij |
| dsimp [w,d] |
| nlinarith only [mul_pos htpos (sub_pos.mpr hij')] |
| · intro i |
| refine ⟨ht.2.2 i,?_,?_⟩ |
| · dsimp [w] |
| linarith only [mul_pos htpos (hd i)] |
| · exact div_mul_cancel₀ _ (ht.2.2 i).ne' |
| · intro y hy |
| exact hUW (show (L t,y) ∈ U ×ˢ W from ⟨ht.1,hYW hy⟩) |
|
|
| def clampUnit (h : ℝ) : ℝ := max 0 (min 1 h) |
|
|
| theorem continuous_clampUnit : Continuous clampUnit := |
| continuous_const.max (continuous_const.min continuous_id) |
|
|
| theorem clampUnit_eq {h : ℝ} (hh : h ∈ Icc (0:ℝ) 1) : clampUnit h = h := by |
| simp [clampUnit,min_eq_right hh.2,max_eq_right hh.1] |
|
|
| def unitIntervalValue (F : C(P × ℝ,ℝ)) : C((P × ℝ) × UnitInterval,ℝ) where |
| toFun p := max (F (p.1.1,p.2.val*(1-clampUnit p.1.2))) |
| (F (p.1.1,p.2.val*(1-clampUnit p.1.2)+clampUnit p.1.2)) |
| continuous_toFun := by |
| have hc : Continuous (fun p : (P × ℝ) × UnitInterval => clampUnit p.1.2) := |
| continuous_clampUnit.comp (continuous_snd.comp continuous_fst) |
| have ht : Continuous (fun p : (P × ℝ) × UnitInterval => p.2.val) := |
| continuous_subtype_val.comp continuous_snd |
| have hy : Continuous (fun p : (P × ℝ) × UnitInterval => p.1.1) := |
| continuous_fst.comp continuous_fst |
| exact (F.continuous.comp (hy.prodMk (ht.mul (continuous_const.sub hc)))).max |
| (F.continuous.comp (hy.prodMk ((ht.mul (continuous_const.sub hc)).add hc))) |
|
|
| def unitRearrange (F : C(P × ℝ,ℝ)) : C(P × ℝ,ℝ) where |
| toFun p := minimum ((unitIntervalValue F).curry p) |
| continuous_toFun := minimum_lipschitz.continuous.comp (unitIntervalValue F).curry.continuous |
|
|
| theorem unitRearrange_attained (F : C(P × ℝ,ℝ)) (y : P) {h : ℝ} |
| (hh : h ∈ Icc (0:ℝ) 1) : |
| ∃ a : ℝ, 0 ≤ a ∧ a+h ≤ 1 ∧ unitRearrange F (y,h) = max (F (y,a)) (F (y,a+h)) := by |
| obtain ⟨t,ht⟩ := minimum_attained ((unitIntervalValue F).curry (y,h)) |
| refine ⟨t.val*(1-h),mul_nonneg t.property.1 (sub_nonneg.mpr hh.2),?_,?_⟩ |
| · nlinarith only [mul_nonneg (sub_nonneg.mpr t.property.2) (sub_nonneg.mpr hh.2)] |
| · change minimum ((unitIntervalValue F).curry (y,h)) = _ |
| rw [←ht] |
| simp [unitIntervalValue,clampUnit_eq hh] |
|
|
| theorem unitRearrange_le_candidate (F : C(P × ℝ,ℝ)) (y : P) {h a : ℝ} |
| (hh : h ∈ Icc (0:ℝ) 1) (ha : 0 ≤ a) (hah : a+h ≤ 1) : |
| unitRearrange F (y,h) ≤ max (F (y,a)) (F (y,a+h)) := by |
| obtain ⟨t,ht⟩ := exists_unitInterval_mul (sub_nonneg.mpr hh.2) ha (by linarith) |
| calc |
| _ ≤ (unitIntervalValue F).curry (y,h) t := minimum_le _ t |
| _ = _ := by simp [unitIntervalValue,clampUnit_eq hh,ht] |
|
|
| theorem unitRearrange_one (F : C(P × ℝ,ℝ)) (y : P) : |
| unitRearrange F (y,1) = max (F (y,0)) (F (y,1)) := by |
| obtain ⟨a,ha,hah,he⟩ := unitRearrange_attained F y (show (1:ℝ) ∈ Icc 0 1 by norm_num) |
| have ha0 : a = 0 := by linarith |
| simpa [ha0] using he |
|
|
| theorem unitRearrange_mono (F : C(P × ℝ,ℝ)) (y : P) |
| (hconv : ConvexOn ℝ (Icc 0 1) (fun v => F (y,v))) : |
| MonotoneOn (fun h => unitRearrange F (y,h)) (Icc 0 1) := by |
| intro h hh H hH hle |
| obtain ⟨a,ha,haH,he⟩ := unitRearrange_attained F y hH |
| have hah : a+h ≤ 1 := by linarith |
| apply (unitRearrange_le_candidate F y hh ha hah).trans |
| change max (F (y,a)) (F (y,a+h)) ≤ unitRearrange F (y,H) |
| rw [he] |
| apply max_le |
| · exact le_max_left _ _ |
| · exact hconv.le_max_of_mem_Icc ⟨ha,by linarith [hH.1]⟩ |
| ⟨by linarith [hH.1],haH⟩ ⟨by linarith [hh.1],by linarith⟩ |
|
|
| def unitSublevel (F : C(P × ℝ,ℝ)) (h ε : ℝ) (y : P) : Set ℝ := |
| {v | v ∈ Ioo 0 1 ∧ F (y,v) < unitRearrange F (y,h)+ε} |
|
|
| theorem unitSublevel_open (F : C(P × ℝ,ℝ)) (h ε : ℝ) : |
| IsOpen {p : P × ℝ | p.2 ∈ unitSublevel F h ε p.1} := |
| (isOpen_Ioo.preimage continuous_snd).inter |
| (isOpen_lt F.continuous (((unitRearrange F).continuous.comp |
| (continuous_fst.prodMk continuous_const)).add continuous_const)) |
|
|
| theorem unitSublevel_room (F : C(P × ℝ,ℝ)) (y : P) {h ε : ℝ} |
| (hh : 0 ≤ h) (hh1 : h < 1) (he : 0 < ε) : |
| ∃ u v : ℝ, u ∈ unitSublevel F h ε y ∧ v ∈ unitSublevel F h ε y ∧ h < v-u := by |
| obtain ⟨a,ha,hah,hg⟩ := unitRearrange_attained F y ⟨hh,hh1.le⟩ |
| obtain ⟨u,v,hu,hv,huv,hfu,hfv⟩ := exists_longer_strict_interval |
| (F.continuous.comp (continuous_const.prodMk continuous_id)) ha hah hh hh1 |
| (show F (y,a) < unitRearrange F (y,h)+ε by rw [hg]; linarith only [le_max_left (F (y,a)) (F (y,a+h)),he]) |
| (show F (y,a+h) < unitRearrange F (y,h)+ε by rw [hg]; linarith only [le_max_right (F (y,a)) (F (y,a+h)),he]) |
| exact ⟨u,v,⟨⟨hu,by linarith⟩,hfu⟩,⟨⟨by linarith,hv⟩,hfv⟩,huv⟩ |
|
|
| theorem unitSublevel_convex (F : C(P × ℝ,ℝ)) (y : P) |
| (hconv : ConvexOn ℝ (Icc 0 1) (fun v => F (y,v))) (h ε : ℝ) : |
| Convex ℝ (unitSublevel F h ε y) := by |
| have he : unitSublevel F h ε y = Ioo 0 1 ∩ |
| {v ∈ Icc 0 1 | F (y,v) < unitRearrange F (y,h)+ε} := by |
| ext v |
| exact ⟨fun hv => ⟨hv.1,⟨hv.1.1.le,hv.1.2.le⟩,hv.2⟩, |
| fun hv => ⟨hv.1,hv.2.2⟩⟩ |
| rw [he] |
| exact (convex_Ioo (𝕜 := ℝ) 0 1).inter (hconv.convex_lt _) |
|
|
| theorem unitSublevel_mono (F : C(P × ℝ,ℝ)) (y : P) |
| (hconv : ConvexOn ℝ (Icc 0 1) (fun v => F (y,v))) (ε : ℝ) : |
| MonotoneOn (fun h => unitSublevel F h ε y) (Icc 0 1) := by |
| intro h hh H hH hle v hv |
| refine ⟨hv.1,?_⟩ |
| have hg := unitRearrange_mono F y hconv hh hH hle |
| change unitRearrange F (y,h) ≤ unitRearrange F (y,H) at hg |
| linarith only [hv.2,hg] |
|
|
| end |
|
|
| def fixedIntervalValue (f : C(ℝ,ℝ)) (L h : ℝ) : C(UnitInterval,ℝ) where |
| toFun t := max (f (t.val*(L-h))) (f (t.val*(L-h)+h)) |
| continuous_toFun := (f.continuous.comp (continuous_subtype_val.mul continuous_const)).max |
| (f.continuous.comp ((continuous_subtype_val.mul continuous_const).add continuous_const)) |
|
|
| def intervalMinimum (f : C(ℝ,ℝ)) (L h : ℝ) : ℝ := minimum (fixedIntervalValue f L h) |
|
|
| theorem intervalMinimum_attained (f : C(ℝ,ℝ)) {L h : ℝ} (hh : h ∈ Icc 0 L) : |
| ∃ a : ℝ, 0 ≤ a ∧ a+h ≤ L ∧ intervalMinimum f L h = max (f a) (f (a+h)) := by |
| obtain ⟨t,ht⟩ := minimum_attained (fixedIntervalValue f L h) |
| refine ⟨t.val*(L-h),mul_nonneg t.property.1 (sub_nonneg.mpr hh.2),?_,ht.symm⟩ |
| nlinarith only [mul_nonneg (sub_nonneg.mpr t.property.2) (sub_nonneg.mpr hh.2)] |
|
|
| theorem intervalMinimum_le_candidate (f : C(ℝ,ℝ)) {L h a : ℝ} |
| (hh : h ∈ Icc 0 L) (ha : 0 ≤ a) (hah : a+h ≤ L) : |
| intervalMinimum f L h ≤ max (f a) (f (a+h)) := by |
| obtain ⟨t,ht⟩ := exists_unitInterval_mul (sub_nonneg.mpr hh.2) ha (by linarith) |
| simpa only [intervalMinimum,fixedIntervalValue,ContinuousMap.coe_mk,ht] using minimum_le (fixedIntervalValue f L h) t |
|
|
| theorem intervalMinimum_shortening (f : C(ℝ,ℝ)) {L l h ε : ℝ} |
| (_hl : 0 ≤ l) (hlL : l ≤ L) (hh : h ∈ Icc 0 l) |
| (hm : ∀ s ∈ Icc (0:ℝ) L, ∀ t ∈ Icc (0:ℝ) L, |
| |s-t| ≤ L-l → f s ≤ f t+ε) : |
| intervalMinimum f l h ≤ intervalMinimum f L h+ε := by |
| obtain ⟨a,ha,hah,he⟩ := intervalMinimum_attained f ⟨hh.1,hh.2.trans hlL⟩ |
| let b := min a (l-h) |
| have hb : 0 ≤ b := le_min ha (sub_nonneg.mpr hh.2) |
| have hbh : b+h ≤ l := by dsimp [b]; linarith [min_le_right a (l-h)] |
| have hba : b ≤ a := min_le_left _ _ |
| have hab : a-b ≤ L-l := by |
| dsimp [b] |
| rcases le_total a (l-h) with hx | hx |
| · rw [min_eq_left hx]; linarith |
| · rw [min_eq_right hx]; linarith |
| have h1 := hm b ⟨hb,by linarith [hh.1]⟩ a ⟨ha,by linarith [hh.1]⟩ |
| (by rw [abs_of_nonpos (sub_nonpos.mpr hba)]; linarith) |
| have h2 := hm (b+h) ⟨by linarith [hh.1],hbh.trans hlL⟩ (a+h) ⟨by linarith [hh.1],hah⟩ |
| (by rw [abs_of_nonpos (by linarith)]; linarith) |
| apply (intervalMinimum_le_candidate f hh hb hbh).trans |
| rw [he] |
| exact max_le ((h1.trans (add_le_add (le_max_left _ _) le_rfl))) |
| (h2.trans (add_le_add (le_max_right _ _) le_rfl)) |
|
|
| theorem intervalMinimum_outer_strip (f : C(ℝ,ℝ)) {L l h ε : ℝ} |
| (hh : h ∈ Icc 0 L) (hlh : l ≤ h) |
| (hm : ∀ s ∈ Icc (0:ℝ) L, ∀ t ∈ Icc (0:ℝ) L, |
| |s-t| ≤ L-l → f s ≤ f t+ε) : |
| f h ≤ intervalMinimum f L h+ε := by |
| obtain ⟨a,ha,hah,he⟩ := intervalMinimum_attained f hh |
| have h1 := hm h hh (a+h) ⟨by linarith [hh.1],hah⟩ |
| (by rw [abs_of_nonpos (by linarith)]; linarith) |
| rw [he] |
| exact h1.trans (add_le_add (le_max_right _ _) le_rfl) |
|
|
| theorem intervalMinimum_small (f : C(ℝ,ℝ)) {L h s ε : ℝ} |
| (hh : h ∈ Icc 0 L) (hs : s ∈ Icc 0 L) |
| (hm : ∀ u ∈ Icc (0:ℝ) L, ∀ v ∈ Icc (0:ℝ) L, f u ≤ f v+ε) : |
| f s ≤ intervalMinimum f L h+ε := by |
| obtain ⟨a,ha,hah,he⟩ := intervalMinimum_attained f hh |
| rw [he] |
| exact (hm s hs a ⟨ha,by linarith [hh.1]⟩).trans |
| (add_le_add (le_max_left _ _) le_rfl) |
|
|
| variable {P : Type*} [TopologicalSpace P] |
|
|
| def scaledUnitFamily (F : C(P × ℝ,ℝ)) (l : C(P,ℝ)) : C(P × ℝ,ℝ) := |
| F.comp ⟨fun p => (p.1,l p.1*p.2), continuous_fst.prodMk |
| ((l.continuous.comp continuous_fst).mul continuous_snd)⟩ |
|
|
| def fiberFunction (F : C(P × ℝ,ℝ)) (y : P) : C(ℝ,ℝ) := |
| F.comp ⟨fun t => (y,t),continuous_const.prodMk continuous_id⟩ |
|
|
| theorem unitRearrange_scaled (F : C(P × ℝ,ℝ)) (l : C(P,ℝ)) (y : P) |
| (hl : 0 < l y) {h : ℝ} (hh : h ∈ Icc 0 (l y)) : |
| unitRearrange (scaledUnitFamily F l) (y,h/l y) = intervalMinimum (fiberFunction F y) (l y) h := by |
| have hq : h/l y ∈ Icc (0:ℝ) 1 := |
| ⟨div_nonneg hh.1 hl.le,(div_le_one hl).mpr hh.2⟩ |
| change minimum ((unitIntervalValue (scaledUnitFamily F l)).curry (y,h/l y)) = |
| minimum (fixedIntervalValue (fiberFunction F y) (l y) h) |
| apply congrArg minimum |
| apply ContinuousMap.ext |
| intro t |
| simp only [unitIntervalValue,ContinuousMap.coe_mk,ContinuousMap.curry_apply, |
| clampUnit_eq hq,scaledUnitFamily,ContinuousMap.comp_apply,fiberFunction,fixedIntervalValue] |
| congr 2 <;> field_simp |
|
|
| end PackingSufficiencySupport.Comparison |
| end |
|
|
| end OAI |
|
|
