lean/OAI/Geometry/BallPacking/Necessity/GradientLimits.lean

import Mathlib
import OAI.Geometry.BallPacking.Necessity.FreezeJ
import OAI.Geometry.BallPacking.Necessity.SchauderBounds

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 ContDiff Topology
open Set Filter Function
namespace HigherDimensionalBallPacking.Rigidity

theorem exists_nested_complex_cutoffs :
    ∃ (χ θ : ℂ → ℝ) (D : ℝ), 0 ≤ D ∧
      ContDiff ℝ ∞ χ ∧ HasCompactSupport χ ∧
      ContDiff ℝ ∞ θ ∧ HasCompactSupport θ ∧
      tsupport χ ⊆ Metric.closedBall (0:ℂ) 2 ∧
      tsupport θ ⊆ Metric.closedBall (0:ℂ) 3 ∧
      χ =ᶠ[𝓝 0] (fun _ => (1:ℝ)) ∧
      (∀ z ∈ tsupport χ, θ z=1) ∧
      (∀ z, |χ z| ≤ 1 ∧ |θ z| ≤ 1) ∧
      (∀ z, ‖fderiv ℝ χ z‖ ≤ D ∧ ‖fderiv ℝ (fderiv ℝ χ) z‖ ≤ D ∧
        ‖fderiv ℝ θ z‖ ≤ D) := by
  let χ : ContDiffBump (0:ℂ) := ⟨1,2,by norm_num,by norm_num⟩
  let θ : ContDiffBump (0:ℂ) := ⟨2,3,by norm_num,by norm_num⟩
  have hχ : ContDiff ℝ ∞ (χ : ℂ → ℝ) := χ.contDiff
  have hθ : ContDiff ℝ ∞ (θ : ℂ → ℝ) := θ.contDiff
  have hχD : ContDiff ℝ ∞ (fderiv ℝ (χ : ℂ → ℝ)) := hχ.fderiv_right (by simp)
  obtain ⟨D₁,hD₁,hB₁⟩ := ((χ.hasCompactSupport.fderiv ℝ).isCompact_range
    (hχ.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le
  have hbD2 : Bornology.IsBounded (range (fderiv ℝ (fderiv ℝ (χ : ℂ → ℝ)))) :=
    (((χ.hasCompactSupport.fderiv ℝ).fderiv ℝ).isCompact_range
      (hχD.continuous_fderiv (by simp))).isBounded
  obtain ⟨D₂,hD₂,hB₂⟩ := hbD2.exists_pos_norm_le
  obtain ⟨D₃,hD₃,hB₃⟩ := ((θ.hasCompactSupport.fderiv ℝ).isCompact_range
    (hθ.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le
  refine ⟨χ,θ,D₁+D₂+D₃,by positivity,hχ,χ.hasCompactSupport,hθ,θ.hasCompactSupport,?_,?_,?_,?_,?_,?_⟩
  · rw [χ.tsupport_eq]
  · rw [θ.tsupport_eq]
  · exact χ.eventuallyEq_one
  · intro z hz
    rw [χ.tsupport_eq] at hz
    exact θ.one_of_mem_closedBall hz
  · intro z
    constructor
    · rw [abs_of_nonneg χ.nonneg]
      exact χ.le_one
    · rw [abs_of_nonneg θ.nonneg]
      exact θ.le_one
  · intro z
    have h1 := hB₁ _ (mem_range_self z)
    have h2 := hB₂ _ (mem_range_self z)
    have h3 := hB₃ _ (mem_range_self z)
    exact ⟨by linarith,by linarith,by linarith⟩


 

 

 

open scoped Topology ContDiff
open Set Filter Function
section
variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

theorem derivative_bound_of_holder_and_values (f : E → F)
    (hf : Differentiable ℝ f) {M C r α : ℝ} (hM : 0 ≤ M) (hC : 0 ≤ C)
    (hr : 0 < r) (hα : 0 ≤ α)
    (hv : ∀ z ∈ Metric.closedBall (0:E) r, ‖f z‖ ≤ M)
    (hD : ∀ z ∈ Metric.closedBall (0:E) r,
      ‖fderiv ℝ f z-fderiv ℝ f 0‖ ≤ C*‖z‖^α) :
    ‖fderiv ℝ f 0‖ ≤ 2*M/r+C*r^α := by
  apply ContinuousLinearMap.opNorm_le_of_unit_norm (by positivity)
  intro v hvn
  have hrv : r • v ∈ Metric.closedBall (0:E) r := by
    simp [Metric.mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_pos hr,hvn]
  have h0 : (0:E) ∈ Metric.closedBall (0:E) r := Metric.mem_closedBall_self hr.le
  have herr := (convex_closedBall (0:E) r).norm_image_sub_le_of_norm_fderiv_le'
    (fun z _ => hf z) (φ := fderiv ℝ f 0) (C := C*r^α)
    (fun z hz => (hD z hz).trans (mul_le_mul_of_nonneg_left
      (Real.rpow_le_rpow (norm_nonneg _) (by simpa using hz) hα) hC)) h0 hrv
  simp only [sub_zero,norm_smul,Real.norm_eq_abs,abs_of_pos hr,hvn,mul_one] at herr
  have hval : ‖f (r • v)-f 0‖ ≤ 2*M :=
    (norm_sub_le _ _).trans (by linarith [hv (r • v) hrv,hv 0 h0])
  have hsum := norm_sub_le (f (r • v)-f 0)
    (f (r • v)-f 0-(fderiv ℝ f 0) (r • v))
  rw [sub_sub_cancel] at hsum
  rw [map_smul,norm_smul,Real.norm_eq_abs,abs_of_pos hr] at hsum
  rw [map_smul] at herr
  have hbound : r*‖(fderiv ℝ f 0) v‖ ≤ 2*M+(C*r^α)*r := by linarith
  have hh : ‖(fderiv ℝ f 0) v‖ ≤ (2*M+(C*r^α)*r)/r :=
    (le_div_iff₀ hr).mpr (by nlinarith)
  convert hh using 1
  field_simp

theorem norm_fderiv_tendsto_zero_of_holder {f : ℕ → E → F}
    (hf : ∀ j, Differentiable ℝ (f j)) {C α : ℝ} (hC : 0 ≤ C) (hα : 0 < α)
    (hD : ∀ᶠ j in atTop, ∀ x y, ‖fderiv ℝ (f j) x-fderiv ℝ (f j) y‖ ≤ C*‖x-y‖^α)
    (hv : TendstoUniformlyOn f (fun _ => (0:F)) atTop (Metric.closedBall (0:E) 1)) :
    Tendsto (fun j => ‖fderiv ℝ (f j) 0‖) atTop (𝓝 0) := by
  apply tendsto_order.2
  constructor
  · intro a ha
    exact Eventually.of_forall (fun j => ha.trans_le (norm_nonneg _))
  intro ε hε
  have hpow : Tendsto (fun r : ℝ => C*r^α) (𝓝[>] 0) (𝓝 0) := by
    simpa [Real.zero_rpow (ne_of_gt hα)] using
      ((tendsto_const_nhds : Tendsto (fun _ : ℝ => C) (𝓝[>] 0) (𝓝 C)).mul
        ((Real.continuousAt_rpow_const 0 α (Or.inr hα.le)).tendsto.mono_left nhdsWithin_le_nhds))
  have hs := hpow.eventually (gt_mem_nhds (show 0 < ε/2 by linarith))
  have hs' : ∀ᶠ r : ℝ in 𝓝[>] 0, r < 1 :=
    (eventually_lt_nhds (show (0:ℝ) < 1 by norm_num)).filter_mono nhdsWithin_le_nhds
  have hpos : ∀ᶠ r : ℝ in 𝓝[>] 0, 0 < r := self_mem_nhdsWithin
  obtain ⟨r,hr,hr1,hsmall⟩ := (hpos.and (hs'.and hs)).exists
  have hδ : 0 < ε*r/8 := by positivity
  have hev := (Metric.tendstoUniformlyOn_iff.mp hv) (ε*r/8) hδ
  filter_upwards [hev,hD] with j hj hjD
  have hb := derivative_bound_of_holder_and_values (f j) (hf j) (M := ε*r/8)
    (C := C) hδ.le hC hr hα.le
    (fun z hz => le_of_lt (by
      have hh := hj z (Metric.closedBall_subset_closedBall hr1.le hz)
      simpa [dist_eq_norm] using hh))
    (fun z _ => by simpa using hjD z 0)
  have hid : 2*(ε*r/8)/r=ε/4 := by field_simp; ring
  rw [hid] at hb
  linarith

end

 

 

 

open scoped ContDiff Topology BoundedContinuousFunction
open Set Filter Function
section
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
local instance gradientLimitsC1NormedAddCommGroup (α : ℝ) : NormedAddCommGroup (C1HolderSpace E α) := inferInstance
local instance gradientLimitsC1NormedSpace (α : ℝ) : NormedSpace ℝ (C1HolderSpace E α) := inferInstance
local instance gradientLimitsCompactNormedAddCommGroup (F : Type) [NormedAddCommGroup F] [NormedSpace ℝ F] (R : ℝ) :
    NormedAddCommGroup (CompactHolderSpace F R) := inferInstance
local instance gradientLimitsCompactNormedSpace (F : Type) [NormedAddCommGroup F] [NormedSpace ℝ F] (R : ℝ) :
    NormedSpace ℝ (CompactHolderSpace F R) := inferInstance

private theorem exists_small_principal_const (B K : ℝ) :
    ∃ δ : ℝ, 0 < δ ∧ δ ≤ 1 ∧
      B*max δ ((2*δ)^((2:ℝ)/3)*K^((1:ℝ)/3)) ≤ 1/2 := by
  let g : ℝ → ℝ := fun r => B*max r ((2*r)^((2:ℝ)/3)*K^((1:ℝ)/3))
  have hg : Continuous g := by
    exact continuous_const.mul (continuous_id.max
      (((Real.continuous_rpow_const (by norm_num : (0:ℝ) ≤ 2/3)).comp
        (continuous_const.mul continuous_id)).mul continuous_const))
  have hg0 : g 0=0 := by simp [g,Real.zero_rpow (show (2:ℝ)/3 ≠ 0 by norm_num)]
  have hev : ∀ᶠ r : ℝ in 𝓝[>] 0, g r < 1/2 := by
    have ht : Tendsto g (𝓝[>] 0) (𝓝 (g 0)) :=
      hg.continuousAt.tendsto.mono_left nhdsWithin_le_nhds
    exact ht.eventually (gt_mem_nhds (show g 0 < (1:ℝ)/2 by rw [hg0]; norm_num))
  have hr1 : ∀ᶠ r : ℝ in 𝓝[>] 0, r < 1 :=
    (eventually_lt_nhds (show (0:ℝ) < 1 by norm_num)).filter_mono nhdsWithin_le_nhds
  have hr0 : ∀ᶠ r : ℝ in 𝓝[>] 0, 0 < r := self_mem_nhdsWithin
  obtain ⟨r,h0,h1,hg⟩ := (hr0.and (hr1.and hev)).exists
  exact ⟨r,h0,h1.le,hg.le⟩

theorem smallCR_sequence_derivative_zero
    (u : ℕ → ℂ → E) (hu : ∀ j, ContDiff ℝ ∞ (u j))
    (A : ℕ → ℂ → E →L[ℝ] E) (hA : ∀ j, ContDiff ℝ ∞ (A j))
    {L K : ℝ} (hL : 0 ≤ L) (hK : 0 ≤ K)
    (huD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (u j) z‖ ≤ L)
    (hAD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (A j) z‖ ≤ K)
    (hCR : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      fderiv ℝ (u j) z Complex.I-Complex.I • fderiv ℝ (u j) z 1=
        A j z (fderiv ℝ (u j) z 1))
    (hu0 : TendstoUniformlyOn u (fun _ => (0:E)) atTop (Metric.closedBall (0:ℂ) 3))
    (hA0 : TendstoUniformlyOn A (fun _ => (0:E →L[ℝ] E)) atTop (Metric.closedBall (0:ℂ) 3)) :
    Tendsto (fun j => ‖fderiv ℝ (u j) 0‖) atTop (𝓝 0) := by
  obtain ⟨χ,θ,D,hD,hχ,hχc,hθ,hθc,hχ2,hθ3,hχ1,hθ1,hχθ,hd⟩ := exists_nested_complex_cutoffs
  have hχ3 : tsupport χ ⊆ Metric.closedBall (0:ℂ) 3 :=
    hχ2.trans (Metric.closedBall_subset_closedBall (by norm_num))
  let B := 2*‖compactCRInverse (E := E) 3‖*‖c1HolderDx (E := E)‖
  obtain ⟨δ,hδ,hδ1,hsmall⟩ := exists_small_principal_const B (K+D)
  have hu1 : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖u j z‖ ≤ 1 := by
    filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu0 1 (by norm_num)] with j hj
    intro z hz
    exact le_of_lt (by simpa [dist_eq_norm] using hj z hz)
  have hAδ : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖A j z‖ ≤ δ := by
    filter_upwards [Metric.tendstoUniformlyOn_iff.mp hA0 δ hδ] with j hj
    intro z hz
    exact le_of_lt (by simpa [dist_eq_norm] using hj z hz)
  let v : ℕ → ℂ → E := fun j z => χ z • u j z
  have hv : ∀ j, ContDiff ℝ ∞ (v j) := fun j => hχ.smul (hu j)
  have hv0 : TendstoUniformlyOn v (fun _ => (0:E)) atTop (Metric.closedBall (0:ℂ) 1) := by
    rw [Metric.tendstoUniformlyOn_iff]
    intro ε hε
    filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu0 ε hε] with j hj
    intro z hz
    simp only [dist_zero_left,v,norm_smul,Real.norm_eq_abs]
    exact (mul_le_mul_of_nonneg_right (hχθ z).1 (norm_nonneg _)).trans_lt (by
      simpa only [one_mul,dist_zero_left] using hj z
        (Metric.closedBall_subset_closedBall (by norm_num : (1:ℝ) ≤ 3) hz))
  have hvD : ∀ᶠ j in atTop, ∀ x y,
      ‖fderiv ℝ (v j) x-fderiv ℝ (v j) y‖ ≤
        localSchauderBound E 3 D L (K+D)*‖x-y‖^((1:ℝ)/3) := by
    filter_upwards [huD,hAD,hCR,hu1,hAδ] with j hjD hjAD hjCR hj1 hjAδ
    let AA : ℂ → E →L[ℝ] E := fun z => θ z • A j z
    have hAA : ContDiff ℝ ∞ AA := hθ.smul (hA j)
    have hAAc : HasCompactSupport AA := hθc.smul_right
    have hAAs : tsupport AA ⊆ Metric.closedBall (0:ℂ) 3 :=
      (tsupport_smul_subset_left θ (A j)).trans hθ3
    have hb := cutoff_smul_bounds hθ (hA j) hθ3 (C := 1) (D := D) (M := δ) (L := K)
      (by norm_num) hD hδ.le hK (fun z => (hχθ z).2) (fun z => (hd z).2.2) hjAδ hjAD
    have hAAv : ∀ z, ‖AA z‖ ≤ δ := by simpa only [one_mul] using hb.1
    have hAAD : ∀ z, ‖fderiv ℝ AA z‖ ≤ K+D := by
      intro z
      exact (hb.2 z).trans (by nlinarith)
    apply cutoff_smallCR_schauder 3 χ hχ hχc hχ3 AA hAA hAAc hAAs (u j) (hu j)
      hD hL (add_nonneg hK hD) hδ.le hδ1 (fun z => (hd z).1)
      (fun z => (hd z).2.1) (fun z hz => hj1 z (hχ3 hz)) (fun z hz => hjD z (hχ3 hz))
      hAAv hAAD
    · intro z hz
      rw [show AA z=A j z by simp only [AA,hθ1 z hz,one_smul]]
      exact hjCR z (hχ3 hz)
    · dsimp [B] at hsmall
      nlinarith only [hsmall]
  have hC : 0 ≤ localSchauderBound E 3 D L (K+D) := by
    dsimp [localSchauderBound]
    positivity
  have hlim := norm_fderiv_tendsto_zero_of_holder (fun j => (hv j).differentiable (by simp))
    hC (by norm_num : (0:ℝ) < 1/3) hvD hv0
  convert hlim using 1
  funext j
  congr 1
  apply Filter.EventuallyEq.fderiv_eq
  filter_upwards [hχ1] with z hz
  simp only [v,hz,one_smul]

end

 

 

 

open scoped Topology
open Set Filter Function
section
variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
  [NormedAddCommGroup G] [NormedSpace ℝ G]

omit [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] in
theorem locally_uniform_comp_uniform_constant
    [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G]
    {f : ℕ → E → F} {v : E → F}
    (hv : TendstoLocallyUniformly f v atTop) {x : E} (hvc : ContinuousAt v x)
    {g : ℕ → G → E} {K : Set G}
    (hg : TendstoUniformlyOn g (fun _ => x) atTop K) :
    TendstoUniformlyOn (fun j z => f j (g j z)) (fun _ => v x) atTop K := by
  rw [Metric.tendstoUniformlyOn_iff]
  intro ε hε
  have he := show {p : F × F | dist p.1 p.2 < ε/2} ∈ uniformity F from
    Metric.dist_mem_uniformity (by linarith)
  obtain ⟨U,hU,hUf⟩ := hv _ he x
  obtain ⟨V,hV,hVc⟩ := Metric.continuousAt_iff.mp hvc (ε/2) (by linarith)
  obtain ⟨δ,hδ,hδU⟩ := Metric.mem_nhds_iff.mp hU
  have hmin : 0 < min δ V := lt_min hδ hV
  filter_upwards [hUf,Metric.tendstoUniformlyOn_iff.mp hg (min δ V) hmin] with j hj hjg
  intro z hz
  have hgdist : dist (g j z) x < min δ V := by simpa [dist_comm] using hjg z hz
  have hmem : g j z ∈ U := hδU (hgdist.trans_le (min_le_left _ _))
  have h1 := hj (g j z) hmem
  have h2 := hVc (lt_of_lt_of_le hgdist (min_le_right _ _))
  have ht := dist_triangle (v x) (v (g j z)) (f j (g j z))
  rw [dist_comm (v x) (v (g j z))] at ht
  linarith

omit [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] in
theorem continuousAt_comp_uniform_constant
    [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G]
    {g : E → F} {x : E}
    (hg : ContinuousAt g x) {u : ℕ → G → E} {K : Set G}
    (hu : TendstoUniformlyOn u (fun _ => x) atTop K) :
    TendstoUniformlyOn (fun j z => g (u j z)) (fun _ => g x) atTop K := by
  rw [Metric.tendstoUniformlyOn_iff]
  intro ε hε
  obtain ⟨δ,hδ,hb⟩ := Metric.continuousAt_iff.mp hg ε hε
  filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu δ hδ] with j hj
  intro z hz
  rw [dist_comm]
  exact hb (by simpa [dist_comm] using hj z hz)

omit [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] in
theorem uniform_constant_prod
    [NormedSpace ℝ E] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G]
    {x : ℕ → E} {p : E} (hx : Tendsto x atTop (𝓝 p))
    {u : ℕ → G → F} {q : F} {K : Set G}
    (hu : TendstoUniformlyOn u (fun _ => q) atTop K) :
    TendstoUniformlyOn (fun j z => (x j,u j z)) (fun _ => (p,q)) atTop K := by
  rw [Metric.tendstoUniformlyOn_iff]
  intro ε hε
  filter_upwards [Metric.tendsto_nhds.mp hx ε hε,Metric.tendstoUniformlyOn_iff.mp hu ε hε] with j hj hju
  intro z hz
  rw [Prod.dist_eq]
  exact max_lt (by simpa [dist_comm] using hj) (hju z hz)

theorem affine_rescale_uniform_constant {x : ℕ → E} {c : E}
    (hx : Tendsto x atTop (𝓝 c)) {r : ℕ → ℝ} (hr : Tendsto r atTop (𝓝 0))
    {K : Set E} (hK : Bornology.IsBounded K) :
    TendstoUniformlyOn (fun j z => x j+r j • z) (fun _ => c) atTop K := by
  obtain ⟨M,hM,hMb⟩ := hK.exists_pos_norm_le
  rw [Metric.tendstoUniformlyOn_iff]
  intro ε hε
  have hsmall : ∀ᶠ j in atTop, dist (x j) c+|r j| * M < ε := by
    have ht : Tendsto (fun j => dist (x j) c+|r j| * M) atTop (𝓝 0) := by
      simpa using (hx.dist (tendsto_const_nhds (x := c))).add (hr.abs.mul_const M)
    exact ht.eventually (gt_mem_nhds hε)
  filter_upwards [hsmall] with j hj
  intro z hz
  rw [dist_comm,dist_eq_norm]
  have he : x j+r j • z-c=(x j-c)+r j • z := by abel
  rw [he]
  apply (norm_add_le _ _).trans_lt
  rw [norm_smul,Real.norm_eq_abs]
  apply lt_of_le_of_lt _ hj
  rw [dist_eq_norm]
  exact add_le_add le_rfl (mul_le_mul_of_nonneg_left (hMb z hz) (abs_nonneg _))

theorem rescaled_maps_uniform_constant {f : ℕ → E → F} {v : E → F}
    (hv : TendstoLocallyUniformly f v atTop) {x : ℕ → E} {c : E}
    (hvc : ContinuousAt v c) (hx : Tendsto x atTop (𝓝 c))
    {r : ℕ → ℝ} (hr : Tendsto r atTop (𝓝 0)) {K : Set E} (hK : Bornology.IsBounded K) :
    TendstoUniformlyOn (fun j z => f j (x j+r j • z)) (fun _ => v c) atTop K :=
  locally_uniform_comp_uniform_constant hv hvc (affine_rescale_uniform_constant hx hr hK)

end

 

 

 

open scoped ContDiff Topology
open Set Filter Function
section
open HigherDimensionalBallPacking.Rigidity

def frameConjugation {n : ℕ} (S : Phase n ≃L[ℝ] Phase n) : End n →L[ℝ] End n :=
  (ContinuousLinearMap.compL ℝ (Phase n) (Phase n) (Phase n) S.toContinuousLinearMap).comp
    ((ContinuousLinearMap.compL ℝ (Phase n) (Phase n) (Phase n)).flip S.symm.toContinuousLinearMap)

@[simp] theorem frameConjugation_apply {n : ℕ} (S : Phase n ≃L[ℝ] Phase n) (B : End n) :
    frameConjugation S B=S.toContinuousLinearMap.comp (B.comp S.symm.toContinuousLinearMap) := rfl

theorem frozenCoefficient_fderiv {n : ℕ} (S : Phase n ≃L[ℝ] Phase n) (J : End n)
    {B : ℂ → End n} (hB : Differentiable ℝ B) (z : ℂ) :
    fderiv ℝ (frozenCoefficient S J B) z=(frameConjugation S).comp (fderiv ℝ B z) :=
  ((frameConjugation S).hasFDerivAt.comp z ((hB z).hasFDerivAt.sub_const J)).fderiv

theorem frozen_CR_no_gradient_loss {n : ℕ}
    (u : ℕ → ℂ → Phase n) (hu : ∀ j, ContDiff ℝ ∞ (u j))
    (B : ℕ → ℂ → End n) (hB : ∀ j, ContDiff ℝ ∞ (B j))
    (p : Phase n) (J : End n) (hJ : Compatible J)
    {L K : ℝ} (hL : 0 ≤ L) (hK : 0 ≤ K)
    (huD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (u j) z‖ ≤ L)
    (hBD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (B j) z‖ ≤ K)
    (hCR : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      fderiv ℝ (u j) z Complex.I=B j z (fderiv ℝ (u j) z 1))
    (hu0 : TendstoUniformlyOn u (fun _ => p) atTop (Metric.closedBall (0:ℂ) 3))
    (hB0 : TendstoUniformlyOn B (fun _ => J) atTop (Metric.closedBall (0:ℂ) 3)) :
    Tendsto (fun j => ‖fderiv ℝ (u j) 0‖) atTop (𝓝 0) := by
  obtain ⟨S,hS⟩ := compatible_standard_frame hJ
  let U : ℕ → ℂ → Phase n := fun j => centeredFrame S p (u j)
  let A : ℕ → ℂ → End n := fun j => frozenCoefficient S J (B j)
  have hU : ∀ j, ContDiff ℝ ∞ (U j) := fun j => centeredFrame_smooth S p (hu j)
  have hA : ∀ j, ContDiff ℝ ∞ (A j) := fun j => frozenCoefficient_smooth S J (hB j)
  have hUD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      ‖fderiv ℝ (U j) z‖ ≤ ‖S.toContinuousLinearMap‖*L := by
    filter_upwards [huD] with j hj
    intro z hz
    rw [show fderiv ℝ (U j) z=S.toContinuousLinearMap.comp (fderiv ℝ (u j) z) from
      centeredFrame_fderiv S p ((hu j).differentiable (by simp)) z]
    exact (S.toContinuousLinearMap.opNorm_comp_le _).trans
      (mul_le_mul_of_nonneg_left (hj z hz) (norm_nonneg _))
  have hAD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      ‖fderiv ℝ (A j) z‖ ≤ ‖frameConjugation S‖*K := by
    filter_upwards [hBD] with j hj
    intro z hz
    rw [show fderiv ℝ (A j) z=(frameConjugation S).comp (fderiv ℝ (B j) z) from
      frozenCoefficient_fderiv S J ((hB j).differentiable (by simp)) z]
    exact ((frameConjugation S).opNorm_comp_le _).trans
      (mul_le_mul_of_nonneg_left (hj z hz) (norm_nonneg _))
  have hACR : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      fderiv ℝ (U j) z Complex.I-Complex.I • fderiv ℝ (U j) z 1=
        A j z (fderiv ℝ (U j) z 1) := by
    filter_upwards [hCR] with j hj
    intro z hz
    exact frozen_CR_equation S J hS p ((hu j).differentiable (by simp)) (B j) (hj z hz)
  have hU0 : TendstoUniformlyOn U (fun _ => (0:Phase n)) atTop (Metric.closedBall (0:ℂ) 3) := by
    have hc : ContinuousAt (fun x : Phase n => S (x-p)) p :=
      S.continuous.continuousAt.comp (continuousAt_id.sub continuousAt_const)
    convert continuousAt_comp_uniform_constant hc hu0 using 1
    all_goals try simp only [U,sub_self,map_zero]
    all_goals rfl
  have hA0 : TendstoUniformlyOn A (fun _ => (0:End n)) atTop (Metric.closedBall (0:ℂ) 3) := by
    have hc : ContinuousAt (fun x : End n => frameConjugation S (x-J)) J :=
      (frameConjugation S).continuous.continuousAt.comp (continuousAt_id.sub continuousAt_const)
    convert continuousAt_comp_uniform_constant hc hB0 using 1
    all_goals try simp only [A,frameConjugation_apply,sub_self,map_zero]
    all_goals rfl
  have hlim := smallCR_sequence_derivative_zero U hU A hA
    (mul_nonneg (norm_nonneg S.toContinuousLinearMap) hL)
    (mul_nonneg (norm_nonneg (frameConjugation S)) hK) hUD hAD hACR hU0 hA0
  apply squeeze_zero (fun j => norm_nonneg _)
    (fun j => show ‖fderiv ℝ (u j) 0‖ ≤ ‖S.symm.toContinuousLinearMap‖*‖fderiv ℝ (U j) 0‖ from ?_)
    (by simpa using hlim.const_mul ‖S.symm.toContinuousLinearMap‖)
  have he : fderiv ℝ (u j) 0=S.symm.toContinuousLinearMap.comp (fderiv ℝ (U j) 0) := by
    rw [show fderiv ℝ (U j) 0=S.toContinuousLinearMap.comp (fderiv ℝ (u j) 0) from
      centeredFrame_fderiv S p ((hu j).differentiable (by simp)) 0]
    apply ContinuousLinearMap.ext
    intro z
    change (fderiv ℝ (u j) 0) z=S.symm (S ((fderiv ℝ (u j) 0) z))
    simp
  rw [he]
  exact S.symm.toContinuousLinearMap.opNorm_comp_le _

end

 

 

 

open scoped ContDiff Topology
open Set Filter Function
section
open HigherDimensionalBallPacking.Rigidity

theorem lineHomotopy_contDiffAt {n : ℕ} {J : Phase n → End n}
    (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x))
    {y : ℝ × Phase n} (hy : y.1 ∈ Icc (0:ℝ) 1) :
    ContDiffAt ℝ ∞ (fun y : ℝ × Phase n => lineHomotopy J y.1 y.2) y :=
  contDiffAt_interpolateJ (hJs.contDiffAt.comp y contDiffAt_snd)
    contDiffAt_fst (hJ y.2) hy

theorem homotopy_CR_no_gradient_loss {n : ℕ} {J : Phase n → End n}
    (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x))
    (t : ℕ → ℝ) (ht : ∀ j, t j ∈ Icc (0:ℝ) 1) {s : ℝ}
    (hts : Tendsto t atTop (𝓝 s))
    (u : ℕ → ℂ → Phase n) (hu : ∀ j, ContDiff ℝ ∞ (u j)) (p : Phase n)
    {L : ℝ} (hL : 0 ≤ L)
    (huD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (u j) z‖ ≤ L)
    (hCR : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      fderiv ℝ (u j) z Complex.I=lineHomotopy J (t j) (u j z) (fderiv ℝ (u j) z 1))
    (hu0 : TendstoUniformlyOn u (fun _ => p) atTop (Metric.closedBall (0:ℂ) 3)) :
    Tendsto (fun j => ‖fderiv ℝ (u j) 0‖) atTop (𝓝 0) := by
  let H : ℝ × Phase n → End n := fun y => lineHomotopy J y.1 y.2
  let B : ℕ → ℂ → End n := fun j z => H (t j,u j z)
  have hs : s ∈ Icc (0:ℝ) 1 := isClosed_Icc.mem_of_tendsto hts (Eventually.of_forall ht)
  have hH (y : ℝ × Phase n) (hy : y.1 ∈ Icc (0:ℝ) 1) : ContDiffAt ℝ ∞ H y :=
    lineHomotopy_contDiffAt hJs hJ hy
  have hB (j : ℕ) : ContDiff ℝ ∞ (B j) := by
    rw [contDiff_iff_contDiffAt]
    intro z
    exact ContDiffAt.comp (g := H) (f := fun z => (t j,u j z)) z
      (hH (t j,u j z) (ht j)) (contDiffAt_const.prodMk (hu j).contDiffAt)
  have hBounded : Bornology.IsBounded
      ((fderiv ℝ H) '' (Icc (0:ℝ) 1 ×ˢ Metric.closedBall p 1)) :=
    ((isCompact_Icc.prod (isCompact_closedBall p 1)).image_of_continuousOn
      (fun y hy => ((hH y hy.1).continuousAt_fderiv (by simp)).continuousWithinAt)).isBounded
  obtain ⟨K,hK,hKb⟩ := hBounded.exists_pos_norm_le
  have hB0 : TendstoUniformlyOn B (fun _ => H (s,p)) atTop (Metric.closedBall (0:ℂ) 3) := by
    convert continuousAt_comp_uniform_constant (hH (s,p) hs).continuousAt
      (uniform_constant_prod hts hu0) using 1
  have hBD : ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall (0:ℂ) 3,
      ‖fderiv ℝ (B j) z‖ ≤ K*L := by
    filter_upwards [huD,Metric.tendstoUniformlyOn_iff.mp hu0 1 (by norm_num)] with j hj hju
    intro z hz
    have hmem : (t j,u j z) ∈ Icc (0:ℝ) 1 ×ˢ Metric.closedBall p 1 :=
      ⟨ht j,by simpa [Metric.mem_closedBall,dist_comm] using (hju z hz).le⟩
    have hd : HasFDerivAt (fun z => (t j,u j z))
        ((0 : ℂ →L[ℝ] ℝ).prod (fderiv ℝ (u j) z)) z :=
      (hasFDerivAt_const (t j) z).prodMk ((hu j).differentiable (by simp) z).hasFDerivAt
    have he : fderiv ℝ (B j) z=(fderiv ℝ H (t j,u j z)).comp
        ((0 : ℂ →L[ℝ] ℝ).prod (fderiv ℝ (u j) z)) :=
      (HasFDerivAt.comp (g := H) (f := fun z => (t j,u j z)) z
        ((hH (t j,u j z) (ht j)).differentiableAt (by simp)).hasFDerivAt hd).fderiv
    rw [he]
    apply ((fderiv ℝ H (t j,u j z)).opNorm_comp_le _).trans
    have hnorm : ‖(0 : ℂ →L[ℝ] ℝ).prod (fderiv ℝ (u j) z)‖=‖fderiv ℝ (u j) z‖ := by
      rw [ContinuousLinearMap.opNorm_prod,Prod.norm_def,norm_zero,max_eq_right (norm_nonneg _)]
    rw [hnorm]
    exact mul_le_mul (hKb _ ⟨(t j,u j z),hmem,rfl⟩) (hj z hz) (norm_nonneg _) hK.le
  exact frozen_CR_no_gradient_loss u hu B hB p (H (s,p))
    (lineHomotopy_compatible hJ hs p) hL (mul_nonneg hK.le hL) huD hBD hCR hu0 hB0

end

 

 

 

open scoped ContDiff Topology
open Set Filter Function
section
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]

def rescaleMap (u : ℂ → F) (x : ℂ) (r : ℝ) : ℂ → F := fun z => u (x+r • z)

theorem rescaleMap_smooth {u : ℂ → F} (hu : ContDiff ℝ ∞ u) (x : ℂ) (r : ℝ) :
    ContDiff ℝ ∞ (rescaleMap u x r) := by
  exact ContDiff.comp (g := u) (f := fun z : ℂ => x+r • z) hu
    (contDiff_const.add (contDiff_id.const_smul r))

theorem rescaleMap_fderiv {u : ℂ → F} (hu : Differentiable ℝ u) (x : ℂ) (r : ℝ) (z : ℂ) :
    fderiv ℝ (rescaleMap u x r) z=r • fderiv ℝ u (x+r • z) := by
  have hd : HasFDerivAt (fun z : ℂ => x+r • z) (r • ContinuousLinearMap.id ℝ ℂ) z :=
    by
      have hh := (hasFDerivAt_const (𝕜 := ℝ) x z).add ((hasFDerivAt_id (𝕜 := ℝ) z).const_smul r)
      simp only [zero_add] at hh
      convert hh using 1
      rfl
  have he := (HasFDerivAt.comp (g := u) (f := fun z : ℂ => x+r • z) z
    (hu (x+r • z)).hasFDerivAt hd).fderiv
  simp only [Function.comp_def,ContinuousLinearMap.comp_smul,
    ContinuousLinearMap.comp_id] at he
  convert he using 1
  rfl

theorem rescaleMap_norm_fderiv {u : ℂ → F} (hu : Differentiable ℝ u)
    (x : ℂ) (r : ℝ) (z : ℂ) :
    ‖fderiv ℝ (rescaleMap u x r) z‖=|r| * ‖fderiv ℝ u (x+r • z)‖ := by
  rw [rescaleMap_fderiv hu,norm_smul,Real.norm_eq_abs]

theorem weighted_rescale_bounds {u : ℂ → F} (hu : Differentiable ℝ u)
    {x c : ℂ} {R : ℝ} (hg : 0 < ‖fderiv ℝ u x‖)
    (hm : 6 ≤ (R-dist x c)*‖fderiv ℝ u x‖)
    (hb : ∀ y ∈ Metric.closedBall x ((R-dist x c)/2),
      ‖fderiv ℝ u y‖ ≤ 2*‖fderiv ℝ u x‖) :
    ‖fderiv ℝ (rescaleMap u x ‖fderiv ℝ u x‖⁻¹) 0‖=1 ∧
      ∀ z ∈ Metric.closedBall (0:ℂ) 3,
        ‖fderiv ℝ (rescaleMap u x ‖fderiv ℝ u x‖⁻¹) z‖ ≤ 2 := by
  have hr : 0 ≤ ‖fderiv ℝ u x‖⁻¹ := inv_nonneg.mpr hg.le
  constructor
  · rw [rescaleMap_norm_fderiv hu,abs_of_nonneg hr,smul_zero,add_zero,inv_mul_cancel₀ hg.ne']
  · intro z hz
    have hhalf : ‖fderiv ℝ u x‖⁻¹*3 ≤ (R-dist x c)/2 := by
      have hh := mul_le_mul_of_nonneg_right hm hr
      rw [mul_assoc,mul_inv_cancel₀ hg.ne',mul_one] at hh
      linarith
    have hmem : x+‖fderiv ℝ u x‖⁻¹ • z ∈ Metric.closedBall x ((R-dist x c)/2) := by
      rw [Metric.mem_closedBall,dist_eq_norm,add_sub_cancel_left,norm_smul,Real.norm_eq_abs,
        abs_of_nonneg hr]
      exact (mul_le_mul_of_nonneg_left (by simpa using hz : ‖z‖ ≤ 3) hr).trans hhalf
    rw [rescaleMap_norm_fderiv hu,abs_of_nonneg hr]
    calc
      _ ≤ ‖fderiv ℝ u x‖⁻¹*(2*‖fderiv ℝ u x‖) := mul_le_mul_of_nonneg_left (hb _ hmem) hr
      _ = 2 := by rw [mul_left_comm,inv_mul_cancel₀ hg.ne',mul_one]

theorem rescaleMap_CR {n : ℕ} {J : Phase n → End n} {u : ℂ → Phase n}
    (hu : Differentiable ℝ u) (hCR : ∀ z, PseudoHolomorphicAt J u z)
    (x : ℂ) (r : ℝ) (z : ℂ) :
    fderiv ℝ (rescaleMap u x r) z Complex.I=
      J (rescaleMap u x r z) (fderiv ℝ (rescaleMap u x r) z 1) := by
  rw [rescaleMap_fderiv hu]
  simpa only [smul_apply,map_smul,mul_one,rescaleMap] using
    congrArg (fun v : Phase n => r • v) ((hCR (x+r • z)).2 1)

end

 

 

 

open scoped ContDiff Topology
open Set Filter Function
section
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]

theorem weighted_gradient_maximum (f : ℂ → F) (hf : ContDiff ℝ ∞ f)
    (c : ℂ) {R : ℝ} (hR : 0 < R) (hgrad : 0 < ‖fderiv ℝ f c‖) :
    ∃ x ∈ Metric.ball c R,
      R*‖fderiv ℝ f c‖ ≤ (R-dist x c)*‖fderiv ℝ f x‖ ∧
      ‖fderiv ℝ f c‖ ≤ ‖fderiv ℝ f x‖ ∧
      ∀ y ∈ Metric.closedBall x ((R-dist x c)/2),
        ‖fderiv ℝ f y‖ ≤ 2*‖fderiv ℝ f x‖ := by
  let g : ℂ → ℝ := fun z => (R-dist z c)*‖fderiv ℝ f z‖
  have hg : Continuous g :=
    (continuous_const.sub (continuous_id.dist continuous_const)).mul
      ((hf.continuous_fderiv (by simp)).norm)
  obtain ⟨x,hx,hxm⟩ := (isCompact_closedBall c R).exists_isMaxOn
    (Metric.nonempty_closedBall.mpr hR.le) hg.continuousOn
  have hcm : c ∈ Metric.closedBall c R := Metric.mem_closedBall_self hR.le
  have hcx : R*‖fderiv ℝ f c‖ ≤ (R-dist x c)*‖fderiv ℝ f x‖ := by
    simpa only [Set.mem_ofPred_eq,g,dist_self,sub_zero] using hxm hcm
  have hxp : 0 < R-dist x c := by
    have hm : 0 < (R-dist x c)*‖fderiv ℝ f x‖ := (mul_pos hR hgrad).trans_le hcx
    exact pos_of_mul_pos_left hm (norm_nonneg _)
  have hxmem : x ∈ Metric.ball c R := by
    rw [Metric.mem_ball]
    linarith
  have hgx : ‖fderiv ℝ f c‖ ≤ ‖fderiv ℝ f x‖ := by
    apply le_of_mul_le_mul_left (a := R)
    · calc
        R*‖fderiv ℝ f c‖ ≤ (R-dist x c)*‖fderiv ℝ f x‖ := hcx
        _ ≤ R*‖fderiv ℝ f x‖ := mul_le_mul_of_nonneg_right (by linarith [dist_nonneg (x := x) (y := c)]) (norm_nonneg _)
    · exact hR
  refine ⟨x,hxmem,hcx,hgx,?_⟩
  intro y hy
  have hyx : dist y x ≤ (R-dist x c)/2 := Metric.mem_closedBall.mp hy
  have hyc : dist y c ≤ (R+dist x c)/2 := by
    have hh := dist_triangle y x c
    linarith
  have hymem : y ∈ Metric.closedBall c R := by
    rw [Metric.mem_closedBall]
    linarith
  have hxy := hxm hymem
  change (R-dist y c)*‖fderiv ℝ f y‖ ≤ (R-dist x c)*‖fderiv ℝ f x‖ at hxy
  have hb : ((R-dist x c)/2)*‖fderiv ℝ f y‖ ≤
      (R-dist y c)*‖fderiv ℝ f y‖ :=
    mul_le_mul_of_nonneg_right (by linarith) (norm_nonneg _)
  have hh := hb.trans hxy
  nlinarith

end

 

 

 

open scoped ContDiff Topology
open Set Filter Function
open HigherDimensionalBallPacking.Rigidity

theorem locally_uniform_reindex {E F : Type*} [TopologicalSpace E] [UniformSpace F]
    {u : ℕ → E → F} {v : E → F} (hv : TendstoLocallyUniformly u v atTop)
    {a : ℕ → ℕ} (ha : Tendsto a atTop atTop) :
    TendstoLocallyUniformly (fun j => u (a j)) v atTop := by
  intro V hV x
  obtain ⟨U,hU,hUV⟩ := hv V hV x
  exact ⟨U,hU,ha.eventually hUV⟩

theorem homotopy_C0_gradient_bound {n : ℕ} {J : Phase n → End n}
    (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x))
    (t : ℕ → ℝ) (ht : ∀ j, t j ∈ Icc (0:ℝ) 1) {s : ℝ}
    (hts : Tendsto t atTop (𝓝 s))
    (u : ℕ → ℂ → Phase n) (hu : ∀ j, ContDiff ℝ ∞ (u j))
    (hCR : ∀ j z, PseudoHolomorphicAt (lineHomotopy J (t j)) (u j) z)
    (v : ℂ → Phase n) (hv : TendstoLocallyUniformly u v atTop)
    (c : ℂ) {R : ℝ} (_hR : 0 ≤ R) :
    ∃ L ≥ 0, ∀ᶠ j in atTop, ∀ z ∈ Metric.closedBall c R, ‖fderiv ℝ (u j) z‖ ≤ L := by
  by_contra hn
  have hbad (j : ℕ) : ∃ i ≥ j, ∃ z ∈ Metric.closedBall c R,
      (j:ℝ)+1 < ‖fderiv ℝ (u i) z‖ := by
    have hnot : ¬ ∀ᶠ i in atTop, ∀ z ∈ Metric.closedBall c R,
        ‖fderiv ℝ (u i) z‖ ≤ (j:ℝ)+1 := by
      intro hh
      exact hn ⟨(j:ℝ)+1,by positivity,hh⟩
    rw [Filter.eventually_atTop] at hnot
    push Not at hnot
    obtain ⟨i,hi,z,hz,hbig⟩ := hnot j
    exact ⟨i,hi,z,hz,hbig⟩
  choose a ha z hz hbig using hbad
  have hat : Tendsto a atTop atTop := tendsto_atTop_mono ha tendsto_id
  have hpos (j : ℕ) : 0 < ‖fderiv ℝ (u (a j)) (z j)‖ := lt_trans (by positivity) (hbig j)
  choose x hx hweight hlarger hlocal using
    (fun j => weighted_gradient_maximum (u (a j)) (hu (a j)) (z j) (by norm_num : (0:ℝ)<1) (hpos j))
  have hxmem (j : ℕ) : x j ∈ Metric.closedBall c (R+1) := by
    have h1 : dist (x j) (z j) < 1 := hx j
    have h2 : dist (z j) c ≤ R := hz j
    rw [Metric.mem_closedBall]
    linarith [dist_triangle (x j) (z j) c]
  obtain ⟨d,hd,φ,hφ,hφx⟩ := (isCompact_closedBall c (R+1)).tendsto_subseq hxmem
  let b : ℕ → ℕ := fun j => a (φ j)
  have hbt : Tendsto b atTop atTop := hat.comp hφ.tendsto_atTop
  let g : ℕ → ℝ := fun j => ‖fderiv ℝ (u (b j)) (x (φ j))‖
  have hgp (j : ℕ) : 0 < g j := (hpos (φ j)).trans_le (hlarger (φ j))
  have hgb (j : ℕ) : (φ j:ℝ)+1 < g j := (hbig (φ j)).trans_le (hlarger (φ j))
  have hgt : Tendsto g atTop atTop := by
    apply tendsto_atTop_mono (fun j => (le_add_of_nonneg_right (by norm_num : (0:ℝ) ≤ 1)).trans (hgb j).le)
    exact tendsto_natCast_atTop_atTop.comp hφ.tendsto_atTop
  let r : ℕ → ℝ := fun j => (g j)⁻¹
  have hrt : Tendsto r atTop (𝓝 0) := tendsto_inv_atTop_zero.comp hgt
  let U : ℕ → ℂ → Phase n := fun j => rescaleMap (u (b j)) (x (φ j)) (r j)
  have hUs (j : ℕ) : ContDiff ℝ ∞ (U j) := rescaleMap_smooth (hu (b j)) _ _
  have hlim : TendstoUniformlyOn U (fun _ => v d) atTop (Metric.closedBall (0:ℂ) 3) := by
    have hv' := locally_uniform_reindex hv hbt
    have hvc : Continuous v := hv.continuous (Eventually.of_forall (fun j => (hu j).continuous)).frequently
    convert rescaled_maps_uniform_constant hv' hvc.continuousAt hφx hrt
      (Metric.isBounded_closedBall (x := (0:ℂ)) (r := 3)) using 1
    rfl
  have hUb : ∀ᶠ j in atTop, ‖fderiv ℝ (U j) 0‖=1 ∧
      ∀ z ∈ Metric.closedBall (0:ℂ) 3, ‖fderiv ℝ (U j) z‖ ≤ 2 := by
    filter_upwards [eventually_ge_atTop (6:ℕ)] with j hj
    apply weighted_rescale_bounds ((hu (b j)).differentiable (by simp)) (hgp j)
    · have hφj : j ≤ φ j := hφ.id_le j
      have h6 : (6:ℝ) ≤ φ j := by exact_mod_cast le_trans hj hφj
      have hw := hweight (φ j)
      dsimp [g,b] at hgb
      nlinarith [hbig (φ j)]
    · exact hlocal (φ j)
  have hUCR : ∀ j z, fderiv ℝ (U j) z Complex.I=
      lineHomotopy J (t (b j)) (U j z) (fderiv ℝ (U j) z 1) := by
    intro j z
    exact rescaleMap_CR ((hu (b j)).differentiable (by simp)) (hCR (b j)) _ _ _
  have hzero := homotopy_CR_no_gradient_loss hJs hJ (fun j => t (b j))
    (fun j => ht (b j)) (hts.comp hbt) U hUs (v d) (by norm_num : (0:ℝ) ≤ 2)
    (hUb.mono (fun j hj => hj.2)) (Eventually.of_forall (fun j z _ => hUCR j z)) hlim
  have hone : Tendsto (fun j => ‖fderiv ℝ (U j) 0‖) atTop (𝓝 1) :=
    tendsto_const_nhds.congr' (hUb.mono (fun j hj => hj.1.symm))
  have he : (0:ℝ)=1 := tendsto_nhds_unique hzero hone
  norm_num at he

end HigherDimensionalBallPacking.Rigidity

end

end OAI