| import Mathlib |
| import OAI.Geometry.BallPacking.Holder.BanachSpace |
| import OAI.Geometry.BallPacking.Rigidity.CompatibleStructures |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity |
|
|
| section |
| open scoped ContDiff Topology Manifold |
| open Set Function Filter |
|
|
|
|
| theorem exists_smooth_cutoff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] {K U : Set E} (hK : IsCompact K) (hU : IsOpen U) |
| (hKU : K ⊆ U) : ∃ χ : E → ℝ, ContDiff ℝ ∞ χ ∧ HasCompactSupport χ ∧ |
| tsupport χ ⊆ U ∧ (∀ᶠ x in 𝓝ˢ K, χ x = 1) ∧ ∀ x, χ x ∈ Icc 0 1 := by |
| obtain ⟨L,hL,hKL,hLU⟩ := exists_compact_between hK hU hKU |
| obtain ⟨χ,hχ1,hχ0,hχrange⟩ := |
| exists_contMDiffMap_one_nhds_of_subset_interior 𝓘(ℝ,E) hK.isClosed hKL (n := ⊤) |
| have hs : tsupport (χ : E → ℝ) ⊆ L := by |
| apply closure_minimal _ hL.isClosed |
| intro x hx |
| by_contra hn |
| exact hx (hχ0 x hn) |
| exact ⟨χ,χ.contMDiff.contDiff,hL.of_isClosed_subset (isClosed_tsupport _) hs, |
| hs.trans hLU,hχ1,hχrange⟩ |
|
|
| def localizeJ {n : ℕ} (V : Set (Phase n)) (J : Phase n → End n) |
| (χ : Phase n → ℝ) (x : Phase n) : End n := by |
| classical |
| exact if x ∈ V then interpolateJ (J x) (χ x) else standardJ n |
|
|
| theorem localizeJ_compatible {n : ℕ} {V : Set (Phase n)} {J : Phase n → End n} |
| {χ : Phase n → ℝ} (hJ : ∀ x ∈ V, Compatible (J x)) |
| (hχ : ∀ x, χ x ∈ Icc (0 : ℝ) 1) (x : Phase n) : |
| Compatible (localizeJ V J χ x) := by |
| classical |
| by_cases hx : x ∈ V |
| · simpa only [localizeJ, ite_eq_left hx] using compatible_interpolateJ (hJ x hx) (hχ x) |
| · simpa only [localizeJ, ite_eq_right hx] using compatible_standardJ n |
|
|
| theorem localizeJ_eq_standard {n : ℕ} {V : Set (Phase n)} {J : Phase n → End n} |
| {χ : Phase n → ℝ} (hJ : ∀ x ∈ V, Compatible (J x)) {x : Phase n} |
| (hx : χ x = 0) : localizeJ V J χ x = standardJ n := by |
| classical |
| by_cases hV : x ∈ V |
| · simp only [localizeJ, ite_eq_left hV, hx, interpolateJ_zero (hJ x hV)] |
| · simp only [localizeJ, ite_eq_right hV] |
|
|
| theorem localizeJ_smooth {n : ℕ} {V : Set (Phase n)} (hV : IsOpen V) |
| {J : Phase n → End n} (hJs : ContDiffOn ℝ ∞ J V) |
| (hJ : ∀ x ∈ V, Compatible (J x)) {χ : Phase n → ℝ} |
| (hχs : ContDiff ℝ ∞ χ) (hχV : tsupport χ ⊆ V) |
| (hχ : ∀ x, χ x ∈ Icc (0 : ℝ) 1) : ContDiff ℝ ∞ (localizeJ V J χ) := by |
| classical |
| apply contDiff_iff_contDiffAt.mpr |
| intro x |
| by_cases hx : x ∈ V |
| · apply (contDiffAt_interpolateJ (hJs.contDiffAt (hV.mem_nhds hx)) hχs.contDiffAt |
| (hJ x hx) (hχ x)).congr_of_eventuallyEq |
| filter_upwards [hV.mem_nhds hx] with y hy |
| simp only [localizeJ, ite_eq_left hy] |
| · have hn : x ∉ tsupport χ := fun h => hx (hχV h) |
| apply (contDiffAt_const (c := standardJ n)).congr_of_eventuallyEq |
| filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hn] with y hy |
| exact localizeJ_eq_standard hJ hy |
|
|
| theorem localizeJ_eqOn {n : ℕ} {V K : Set (Phase n)} {J : Phase n → End n} |
| {χ : Phase n → ℝ} (hKV : K ⊆ V) (hJ : ∀ x ∈ V, Compatible (J x)) |
| (hχ : ∀ x ∈ K, χ x = 1) : EqOn (localizeJ V J χ) J K := by |
| classical |
| intro x hx |
| simp only [localizeJ, ite_eq_left (hKV hx), hχ x hx, interpolateJ_one (hJ x (hKV hx))] |
|
|
| theorem extend_two_compatible {n : ℕ} {K₀ K₁ V₀ V₁ W : Set (Phase n)} |
| (hK₀ : IsCompact K₀) (hK₁ : IsCompact K₁) (hdis : Disjoint K₀ K₁) |
| (hV₀ : IsOpen V₀) (hV₁ : IsOpen V₁) (hW : IsOpen W) |
| (hKV₀ : K₀ ⊆ V₀) (hKV₁ : K₁ ⊆ V₁) (hKW₀ : K₀ ⊆ W) (hKW₁ : K₁ ⊆ W) |
| {J₀ J₁ : Phase n → End n} (hJ₀s : ContDiffOn ℝ ∞ J₀ V₀) |
| (hJ₁s : ContDiffOn ℝ ∞ J₁ V₁) (hJ₀ : ∀ x ∈ V₀, Compatible (J₀ x)) |
| (hJ₁ : ∀ x ∈ V₁, Compatible (J₁ x)) : |
| ∃ J : Phase n → End n, ContDiff ℝ ∞ J ∧ (∀ x, Compatible (J x)) ∧ |
| (∀ᶠ x in 𝓝ˢ K₀, J x = J₀ x) ∧ (∀ᶠ x in 𝓝ˢ K₁, J x = J₁ x) ∧ |
| HasCompactSupport (fun x => J x - standardJ n) ∧ |
| tsupport (fun x => J x - standardJ n) ⊆ W := by |
| obtain ⟨O₀,O₁,hO₀,hO₁,hKO₀,hKO₁,hOdis⟩ := |
| normal_separation hK₀.isClosed hK₁.isClosed hdis |
| let A₀ := O₀ ∩ V₀ ∩ W |
| let A₁ := O₁ ∩ V₁ ∩ W |
| have hA₀ : IsOpen A₀ := (hO₀.inter hV₀).inter hW |
| have hA₁ : IsOpen A₁ := (hO₁.inter hV₁).inter hW |
| have hKA₀ : K₀ ⊆ A₀ := fun x hx => ⟨⟨hKO₀ hx,hKV₀ hx⟩,hKW₀ hx⟩ |
| have hKA₁ : K₁ ⊆ A₁ := fun x hx => ⟨⟨hKO₁ hx,hKV₁ hx⟩,hKW₁ hx⟩ |
| obtain ⟨χ₀,hχ₀s,hχ₀c,hχ₀A,hχ₀one,hχ₀I⟩ := exists_smooth_cutoff hK₀ hA₀ hKA₀ |
| obtain ⟨χ₁,hχ₁s,hχ₁c,hχ₁A,hχ₁one,hχ₁I⟩ := exists_smooth_cutoff hK₁ hA₁ hKA₁ |
| have hχdis : Disjoint (tsupport χ₀) (tsupport χ₁) := |
| hOdis.mono (fun _ hx => (hχ₀A hx).1.1) (fun _ hx => (hχ₁A hx).1.1) |
| have hA₀V : A₀ ⊆ V₀ := fun _ hx => hx.1.2 |
| have hA₁V : A₁ ⊆ V₁ := fun _ hx => hx.1.2 |
| have hJ₀A : ∀ x ∈ A₀, Compatible (J₀ x) := fun _ hx => hJ₀ _ (hA₀V hx) |
| have hJ₁A : ∀ x ∈ A₁, Compatible (J₁ x) := fun _ hx => hJ₁ _ (hA₁V hx) |
| let L₀ := localizeJ A₀ J₀ χ₀ |
| let L₁ := localizeJ A₁ J₁ χ₁ |
| have hL₀s : ContDiff ℝ ∞ L₀ := |
| localizeJ_smooth hA₀ (hJ₀s.mono hA₀V) hJ₀A hχ₀s hχ₀A hχ₀I |
| have hL₁s : ContDiff ℝ ∞ L₁ := |
| localizeJ_smooth hA₁ (hJ₁s.mono hA₁V) hJ₁A hχ₁s hχ₁A hχ₁I |
| have hL₀ (x) : Compatible (L₀ x) := localizeJ_compatible hJ₀A hχ₀I x |
| have hL₁ (x) : Compatible (L₁ x) := localizeJ_compatible hJ₁A hχ₁I x |
| have hL₀out (x) (hx : x ∉ tsupport χ₀) : L₀ x = standardJ n := |
| localizeJ_eq_standard hJ₀A (image_eq_zero_of_notMem_tsupport hx) |
| have hL₁out (x) (hx : x ∉ tsupport χ₁) : L₁ x = standardJ n := |
| localizeJ_eq_standard hJ₁A (image_eq_zero_of_notMem_tsupport hx) |
| let J := fun x => L₀ x + L₁ x - standardJ n |
| have hJs : ContDiff ℝ ∞ J := (hL₀s.add hL₁s).sub contDiff_const |
| have hJ (x) : Compatible (J x) := by |
| by_cases hx : x ∈ tsupport χ₀ |
| · have hx₁ : x ∉ tsupport χ₁ := fun hh => disjoint_left.mp hχdis hx hh |
| simpa only [J,hL₁out x hx₁,add_sub_cancel_right] using hL₀ x |
| · simpa only [J,hL₀out x hx,add_sub_cancel_left] using hL₁ x |
| have hzero (x) (hx : x ∉ tsupport χ₀ ∪ tsupport χ₁) : J x - standardJ n = 0 := by |
| have hx₀ : x ∉ tsupport χ₀ := fun hh => hx (Or.inl hh) |
| have hx₁ : x ∉ tsupport χ₁ := fun hh => hx (Or.inr hh) |
| simp only [J,hL₀out x hx₀,hL₁out x hx₁,add_sub_cancel_right,sub_self] |
| have hsupport : tsupport (fun x => J x - standardJ n) ⊆ tsupport χ₀ ∪ tsupport χ₁ := by |
| apply closure_minimal _ ((isClosed_tsupport χ₀).union (isClosed_tsupport χ₁)) |
| intro x hx |
| by_contra hn |
| exact hx (hzero x hn) |
| refine ⟨J,hJs,hJ,?_,?_,(hχ₀c.union hχ₁c).of_isClosed_subset (isClosed_tsupport _) hsupport, |
| fun x hx => ?_⟩ |
| · filter_upwards [hχ₀one] with x hx |
| have hx₀ : x ∈ tsupport χ₀ := subset_tsupport χ₀ (by simp [mem_support,hx]) |
| have hx₁ : x ∉ tsupport χ₁ := fun hh => disjoint_left.mp hχdis hx₀ hh |
| have hL : L₀ x = J₀ x := by |
| classical |
| simp only [L₀,localizeJ,ite_eq_left (hχ₀A hx₀),hx, |
| interpolateJ_one (hJ₀A x (hχ₀A hx₀))] |
| simp only [J,hL,hL₁out x hx₁,add_sub_cancel_right] |
| · filter_upwards [hχ₁one] with x hx |
| have hx₁ : x ∈ tsupport χ₁ := subset_tsupport χ₁ (by simp [mem_support,hx]) |
| have hx₀ : x ∉ tsupport χ₀ := fun hh => disjoint_left.mp hχdis hh hx₁ |
| have hL : L₁ x = J₁ x := by |
| classical |
| simp only [L₁,localizeJ,ite_eq_left (hχ₁A hx₁),hx, |
| interpolateJ_one (hJ₁A x (hχ₁A hx₁))] |
| simp only [J,hL₀out x hx₀,hL,add_sub_cancel_left] |
| · rcases hsupport hx with h | h |
| · exact (hχ₀A h).2 |
| · exact (hχ₁A h).2 |
|
|
| @[fun_prop] |
| theorem continuous_capacity (n : ℕ) : Continuous (capacity : Phase 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 : Phase 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)] |
|
|
| theorem adapt_two_ball_images {n : ℕ} {a b R : ℝ} |
| {U₀ U₁ : Set (Phase n)} {f₀ f₁ : Phase n → Phase n} |
| (hsub₀ : closedBall n a ⊆ U₀) (hsub₁ : closedBall n b ⊆ U₁) |
| (hf₀ : SymplecticOn U₀ f₀) (hf₁ : SymplecticOn U₁ f₁) |
| (ht₀ : MapsTo f₀ (closedBall n a) (openBall n R)) |
| (ht₁ : MapsTo f₁ (closedBall n b) (openBall n R)) |
| (hdis : Disjoint (f₀ '' closedBall n a) (f₁ '' closedBall n b)) : |
| ∃ J : Phase n → End n, ContDiff ℝ ∞ J ∧ (∀ x, Compatible (J x)) ∧ |
| (∀ᶠ x in 𝓝ˢ (f₀ '' closedBall n a), J x = imageJ U₀ f₀ x) ∧ |
| (∀ᶠ x in 𝓝ˢ (f₁ '' closedBall n b), J x = imageJ U₁ f₁ x) ∧ |
| HasCompactSupport (fun x => J x - standardJ n) ∧ |
| tsupport (fun x => J x - standardJ n) ⊆ openBall n R := by |
| exact extend_two_compatible |
| ((closedBall_isCompact n a).image_of_continuousOn (hf₀.2.1.continuousOn.mono hsub₀)) |
| ((closedBall_isCompact n b).image_of_continuousOn (hf₁.2.1.continuousOn.mono hsub₁)) |
| hdis (symplecticOn_open_image hf₀) (symplecticOn_open_image hf₁) (openBall_isOpen n R) |
| (image_mono hsub₀) (image_mono hsub₁) (image_subset_iff.mpr ht₀) (image_subset_iff.mpr ht₁) |
| (imageJ_smooth hf₀) (imageJ_smooth hf₁) |
| (fun _ hx => imageJ_compatible hf₀ hx) (fun _ hx => imageJ_compatible hf₁ hx) |
|
|
| theorem packing_two_has_adapted_structure {n : ℕ} {a b R : ℝ} |
| (hp : HasPacking n 2 R ![a,b]) : |
| ∃ (U : Fin 2 → Set (Phase n)) (f : Fin 2 → Phase n → Phase n) |
| (J : Phase n → End n), |
| (∀ i, closedBall n (![a,b] i) ⊆ U i ∧ SymplecticOn (U i) (f i) ∧ |
| MapsTo (f i) (closedBall n (![a,b] i)) (openBall n R)) ∧ |
| (∀ i j, i ≠ j → Disjoint (f i '' closedBall n (![a,b] i)) |
| (f j '' closedBall n (![a,b] j))) ∧ |
| ContDiff ℝ ∞ J ∧ (∀ x, Compatible (J x)) ∧ |
| (∀ i, ∀ᶠ x in 𝓝ˢ (f i '' closedBall n (![a,b] i)), J x = imageJ (U i) (f i) x) ∧ |
| HasCompactSupport (fun x => J x - standardJ n) ∧ |
| tsupport (fun x => J x - standardJ n) ⊆ openBall n R := by |
| obtain ⟨U,f,hf,hd⟩ := hp |
| obtain ⟨J,hJs,hJ,hJ₀,hJ₁,hJc,hJsupp⟩ := adapt_two_ball_images |
| (hf 0).1 (hf 1).1 (hf 0).2.1 (hf 1).2.1 (hf 0).2.2 (hf 1).2.2 |
| (hd 0 1 (by decide)) |
| refine ⟨U,f,J,hf,hd,hJs,hJ,?_,hJc,hJsupp⟩ |
| intro i |
| fin_cases i |
| · exact hJ₀ |
| · exact hJ₁ |
|
|
|
|
| end |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function Filter |
|
|
| def AffineLineCurve {n : ℕ} (J : Phase n → End n) (p q : Phase n) |
| (u : ℂ → Phase n) : Prop := |
| ContDiff ℝ ∞ u ∧ (∀ z, PseudoHolomorphicAt J u z) ∧ u 0 = p ∧ u 1 = q ∧ |
| ∃ v : Phase n, v ≠ 0 ∧ Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 v) |
|
|
| theorem pseudoHolomorphicAt_standard_of_complex {n : ℕ} {u : ℂ → Phase n} {z : ℂ} |
| (hu : DifferentiableAt ℂ u z) : |
| PseudoHolomorphicAt (fun _ => standardJ n) u z := by |
| refine ⟨hu.restrictScalars ℝ,?_⟩ |
| intro w |
| rw [(hu.hasFDerivAt.restrictScalars ℝ).fderiv] |
| change fderiv ℂ u z (Complex.I • w) = Complex.I • fderiv ℂ u z w |
| exact map_smul (fderiv ℂ u z) Complex.I w |
|
|
| theorem standard_affine_line {n : ℕ} (p q : Phase n) (hpq : p ≠ q) : |
| AffineLineCurve (fun _ => standardJ n) p q (fun z : ℂ => p + z • (q-p)) := by |
| have hs : ContDiff ℂ ∞ (fun z : ℂ => p + z • (q-p)) := |
| contDiff_const.add (contDiff_id.smul contDiff_const) |
| refine ⟨hs.restrict_scalars ℝ,fun z => |
| pseudoHolomorphicAt_standard_of_complex (hs.differentiable (by simp) z),by simp,by simp,?_,?_⟩ |
| · exact q-p |
| · refine ⟨sub_ne_zero.mpr hpq.symm,?_⟩ |
| have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by |
| simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ)) |
| have ht : Tendsto (fun z : ℂ => z⁻¹ • p + (q-p)) (cocompact ℂ) (𝓝 (q-p)) := by |
| simpa only [zero_smul, zero_add] using (hi.smul_const p).add_const (q-p) |
| apply ht.congr' |
| filter_upwards [(isCompact_singleton (x := (0:ℂ))).compl_mem_cocompact] with z hz |
| have hz0 : z ≠ 0 := by simpa only [mem_compl_iff, mem_singleton_iff] using hz |
| simp only [smul_add, smul_smul, inv_mul_cancel₀ hz0, one_smul] |
|
|
| theorem interpolateJ_standard {n : ℕ} {t : ℝ} (ht : t ∈ Icc (0:ℝ) 1) : |
| interpolateJ (standardJ n) t = standardJ n := by |
| have ha : 0 < 1+t := by linarith [ht.1] |
| have hb : 0 ≤ 1-t := by linarith [ht.2] |
| obtain ⟨e,he⟩ := cayleyP_invertible (compatible_standardJ n) ha hb |
| apply ContinuousLinearMap.ext |
| intro v |
| obtain ⟨x,rfl⟩ := e.surjective v |
| change standardJ n (cayleyOperator (standardJ n) (1+t) (1-t) ((e : End n) x)) = |
| standardJ n ((e : End n) x) |
| rw [he,cayleyOperator_on_denominator ⟨e,he⟩] |
| congr 1 |
| simp only [cayleyP_apply,relativeOperator_apply,standardJ_sq,neg_neg] |
| module |
|
|
| def lineHomotopy {n : ℕ} (J : Phase n → End n) (t : ℝ) (x : Phase n) : End n := |
| interpolateJ (J x) t |
|
|
| theorem lineHomotopy_compatible {n : ℕ} {J : Phase n → End n} |
| (hJ : ∀ x, Compatible (J x)) {t : ℝ} (ht : t ∈ Icc (0:ℝ) 1) (x : Phase n) : |
| Compatible (lineHomotopy J t x) := compatible_interpolateJ (hJ x) ht |
|
|
| theorem lineHomotopy_smooth {n : ℕ} {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x)) : |
| ContDiffOn ℝ ∞ (fun y : ℝ × Phase n => lineHomotopy J y.1 y.2) |
| ((Icc (0:ℝ) 1) ×ˢ univ) := by |
| intro y hy |
| exact (contDiffAt_interpolateJ (hJs.contDiffAt.comp y contDiffAt_snd) |
| contDiffAt_fst (hJ y.2) hy.1).contDiffWithinAt |
|
|
| @[simp] theorem lineHomotopy_zero {n : ℕ} {J : Phase n → End n} |
| (hJ : ∀ x, Compatible (J x)) (x : Phase n) : lineHomotopy J 0 x = standardJ n := |
| interpolateJ_zero (hJ x) |
|
|
| @[simp] theorem lineHomotopy_one {n : ℕ} {J : Phase n → End n} |
| (hJ : ∀ x, Compatible (J x)) (x : Phase n) : lineHomotopy J 1 x = J x := |
| interpolateJ_one (hJ x) |
|
|
| theorem lineHomotopy_support {n : ℕ} (J : Phase n → End n) |
| {t : ℝ} (ht : t ∈ Icc (0:ℝ) 1) : |
| tsupport (fun x => lineHomotopy J t x - standardJ n) ⊆ |
| tsupport (fun x => J x - standardJ n) := by |
| apply closure_minimal _ (isClosed_tsupport _) |
| intro x hx |
| by_contra hn |
| have hzero := image_eq_zero_of_notMem_tsupport hn |
| have hJx : J x = standardJ n := sub_eq_zero.mp hzero |
| apply hx |
| change interpolateJ (J x) t - standardJ n = 0 |
| rw [hJx,interpolateJ_standard ht,sub_self] |
|
|
| theorem lineHomotopy_compact {n : ℕ} {J : Phase n → End n} |
| (hJc : HasCompactSupport (fun x => J x - standardJ n)) |
| {t : ℝ} (ht : t ∈ Icc (0:ℝ) 1) : |
| HasCompactSupport (fun x => lineHomotopy J t x - standardJ n) := |
| hJc.of_isClosed_subset (isClosed_tsupport _) (lineHomotopy_support J ht) |
|
|
|
|
| end |
|
|
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
|
|
| def radialSwitch (σ τ t : ℝ) : ℝ := Real.smoothTransition ((t-σ)/(τ-σ)) |
|
|
| theorem radialSwitch_smooth (σ τ : ℝ) : ContDiff ℝ ∞ (radialSwitch σ τ) := |
| Real.smoothTransition.contDiff.comp ((contDiff_id.sub contDiff_const).div_const _) |
|
|
| theorem radialSwitch_nonneg (σ τ t : ℝ) : 0 ≤ radialSwitch σ τ t := |
| Real.smoothTransition.nonneg _ |
|
|
| theorem radialSwitch_le_one (σ τ t : ℝ) : radialSwitch σ τ t ≤ 1 := |
| Real.smoothTransition.le_one _ |
|
|
| theorem radialSwitch_zero {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| radialSwitch σ τ t = 0 := by |
| apply Real.smoothTransition.zero_of_nonpos |
| exact div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr ht) (sub_pos.mpr hστ).le |
|
|
| theorem radialSwitch_one {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) : |
| radialSwitch σ τ t = 1 := by |
| apply Real.smoothTransition.one_of_one_le |
| apply (le_div_iff₀ (sub_pos.mpr hστ)).mpr |
| linarith |
|
|
| def radialOffset (σ τ t : ℝ) : ℝ := ∫ s in σ..t, radialSwitch σ τ s |
|
|
| theorem radialOffset_hasDerivAt (σ τ t : ℝ) : |
| HasDerivAt (radialOffset σ τ) (radialSwitch σ τ t) t := by |
| have hc := (radialSwitch_smooth σ τ).continuous |
| exact intervalIntegral.integral_hasDerivAt_right (hc.intervalIntegrable _ _) |
| hc.stronglyMeasurable.stronglyMeasurableAtFilter hc.continuousAt |
|
|
| theorem radialOffset_smooth (σ τ : ℝ) : ContDiff ℝ ∞ (radialOffset σ τ) := by |
| apply contDiff_infty_iff_deriv.mpr |
| refine ⟨fun t => (radialOffset_hasDerivAt σ τ t).differentiableAt,?_⟩ |
| have he : deriv (radialOffset σ τ) = radialSwitch σ τ := |
| funext (fun t => (radialOffset_hasDerivAt σ τ t).deriv) |
| rw [he] |
| exact radialSwitch_smooth σ τ |
|
|
| theorem radialOffset_zero {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| radialOffset σ τ t = 0 := by |
| unfold radialOffset |
| calc |
| (∫ s in σ..t, radialSwitch σ τ s) = ∫ s in σ..t, (0:ℝ) := by |
| apply intervalIntegral.integral_congr |
| intro s hs |
| exact radialSwitch_zero hστ ((uIcc_of_ge ht ▸ hs).2) |
| _ = 0 := by simp |
|
|
| theorem radialOffset_nonneg {σ τ : ℝ} (hστ : σ < τ) (t : ℝ) : |
| 0 ≤ radialOffset σ τ t := by |
| by_cases ht : t ≤ σ |
| · rw [radialOffset_zero hστ ht] |
| · exact intervalIntegral.integral_nonneg (le_of_not_ge ht) |
| (fun s _ => radialSwitch_nonneg σ τ s) |
|
|
| def radialShift (σ τ : ℝ) : ℝ := 1 + radialOffset σ τ τ - τ |
|
|
| theorem radialShift_pos {σ τ : ℝ} (hστ : σ < τ) (hτ : τ < 1) : |
| 0 < radialShift σ τ := by |
| have hn := radialOffset_nonneg hστ τ |
| unfold radialShift |
| linarith |
|
|
| theorem radialOffset_after {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) : |
| 1 + radialOffset σ τ t = t + radialShift σ τ := by |
| have hc := (radialSwitch_smooth σ τ).continuous |
| have he := intervalIntegral.integral_add_adjacent_intervals |
| (hc.intervalIntegrable (μ := volume) σ τ) (hc.intervalIntegrable τ t) |
| have hI : (∫ s in τ..t, radialSwitch σ τ s) = t-τ := by |
| calc |
| _ = ∫ s in τ..t, (1:ℝ) := by |
| apply intervalIntegral.integral_congr |
| intro s hs |
| exact radialSwitch_one hστ ((uIcc_of_le ht ▸ hs).1) |
| _ = t-τ := by simp |
| rw [hI] at he |
| change radialOffset σ τ τ + (t-τ) = radialOffset σ τ t at he |
| unfold radialShift |
| linarith |
|
|
| def radialCoefficient (σ τ t : ℝ) : ℝ := (1 + radialOffset σ τ t)⁻¹ |
|
|
| theorem radialCoefficient_pos {σ τ : ℝ} (hστ : σ < τ) (t : ℝ) : |
| 0 < radialCoefficient σ τ t := |
| inv_pos.mpr (by linarith [radialOffset_nonneg hστ t]) |
|
|
| theorem radialCoefficient_smooth {σ τ : ℝ} (hστ : σ < τ) : |
| ContDiff ℝ ∞ (radialCoefficient σ τ) := |
| (contDiff_const.add (radialOffset_smooth σ τ)).inv |
| (fun t => ne_of_gt (by linarith [radialOffset_nonneg hστ t])) |
|
|
| theorem radialCoefficient_hasDerivAt {σ τ : ℝ} (hστ : σ < τ) (t : ℝ) : |
| HasDerivAt (radialCoefficient σ τ) |
| (-radialSwitch σ τ t / (1 + radialOffset σ τ t)^2) t := by |
| have hd : HasDerivAt (fun x : ℝ => 1 + radialOffset σ τ x) (radialSwitch σ τ t) t := |
| (radialOffset_hasDerivAt σ τ t).const_add 1 |
| exact hd.inv (ne_of_gt (by linarith [radialOffset_nonneg hστ t])) |
|
|
| theorem radialCoefficient_one {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| radialCoefficient σ τ t = 1 := by |
| simp only [radialCoefficient,radialOffset_zero hστ ht,add_zero,inv_one] |
|
|
| theorem radialCoefficient_after {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) : |
| radialCoefficient σ τ t = (t + radialShift σ τ)⁻¹ := by |
| rw [radialCoefficient,radialOffset_after hστ ht] |
|
|
| def radialMoment (σ τ t : ℝ) : ℝ := t * radialCoefficient σ τ t |
|
|
| theorem radialMoment_hasDerivAt {σ τ : ℝ} (hστ : σ < τ) (t : ℝ) : |
| HasDerivAt (radialMoment σ τ) |
| ((1 + radialOffset σ τ t - t * radialSwitch σ τ t) / |
| (1 + radialOffset σ τ t)^2) t := by |
| have hd : HasDerivAt (radialMoment σ τ) |
| (1 * radialCoefficient σ τ t + t * (-radialSwitch σ τ t / |
| (1 + radialOffset σ τ t)^2)) t := |
| (hasDerivAt_id t).mul (radialCoefficient_hasDerivAt hστ t) |
| have hn : 1 + radialOffset σ τ t ≠ 0 := |
| ne_of_gt (by linarith [radialOffset_nonneg hστ t]) |
| have he : 1 * radialCoefficient σ τ t + t * (-radialSwitch σ τ t / |
| (1 + radialOffset σ τ t)^2) = |
| (1 + radialOffset σ τ t - t * radialSwitch σ τ t) / |
| (1 + radialOffset σ τ t)^2 := by |
| simp only [one_mul,radialCoefficient] |
| field_simp |
| ring |
| rw [←he] |
| exact hd |
|
|
| theorem radialMoment_derivative_pos {σ τ : ℝ} (hστ : σ < τ) (hτ : τ < 1) (t : ℝ) : |
| 0 < (1 + radialOffset σ τ t - t * radialSwitch σ τ t) / |
| (1 + radialOffset σ τ t)^2 := by |
| apply div_pos _ (sq_pos_of_pos (by linarith [radialOffset_nonneg hστ t])) |
| by_cases htσ : t ≤ σ |
| · rw [radialOffset_zero hστ htσ,radialSwitch_zero hστ htσ] |
| norm_num |
| by_cases htτ : t ≤ τ |
| · have ht1 : t < 1 := htτ.trans_lt hτ |
| have hs0 := radialSwitch_nonneg σ τ t |
| have hs1 := radialSwitch_le_one σ τ t |
| have hφ := radialOffset_nonneg hστ t |
| have hm : t * radialSwitch σ τ t < 1 := by |
| by_cases ht0 : 0 ≤ t |
| · exact (mul_le_mul_of_nonneg_left hs1 ht0).trans_lt (by simpa using ht1) |
| · exact (mul_nonpos_of_nonpos_of_nonneg (le_of_not_ge ht0) hs0).trans_lt zero_lt_one |
| linarith |
| · have htτ' : τ ≤ t := le_of_not_ge htτ |
| rw [radialOffset_after hστ htτ',radialSwitch_one hστ htτ',mul_one] |
| linarith [radialShift_pos hστ hτ] |
|
|
| @[simp] theorem radialMoment_zero {σ τ : ℝ} : radialMoment σ τ 0 = 0 := by |
| simp [radialMoment] |
|
|
| theorem radialMoment_before {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| radialMoment σ τ t = t := by |
| rw [radialMoment,radialCoefficient_one hστ ht,mul_one] |
|
|
| theorem radialMoment_after {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) : |
| radialMoment σ τ t = t / (t + radialShift σ τ) := by |
| rw [radialMoment, radialCoefficient_after hστ ht,div_eq_mul_inv] |
|
|
| theorem radialMoment_tendsto_one {σ τ : ℝ} (hστ : σ < τ) : |
| Tendsto (radialMoment σ τ) atTop (𝓝 1) := by |
| have ht : Tendsto (fun t : ℝ => t + radialShift σ τ) atTop atTop := |
| Filter.tendsto_atTop_add_const_right _ _ tendsto_id |
| have hc : Tendsto (fun t : ℝ => radialShift σ τ / (t + radialShift σ τ)) |
| atTop (𝓝 0) := tendsto_const_nhds.div_atTop ht |
| have hl : Tendsto (fun t : ℝ => 1 - radialShift σ τ / (t + radialShift σ τ)) |
| atTop (𝓝 1) := by simpa using tendsto_const_nhds.sub hc |
| apply hl.congr' |
| filter_upwards [eventually_ge_atTop τ, eventually_gt_atTop (-radialShift σ τ)] with t htτ ht0 |
| rw [radialMoment_after hστ htτ] |
| have hn : t + radialShift σ τ ≠ 0 := by linarith |
| field_simp |
| ring |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
