lean/OAI/Geometry/BallPacking/DiskMaps/SmoothConvexSelection.lean

import Mathlib
import OAI.Geometry.BallPacking.DiskMaps.CubicAreaExhaustion

namespace OAI

noncomputable section
namespace PackingSufficiencySupport.Hamiltonian

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

theorem exists_smooth_convex_selection {Y : Set P} (hY : IsClosed Y)
    (S : P → Set F) (hopen : ∀ v, IsOpen {y | v ∈ S y})
    (hconv : ∀ y ∈ Y, Convex ℝ (S y)) (hne : ∀ y ∈ Y, (S y).Nonempty) :
    ∃ c : P → F, ContDiff ℝ ∞ c ∧ ∀ y ∈ Y, c y ∈ S y := by
  classical
  choose v hv using fun y : Y => hne y y.property
  let U : Y → Set P := fun y => {x | v y ∈ S x}
  obtain ⟨ρ,hρ⟩ := SmoothPartitionOfUnity.exists_isSubordinate 𝓘(ℝ,P) hY U
    (fun y => hopen (v y)) (by
      intro y hy
      exact mem_iUnion_of_mem ⟨y,hy⟩ (hv ⟨y,hy⟩))
  refine ⟨fun y => ∑ᶠ i, ρ i y • v i,?_,?_⟩
  · apply contDiff_iff_contDiffAt.mpr
    intro y
    exact ρ.contDiffAt_finsum (fun _ _ => contDiffAt_const)
  · intro y hy
    apply ρ.finsum_smul_mem_convex hy _ (hconv y hy)
    intro i hi
    exact hρ i (subset_tsupport (ρ i) hi)


end

section
open Set Function

theorem exists_strict_interval_extension {a b l u L : ℝ}
    (hal : a < l) (hub : u < b) (hLu : u-l < L) (hLb : L < b-a) :
    ∃ c, a < c ∧ c+L < b ∧ c < l ∧ u < c+L := by
  have hh : max a (u-L) < min l (b-L) := by
    rw [max_lt_iff,lt_min_iff,lt_min_iff]
    constructor <;> constructor <;> linarith
  obtain ⟨c,hlo,hhi⟩ := exists_between hh
  exact ⟨c,(le_max_left _ _).trans_lt hlo,
    by linarith [(lt_of_lt_of_le hhi (min_le_right _ _))],
    hhi.trans_le (min_le_left _ _),
    by linarith [(lt_of_le_of_lt (le_max_right _ _) hlo)]⟩

theorem exists_strict_nested_intervals {n : ℕ} (a b L : Fin n → ℝ)
    (ha : Antitone a) (hb : Monotone b) (hL : StrictMono L)
    (hfit : ∀ i, L i < b i-a i) :
    ∃ c : Fin n → ℝ, (∀ i, a i < c i ∧ c i+L i < b i) ∧
      ∀ ⦃i j⦄, i < j → c j < c i ∧ c i+L i < c j+L j := by
  induction n with
  | zero => exact ⟨fun i => i.elim0,by simp,by simp⟩
  | succ n ih =>
    cases n with
    | zero =>
      refine ⟨fun i => (a i+b i-L i)/2,?_,?_⟩
      · intro i; have := hfit i; constructor <;> linarith
      · intro i j hij
        have : i = j := by omega
        exact (lt_irrefl _ (this ▸ hij)).elim
    | succ m =>
      obtain ⟨c,hc,hnest⟩ := ih (a ∘ Fin.castSucc) (b ∘ Fin.castSucc)
        (L ∘ Fin.castSucc) (ha.comp_monotone Fin.strictMono_castSucc.monotone)
        (hb.comp Fin.strictMono_castSucc.monotone) (hL.comp Fin.strictMono_castSucc)
        (fun i => hfit i.castSucc)
      let i₀ : Fin (m+1) := Fin.last m
      let j₀ : Fin (m+2) := Fin.last (m+1)
      have hij : i₀.castSucc < j₀ := Fin.castSucc_lt_last _
      obtain ⟨d,hd⟩ := exists_strict_interval_extension
        ((ha hij.le).trans_lt (hc i₀).1)
        ((hc i₀).2.trans_le (hb hij.le))
        (by simpa only [Function.comp_apply,add_sub_cancel_left] using hL hij)
        (hfit j₀)
      refine ⟨Fin.snoc c d,?_,?_⟩
      · intro i
        refine Fin.lastCases ?_ (fun j => ?_) i
        · simpa only [Fin.snoc_last] using And.intro hd.1 hd.2.1
        · simpa only [Fin.snoc_castSucc,Function.comp_apply] using hc j
      · intro i j hij'
        have hi : i ≠ Fin.last (m+1) := by
          intro hh
          subst i
          exact not_lt_of_ge (Fin.le_last _) hij'
        obtain ⟨i,rfl⟩ := Fin.eq_castSucc_of_ne_last hi
        revert hij'
        refine Fin.lastCases ?_ (fun j hj => ?_) j
        · intro _
          simp only [Fin.snoc_castSucc,Fin.snoc_last]
          rcases lt_or_eq_of_le (Fin.le_last i) with hi | hi
          · have hh := hnest hi
            exact ⟨hd.2.2.1.trans hh.1,hh.2.trans hd.2.2.2⟩
          · subst i
            exact hd.2.2
        · simpa only [Fin.snoc_castSucc,Function.comp_apply] using
            hnest (show i < j from hj)


end

section
open scoped ContDiff Topology
open Set Function

variable {n : ℕ}

def StrictNestedStarts (L c : Fin n → ℝ) : Prop :=
  ∀ ⦃i j : Fin n⦄, i < j → c j < c i ∧ c i+L i < c j+L j

def IntervalPlacements (L : Fin n → ℝ) (V : Fin n → Set ℝ) : Set (Fin n → ℝ) :=
  {c | (∀ i, c i ∈ V i ∧ c i+L i ∈ V i) ∧ StrictNestedStarts L c}

theorem intervalPlacements_convex (L : Fin n → ℝ) (V : Fin n → Set ℝ)
    (hV : ∀ i, Convex ℝ (V i)) : Convex ℝ (IntervalPlacements L V) := by
  intro c hc d hd α β hα hβ hab
  refine ⟨?_,?_⟩
  · intro i
    have he : (α • c+β • d) i+L i = α*(c i+L i)+β*(d i+L i) := by
      simp only [Pi.add_apply,Pi.smul_apply,smul_eq_mul]
      have he := congrArg (fun t : ℝ => t*L i) hab
      nlinarith only [he]
    constructor
    · exact hV i (hc.1 i).1 (hd.1 i).1 hα hβ hab
    · rw [he]
      exact hV i (hc.1 i).2 (hd.1 i).2 hα hβ hab
  · intro i j hij
    let A : (Fin n → ℝ) →ₗ[ℝ] ℝ := (LinearMap.proj j : (Fin n → ℝ) →ₗ[ℝ] ℝ) - LinearMap.proj i
    let B : (Fin n → ℝ) →ₗ[ℝ] ℝ := (LinearMap.proj i : (Fin n → ℝ) →ₗ[ℝ] ℝ) - LinearMap.proj j
    have ha : A c < 0 := sub_neg.mpr (hc.2 hij).1
    have hb : A d < 0 := sub_neg.mpr (hd.2 hij).1
    have ha' : B c < L j-L i := by change c i-c j < _; linarith [(hc.2 hij).2]
    have hb' : B d < L j-L i := by change d i-d j < _; linarith [(hd.2 hij).2]
    have hh := (convex_halfSpace_lt A.isLinear 0) ha hb hα hβ hab
    have hh' := (convex_halfSpace_lt B.isLinear (L j-L i)) ha' hb' hα hβ hab
    change (α • c+β • d) j-(α • c+β • d) i < 0 at hh
    change (α • c+β • d) i-(α • c+β • d) j < L j-L i at hh'
    exact ⟨sub_neg.mp hh,by linarith⟩

variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P] [FiniteDimensional ℝ P]

theorem exists_smooth_nested_intervals {Y : Set P} (hY : IsClosed Y)
    (L : Fin n → ℝ) (hL : StrictMono L) (V : P → Fin n → Set ℝ)
    (hopen : ∀ i t, IsOpen {y | t ∈ V y i})
    (hconv : ∀ y ∈ Y, ∀ i, Convex ℝ (V y i))
    (hroom : ∀ y ∈ Y, ∃ a b : Fin n → ℝ, Antitone a ∧ Monotone b ∧
      (∀ i, L i < b i-a i) ∧ ∀ i, Ioo (a i) (b i) ⊆ V y i)
    (hpos : ∀ i, 0 < L i) :
    ∃ c : P → (Fin n → ℝ), ContDiff ℝ ∞ c ∧
      ∀ y ∈ Y, (∀ i, Icc (c y i) (c y i+L i) ⊆ V y i) ∧
        StrictNestedStarts L (c y) := by
  have hsopen (c : Fin n → ℝ) : IsOpen {y | c ∈ IntervalPlacements L (V y)} := by
    change IsOpen {y | (∀ i, c i ∈ V y i ∧ c i+L i ∈ V y i) ∧ StrictNestedStarts L c}
    by_cases hn : StrictNestedStarts L c
    · simp only [hn,and_true,ofPred_forall,ofPred_and]
      exact isOpen_iInter_of_finite (fun i => (hopen i (c i)).inter (hopen i (c i+L i)))
    · simp only [hn,and_false,ofPred_false,isOpen_empty]
  have hsne (y : P) (hy : y ∈ Y) : (IntervalPlacements L (V y)).Nonempty := by
    obtain ⟨a,b,ha,hb,hfit,hsub⟩ := hroom y hy
    obtain ⟨c,hc,hn⟩ := exists_strict_nested_intervals a b L ha hb hL hfit
    refine ⟨c,?_,hn⟩
    intro i
    have hLi := hpos i
    exact ⟨hsub i ⟨(hc i).1,by linarith [(hc i).2]⟩,
      hsub i ⟨by linarith [(hc i).1],(hc i).2⟩⟩
  obtain ⟨c,hc,hmem⟩ := exists_smooth_convex_selection hY
    (fun y => IntervalPlacements L (V y)) hsopen
    (fun y hy => intervalPlacements_convex L (V y) (hconv y hy)) hsne
  refine ⟨c,hc,?_⟩
  intro y hy
  refine ⟨?_,(hmem y hy).2⟩
  intro i
  exact (hconv y hy i).ordConnected.out ((hmem y hy).1 i).1 ((hmem y hy).1 i).2


end

section
open scoped ContDiff Topology
open Set Function
variable {P : Type*} [TopologicalSpace P]

def RoundedMargins {n : ℕ} (C : P → Fin n → ℝ) (L w : Fin n → ℝ)
    (V : P → Fin n → Set ℝ) (q s : ℝ) (y : P) : Prop :=
  0 < s ∧
  (∀ i, C y i-s*L i/2 ∈ V y i ∧ C y i+s*L i/2 ∈ V y i) ∧
  ∀ ⦃i j⦄, i < j →
    C y j-q*s*L j/2 < C y i-s*L i/2 ∧
    C y i+s*L i/2 < C y j+q*s*L j/2 ∧ w i < q*w j

theorem roundedMargins_open {n : ℕ} (C : P → Fin n → ℝ) (hC : Continuous C)
    (L w : Fin n → ℝ) (V : P → Fin n → Set ℝ)
    (hV : ∀ i, IsOpen {p : P × ℝ | p.2 ∈ V p.1 i}) :
    IsOpen {p : Plane × P | RoundedMargins C L w V p.1.1 p.1.2 p.2} := by
  have hlo (i : Fin n) : IsOpen {p : Plane × P | C p.2 i-p.1.2*L i/2 ∈ V p.2 i} :=
    (hV i).preimage (continuous_snd.prodMk
      (((continuous_apply i).comp (hC.comp continuous_snd)).sub
        ((continuous_fst.snd.mul continuous_const).div_const 2)))
  have hhi (i : Fin n) : IsOpen {p : Plane × P | C p.2 i+p.1.2*L i/2 ∈ V p.2 i} :=
    (hV i).preimage (continuous_snd.prodMk
      (((continuous_apply i).comp (hC.comp continuous_snd)).add
        ((continuous_fst.snd.mul continuous_const).div_const 2)))
  have hpair (i j : Fin n) : IsOpen {p : Plane × P | i < j →
      C p.2 j-p.1.1*p.1.2*L j/2 < C p.2 i-p.1.2*L i/2 ∧
      C p.2 i+p.1.2*L i/2 < C p.2 j+p.1.1*p.1.2*L j/2 ∧ w i < p.1.1*w j} := by
    by_cases hij : i < j
    · simp only [hij,true_implies,ofPred_and]
      exact (isOpen_lt (by fun_prop) (by fun_prop)).inter
        ((isOpen_lt (by fun_prop) (by fun_prop)).inter (isOpen_lt (by fun_prop) (by fun_prop)))
    · simp only [hij,false_implies,ofPred_true,isOpen_univ]
  change IsOpen {p : Plane × P | 0 < p.1.2 ∧
    (∀ i, C p.2 i-p.1.2*L i/2 ∈ V p.2 i ∧ C p.2 i+p.1.2*L i/2 ∈ V p.2 i) ∧
    ∀ i j, i < j → _}
  simp only [ofPred_and,ofPred_forall]
  exact (isOpen_lt continuous_const continuous_fst.snd).inter
    ((isOpen_iInter_of_finite (fun i => (hlo i).inter (hhi i))).inter
      (isOpen_iInter_of_finite (fun i => isOpen_iInter_of_finite (fun j => by
        simpa only [ofPred_forall,ofPred_and] using hpair i j))))

theorem exists_exact_area_rounded_margins {n : ℕ} {Y : Set P} (hY : IsCompact Y)
    (c : P → Fin n → ℝ) (hc : Continuous c) (L w : Fin n → ℝ)
    (hw : StrictMono w) (V : P → Fin n → Set ℝ)
    (hV : ∀ i, IsOpen {p : P × ℝ | p.2 ∈ V p.1 i})
    (hplace : ∀ y ∈ Y, (∀ i, c y i ∈ V y i ∧ c y i+L i ∈ V y i) ∧
      StrictNestedStarts L (c y)) :
    ∃ q k : ℝ, 0 < q ∧ q < 1 ∧ 0 < k ∧
      Icc (-q) q ×ˢ Icc (-q) q ⊆ squeezedDisk k ∧ 0 < squeezedArea k ∧
      ∀ y ∈ Y, RoundedMargins (fun y i => c y i+L i/2) L w V q (4/squeezedArea k) y := by
  let C : P → Fin n → ℝ := fun y i => c y i+L i/2
  have hC : Continuous C := by
    apply continuous_pi
    intro i
    exact ((continuous_apply i).comp hc).add continuous_const
  apply exists_rounded_square_with_control hY continuous_id
    (roundedMargins_open C hC L w V hV)
  intro y hy
  change RoundedMargins C L w V 1 1 y
  refine ⟨by norm_num,?_,?_⟩
  · intro i
    simpa only [C,one_mul,add_sub_cancel_right,add_assoc,add_halves] using (hplace y hy).1 i
  · intro i j hij
    dsimp [C]
    simp only [one_mul,add_sub_cancel_right,add_assoc,add_halves]
    exact ⟨((hplace y hy).2 hij).1,((hplace y hy).2 hij).2,hw hij⟩


end

section
open scoped ContDiff Topology BigOperators
open Set Function

theorem exists_thin_rectangle_placement {m : ℕ} (h : Fin m → ℝ)
    (hh : ∀ i, 0 < h i) (hmono : StrictMono h) {δ : ℝ} (hδ : 0 < δ) :
    ∃ (L w c : Fin m → ℝ), (∀ i, 0 < L i) ∧ (∀ i, 0 < w i ∧ w i < 1) ∧
      StrictMono w ∧ (∀ i, L i*w i = h i) ∧ StrictNestedStarts L c ∧
      ∀ i, c i ∈ Ioo 0 (h i+δ/2) ∧ c i+L i ∈ Ioo 0 (h i+δ/2) := by
  let B : ℝ := 1+∑ i, h i
  have hB : 1 ≤ B := by
    have hs : 0 ≤ ∑ i, h i := Finset.sum_nonneg (fun i _ => (hh i).le)
    dsimp [B]; linarith
  have hiB (i : Fin m) : h i < B := by
    have hi := Finset.single_le_sum (s := Finset.univ) (fun j _ => (hh j).le) (Finset.mem_univ i)
    dsimp [B]; linarith
  let ε := min (δ/8) (1/4)
  have hε : 0 < ε := lt_min (by positivity) (by norm_num)
  have hεδ : ε ≤ δ/8 := min_le_left _ _
  have hε1 : ε ≤ 1/4 := min_le_right _ _
  let β := ε/(2*B)
  have hd : 0 < 2*B := by linarith
  have hβ : 0 < β := div_pos hε hd
  have hβ1 : β < 1 := by apply (div_lt_one hd).mpr; linarith
  have hB0 : B ≠ 0 := ne_of_gt (by linarith)
  have hβB : β*B = ε/2 := by dsimp [β]; field_simp [hB0]
  have hsmall (i : Fin m) : β*h i < ε := by
    have he := mul_lt_mul_of_pos_left (hiB i) hβ
    rw [hβB] at he
    linarith
  let L i := h i+ε
  let w i := h i/(h i+ε)
  let c i := ε-β*h i
  have hL i : 0 < L i := add_pos (hh i) hε
  have hw i : 0 < w i ∧ w i < 1 :=
    ⟨div_pos (hh i) (hL i),(div_lt_one (hL i)).mpr (by dsimp [L]; linarith)⟩
  refine ⟨L,w,c,hL,hw,?_,?_,?_,?_⟩
  · intro i j hij
    apply (div_lt_div_iff₀ (hL i) (hL j)).mpr
    dsimp [L]
    have he := mul_lt_mul_of_pos_right (hmono hij) hε
    nlinarith
  · intro i
    dsimp [L,w]
    field_simp [show h i+ε ≠ 0 from (hL i).ne']
  · intro i j hij
    dsimp [c,L]
    have he := hmono hij
    have he1 := mul_lt_mul_of_pos_left he hβ
    have he2 := mul_lt_mul_of_pos_left he (sub_pos.mpr hβ1)
    constructor <;> nlinarith
  · intro i
    have hc : 0 < c i := sub_pos.mpr (hsmall i)
    have hcε : c i < ε := by dsimp [c]; nlinarith [mul_pos hβ (hh i)]
    have hlower : 0 < c i+L i := add_pos hc (hL i)
    have hupper : c i+L i < h i+δ/2 := by dsimp [L]; linarith
    exact ⟨⟨hc,(lt_add_of_pos_right (c i) (hL i)).trans hupper⟩,hlower,hupper⟩


end

section
open scoped ContDiff Topology
open Set Function MeasureTheory

def box (c : Plane) (a b : ℝ) : Set Plane :=
  Icc (c.1-a) (c.1+a) ×ˢ Icc (c.2-b) (c.2+b)

def openBox (c : Plane) (a b : ℝ) : Set Plane :=
  Ioo (c.1-a) (c.1+a) ×ˢ Ioo (c.2-b) (c.2+b)

def roundedMap (k : ℝ) (c : Plane) (a b : ℝ) (x : Plane) : Plane :=
  affineRectangle c a b (squareSqueeze k x)

def roundedBox (k : ℝ) (c : Plane) (a b : ℝ) : Set Plane :=
  roundedMap k c a b '' closedRoundDisk 1

theorem affineRectangle_injective {a b : ℝ} (ha : a ≠ 0) (hb : b ≠ 0) (c : Plane) :
    Injective (affineRectangle c a b) := by
  intro x y he
  have h1 := congrArg Prod.fst he
  have h2 := congrArg Prod.snd he
  exact Prod.ext (mul_left_cancel₀ ha (add_left_cancel h1))
    (mul_left_cancel₀ hb (add_left_cancel h2))

theorem affineRectangle_smooth (c : Plane) (a b : ℝ) :
    ContDiff ℝ ∞ (affineRectangle c a b) :=
  contDiff_const.add (diagonalScale a b).contDiff

theorem roundedMap_smooth (k : ℝ) (c : Plane) (a b : ℝ) :
    ContDiff ℝ ∞ (roundedMap k c a b) :=
  (affineRectangle_smooth c a b).comp (squareSqueeze_smooth k)

theorem roundedMap_injective {k a b : ℝ} (hk : k ≠ 0) (ha : a ≠ 0) (hb : b ≠ 0)
    (c : Plane) : Injective (roundedMap k c a b) :=
  (affineRectangle_injective ha hb c).comp (squareSqueeze_injective hk)

theorem affineRectangle_fderiv (c : Plane) (a b : ℝ) (x : Plane) :
    fderiv ℝ (affineRectangle c a b) x = diagonalScale a b := by
  exact ((diagonalScale a b).hasFDerivAt.const_add c).fderiv

theorem roundedMap_det {k a b : ℝ} (c : Plane) (x : Plane) :
    (fderiv ℝ (roundedMap k c a b) x).det = a*b*(fderiv ℝ (squareSqueeze k) x).det := by
  change (fderiv ℝ (affineRectangle c a b ∘ squareSqueeze k) x).det = _
  rw [fderiv_comp x ((affineRectangle_smooth c a b).differentiable (by simp) _)
    ((squareSqueeze_smooth k).differentiable (by simp) _),affineRectangle_fderiv,
    ContinuousLinearMap.det,ContinuousLinearMap.toLinearMap_comp,LinearMap.det_comp]
  change (diagonalScale a b).det * _ = _
  rw [diagonalScale_det]

theorem roundedMap_det_pos {k a b : ℝ} (hk : 0 < k) (ha : 0 < a) (hb : 0 < b)
    (c : Plane) (x : Plane) : 0 < (fderiv ℝ (roundedMap k c a b) x).det := by
  rw [roundedMap_det]
  exact mul_pos (mul_pos ha hb) (squareSqueeze_det_pos hk x)

theorem roundedMap_mem_openBox {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (c : Plane) (x : Plane) : roundedMap k c a b x ∈ openBox c a b := by
  have hx1 := Real.neg_one_lt_tanh (k*x.1)
  have hx2 := Real.tanh_lt_one (k*x.1)
  have hy1 := Real.neg_one_lt_tanh (k*x.2)
  have hy2 := Real.tanh_lt_one (k*x.2)
  change (c.1-a < c.1+a*Real.tanh (k*x.1) ∧ c.1+a*Real.tanh (k*x.1) < c.1+a) ∧
    (c.2-b < c.2+b*Real.tanh (k*x.2) ∧ c.2+b*Real.tanh (k*x.2) < c.2+b)
  constructor <;> constructor <;> nlinarith

theorem box_subset_roundedBox {q k a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (hs : Icc (-q) q ×ˢ Icc (-q) q ⊆ squeezedDisk k) (c : Plane) :
    box c (q*a) (q*b) ⊆ roundedBox k c a b := by
  intro x hx
  let z : Plane := ((x.1-c.1)/a,(x.2-c.2)/b)
  have hz : z ∈ Icc (-q) q ×ˢ Icc (-q) q := by
    change (-q ≤ (x.1-c.1)/a ∧ (x.1-c.1)/a ≤ q) ∧
      (-q ≤ (x.2-c.2)/b ∧ (x.2-c.2)/b ≤ q)
    constructor <;> constructor
    · apply (le_div_iff₀ ha).mpr; linarith [hx.1.1]
    · apply (div_le_iff₀ ha).mpr; linarith [hx.1.2]
    · apply (le_div_iff₀ hb).mpr; linarith [hx.2.1]
    · apply (div_le_iff₀ hb).mpr; linarith [hx.2.2]
  obtain ⟨u,hu,he⟩ := hs hz
  refine ⟨u,hu,?_⟩
  change affineRectangle c a b (squareSqueeze k u) = x
  rw [he]
  ext <;> simp [affineRectangle,z,mul_div_cancel₀ _ ha.ne',mul_div_cancel₀ _ hb.ne']

theorem openBox_subset_interior_roundedBox {q k a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (hs : Icc (-q) q ×ˢ Icc (-q) q ⊆ squeezedDisk k) (c : Plane) :
    openBox c (q*a) (q*b) ⊆ interior (roundedBox k c a b) := by
  apply (isOpen_Ioo.prod isOpen_Ioo).subset_interior_iff.mpr
  exact (prod_mono Ioo_subset_Icc_self Ioo_subset_Icc_self).trans
    (box_subset_roundedBox ha hb hs c)

theorem roundedBox_compact (k : ℝ) (c : Plane) (a b : ℝ) :
    IsCompact (roundedBox k c a b) :=
  (closedRoundDisk_isCompact 1).image (roundedMap_smooth k c a b).continuous

theorem roundedBox_volume {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (k : ℝ) (c : Plane) :
    (volume (roundedBox k c a b)).toReal = a*b*squeezedArea k := by
  change (volume ((affineRectangle c a b ∘ squareSqueeze k) '' closedRoundDisk 1)).toReal = _
  rw [image_comp]
  exact affineRectangle_squeezedArea ha hb c k


end

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

variable [FiniteDimensional ℝ E]

theorem isInvertible_of_det_ne_zero {A : E →L[ℝ] E} (hA : A.det ≠ 0) : A.IsInvertible :=
  ⟨(A.toLinearMap.equivOfDetNeZero hA).toContinuousLinearEquiv,rfl⟩

theorem smooth_map_nhds_eq {f : E → E} {x : E} (hf : ContDiffAt ℝ ∞ f x)
    (hd : (fderiv ℝ f x).det ≠ 0) : map f (𝓝 x) = 𝓝 (f x) := by
  obtain ⟨e,he⟩ := isInvertible_of_det_ne_zero hd
  have hs := hf.hasStrictFDerivAt (by simp)
  rw [← he] at hs
  exact hs.map_nhds_eq_of_equiv

theorem image_interior_subset_of_det_ne_zero {f : E → E} {S : Set E}
    (hf : ∀ x ∈ interior S, ContDiffAt ℝ ∞ f x)
    (hd : ∀ x ∈ interior S, (fderiv ℝ f x).det ≠ 0) :
    f '' interior S ⊆ interior (f '' S) := by
  rintro _ ⟨x,hx,rfl⟩
  apply mem_interior_iff_mem_nhds.mpr
  have hh := Filter.image_mem_map (m := f) (mem_interior_iff_mem_nhds.mp hx)
  rwa [smooth_map_nhds_eq (hf x hx) (hd x hx)] at hh

variable [FiniteDimensional ℝ F]

omit [FiniteDimensional ℝ E] [FiniteDimensional ℝ F] in
theorem det_fderiv_conjugate (e : E ≃L[ℝ] F) {f : F → F} {x : E}
    (hf : DifferentiableAt ℝ f (e x)) :
    (fderiv ℝ (fun x => e.symm (f (e x))) x).det = (fderiv ℝ f (e x)).det := by
  have hd := e.symm.hasFDerivAt.comp x (hf.hasFDerivAt.comp x e.hasFDerivAt)
  change (fderiv ℝ (e.symm ∘ f ∘ e) x).det = _
  rw [hd.fderiv]
  change LinearMap.det (e.symm.toLinearEquiv.toLinearMap ∘ₗ
    (fderiv ℝ f (e x)).toLinearMap ∘ₗ e.toLinearEquiv.toLinearMap) = _
  exact LinearMap.det_conj _ e.symm.toLinearEquiv


end

open scoped ContDiff Topology
open Set Function MeasureTheory

def FitsPolar (c : Plane) (a b : ℝ) : Prop :=
  0 < c.1-a ∧ c.1+a < 1 ∧ 0 < c.2-b ∧ c.2+b < 1

theorem openBox_subset_polar {c : Plane} {a b : ℝ} (hfit : FitsPolar c a b) :
    openBox c a b ⊆ areaPolarDomain := by
  intro x hx
  exact ⟨hfit.1.trans hx.1.1,hfit.2.2.1.trans hx.2.1,hx.2.2.trans hfit.2.2.2⟩

def polarRoundedMap (k : ℝ) (c : Plane) (a b : ℝ) (x : Plane) : Plane :=
  areaPolar (roundedMap k c a b x)

def polarRoundedDisk (k : ℝ) (c : Plane) (a b : ℝ) : Set Plane :=
  polarRoundedMap k c a b '' closedRoundDisk 1

theorem polarRoundedMap_injective {k a b : ℝ} (hk : 0 < k) (ha : 0 < a) (hb : 0 < b)
    (c : Plane) (hfit : FitsPolar c a b) : Injective (polarRoundedMap k c a b) := by
  intro x y he
  apply roundedMap_injective hk.ne' ha.ne' hb.ne' c
  exact areaPolar_injOn (openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c x))
    (openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c y)) he

theorem polarRoundedMap_smooth {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (c : Plane) (hfit : FitsPolar c a b) : ContDiff ℝ ∞ (polarRoundedMap k c a b) := by
  apply contDiff_iff_contDiffAt.mpr
  intro x
  exact (areaPolar_smoothAt (openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c x)).1).comp x
    (roundedMap_smooth k c a b).contDiffAt

theorem polarRoundedMap_det {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (c : Plane) (hfit : FitsPolar c a b) (x : Plane) :
    (fderiv ℝ (polarRoundedMap k c a b) x).det = (fderiv ℝ (roundedMap k c a b) x).det := by
  have hp := (openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c x)).1
  change (fderiv ℝ (areaPolar ∘ roundedMap k c a b) x).det = _
  rw [fderiv_comp x ((areaPolar_smoothAt hp).differentiableAt (by simp))
    ((roundedMap_smooth k c a b).differentiable (by simp) _),
    ContinuousLinearMap.det,ContinuousLinearMap.toLinearMap_comp,LinearMap.det_comp]
  change (fderiv ℝ areaPolar (roundedMap k c a b x)).det * _ = _
  rw [areaPolar_det hp,one_mul]

theorem polarRoundedMap_det_pos {k a b : ℝ} (hk : 0 < k) (ha : 0 < a) (hb : 0 < b)
    (c : Plane) (hfit : FitsPolar c a b) (x : Plane) :
    0 < (fderiv ℝ (polarRoundedMap k c a b) x).det := by
  rw [polarRoundedMap_det ha hb k c hfit]
  exact roundedMap_det_pos hk ha hb c x

theorem polarRoundedMap_capacity {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (c : Plane) (hfit : FitsPolar c a b) (x : Plane) :
    Real.pi * radiusSq (polarRoundedMap k c a b x) = (roundedMap k c a b x).1 :=
  areaPolar_capacity (openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c x)).1.le

theorem polarRoundedDisk_volume {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (c : Plane) (hfit : FitsPolar c a b) :
    (volume (polarRoundedDisk k c a b)).toReal = a*b*squeezedArea k := by
  change (volume ((areaPolar ∘ roundedMap k c a b) '' closedRoundDisk 1)).toReal = _
  rw [image_comp]
  change (volume (areaPolar '' roundedBox k c a b)).toReal = _
  rw [areaPolar_image_volume (roundedBox_compact k c a b).measurableSet (by
    rintro z ⟨x,_,rfl⟩
    exact openBox_subset_polar hfit (roundedMap_mem_openBox ha hb k c x))]
  exact roundedBox_volume ha.le hb.le k c

theorem polarRoundedDisk_nested {k a b a' b' : ℝ} {c c' : Plane}
    (ha' : 0 < a') (hb' : 0 < b') (hfit' : FitsPolar c' a' b')
    (hnest : roundedBox k c a b ⊆ interior (roundedBox k c' a' b')) :
    polarRoundedDisk k c a b ⊆ interior (polarRoundedDisk k c' a' b') := by
  change (areaPolar ∘ roundedMap k c a b) '' closedRoundDisk 1 ⊆
    interior ((areaPolar ∘ roundedMap k c' a' b') '' closedRoundDisk 1)
  rw [image_comp,image_comp]
  apply (image_mono hnest).trans
  apply image_interior_subset_of_det_ne_zero
  · intro x hx
    obtain ⟨z,_,rfl⟩ := interior_subset hx
    exact areaPolar_smoothAt (openBox_subset_polar hfit' (roundedMap_mem_openBox ha' hb' k c' z)).1
  · intro x hx
    obtain ⟨z,_,rfl⟩ := interior_subset hx
    rw [areaPolar_det (openBox_subset_polar hfit' (roundedMap_mem_openBox ha' hb' k c' z)).1]
    norm_num

variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]

theorem polarRoundedFamily_smoothOn {A : Set P} (_hA : IsOpen A)
    (C : P → Plane) (hC : ContDiff ℝ ∞ C) {a b : ℝ} (ha : 0 < a) (hb : 0 < b)
    (k : ℝ) (hfit : ∀ y ∈ A, FitsPolar (C y) a b) :
    ContDiffOn ℝ ∞ (fun p : P × Plane => polarRoundedMap k (C p.1) a b p.2) (A ×ˢ univ) := by
  intro p hp
  apply ContDiffAt.contDiffWithinAt
  have hg : ContDiff ℝ ∞ (fun p : P × Plane => roundedMap k (C p.1) a b p.2) :=
    (hC.comp contDiff_fst).add
      ((diagonalScale a b).contDiff.comp ((squareSqueeze_smooth k).comp contDiff_snd))
  exact (areaPolar_smoothAt
    (openBox_subset_polar (hfit p.1 hp.1) (roundedMap_mem_openBox ha hb k (C p.1) p.2)).1).comp p hg.contDiffAt



end PackingSufficiencySupport.Hamiltonian
end

end OAI