import Mathlib
import OAI.Probability.LatticeSurface.Dynamics.ClusterShift
import OAI.Probability.LatticeSurface.Dynamics.JacobianIdentity
import OAI.Probability.LatticeSurface.Dynamics.LogDet
import OAI.Probability.LatticeSurface.Dynamics.MatrixJacobi
import OAI.Probability.LatticeSurface.Dynamics.ShiftData

namespace OAI

open Set MeasureTheory intervalIntegral

open Matrix Polynomial

open scoped Topology

open Set MeasureTheory Filter

open scoped Topology

namespace TangentialJacobian

variable {V : Type*} [Fintype V] [DecidableEq V]

lemma opNorm_le_of_row_sum (A : (V → ℝ) →L[ℝ] (V → ℝ)) (K : ℝ) (hK : 0 ≤ K)
    (hrow : ∀ i, ∑ j, |asMatrix A i j| ≤ K) : ‖A‖ ≤ K := by
  apply A.opNorm_le_bound hK
  intro v
  apply (pi_norm_le_iff_of_nonneg (mul_nonneg hK (norm_nonneg v))).mpr
  intro i
  have he : A v i = ∑ j, asMatrix A i j * v j := by
    exact congrFun (LinearMap.toMatrix'_mulVec A.toLinearMap v).symm i
  rw [Real.norm_eq_abs, he]
  calc
    _ ≤ ∑ j, |asMatrix A i j| * |v j| := by
      simpa only [abs_mul] using Finset.abs_sum_le_sum_abs (fun j => asMatrix A i j * v j) Finset.univ
    _ ≤ ∑ j, |asMatrix A i j| * ‖v‖ := by
      apply Finset.sum_le_sum; intro j _
      exact mul_le_mul_of_nonneg_left (norm_le_pi_norm v j) (abs_nonneg _)
    _ = (∑ j, |asMatrix A i j|) * ‖v‖ := (Finset.sum_mul _ _ _).symm
    _ ≤ K * ‖v‖ := mul_le_mul_of_nonneg_right (hrow i) (norm_nonneg _)

end TangentialJacobian

namespace FeasibleShift

open TangentialJacobian

variable {V : Type*} [Fintype V] [DecidableEq V]

lemma freeShift_derivative_row (G : SimpleGraph V) (ground pins : Finset V)
    (β f : V → ℝ) (h : FreeSites pins → ℝ)
    (s₀ s₁ s₂ L : ℝ) (D : ℕ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (hfground : ∀ x ∈ ground, f x = 0)
    (hfl : ∀ x y, G.Adj x y → |f x - f y| ≤ L)
    (hD : ∀ x, (neighbors G x).card ≤ D)
    (A : (FreeSites pins → ℝ) →L[ℝ] (FreeSites pins → ℝ))
    (hu : HasFDerivAt (freeShift G ground pins β f s₀ s₁) A h) (x : FreeSites pins) :
    ∑ j, |asMatrix A x j| ≤ ((s₁ - s₀)⁻¹ * (4 * D * L)) *
      ((component (contactGraph G (extendHeight pins β h) s₂) x).card : ℝ)^2 := by
  classical
  have hd : 0 < s₁ - s₀ := sub_pos.mpr hs
  let C := component (contactGraph G (extendHeight pins β h) s₂) x
  let F : Finset (FreeSites pins) := Finset.univ.filter fun j => (j : V) ∈ C
  have hFc : F.card ≤ C.card := by
    apply Finset.card_le_card_of_injOn (fun j : FreeSites pins => (j : V))
    · intro j hj; exact (Finset.mem_filter.mp hj).2
    · intro j hj k hk hjk; exact Subtype.ext hjk
  have hsum : ∑ j, |asMatrix A x j| = ∑ j ∈ F, |asMatrix A x j| := by
    symm
    apply Finset.sum_subset (Finset.subset_univ _)
    intro j _ hj
    have hj' : (j : V) ∉ C := by simpa [F] using hj
    rw [asMatrix_apply, freeShift_derivative_entry_zero G ground pins β f h s₀ s₁ s₂ L
      hs hss hL hfground hfl A hu x j hj', abs_zero]
  rw [hsum]
  calc
    _ ≤ ∑ j ∈ F, ((s₁ - s₀)⁻¹ * (4 * D * L)) * C.card := by
      apply Finset.sum_le_sum; intro j _
      exact freeShift_derivative_entry G ground pins β f h s₀ s₁ s₂ L D hs hss hL hfground hfl hD A hu x j
    _ ≤ C.card * (((s₁ - s₀)⁻¹ * (4 * D * L)) * C.card) := by
      simp only [Finset.sum_const, nsmul_eq_mul]
      exact mul_le_mul_of_nonneg_right (by exact_mod_cast hFc) (by positivity)
    _ = _ := by dsimp [C]; ring

lemma freeShift_derivative_column (G : SimpleGraph V) (ground pins : Finset V)
    (β f : V → ℝ) (h : FreeSites pins → ℝ)
    (s₀ s₁ s₂ L : ℝ) (D : ℕ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (hfground : ∀ x ∈ ground, f x = 0)
    (hfl : ∀ x y, G.Adj x y → |f x - f y| ≤ L)
    (hD : ∀ x, (neighbors G x).card ≤ D)
    (A : (FreeSites pins → ℝ) →L[ℝ] (FreeSites pins → ℝ))
    (hu : HasFDerivAt (freeShift G ground pins β f s₀ s₁) A h) (j : FreeSites pins) :
    ‖A (Pi.single j 1)‖ ≤ ((s₁ - s₀)⁻¹ * (4 * D * L)) *
      (component (contactGraph G (extendHeight pins β h) s₂) j).card := by
  have hd : 0 < s₁ - s₀ := sub_pos.mpr hs
  apply (pi_norm_le_iff_of_nonneg (by positivity)).mpr
  intro x
  rw [Real.norm_eq_abs]
  by_cases hj : (j : V) ∈ component (contactGraph G (extendHeight pins β h) s₂) x
  · have he := component_eq_of_reachable ((mem_component _ _ _).mp hj)
    rw [← he]
    exact freeShift_derivative_entry G ground pins β f h s₀ s₁ s₂ L D hs hss hL hfground hfl hD A hu x j
  · rw [freeShift_derivative_entry_zero G ground pins β f h s₀ s₁ s₂ L
      hs hss hL hfground hfl A hu x j hj, abs_zero]
    positivity

lemma freeShift_derivative_cost (G : SimpleGraph V) (ground pins : Finset V)
    (β f : V → ℝ) (h : FreeSites pins → ℝ)
    (s₀ s₁ s₂ L : ℝ) (D : ℕ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (hfground : ∀ x ∈ ground, f x = 0)
    (hfl : ∀ x y, G.Adj x y → |f x - f y| ≤ L)
    (hD : ∀ x, (neighbors G x).card ≤ D)
    (A : (FreeSites pins → ℝ) →L[ℝ] (FreeSites pins → ℝ))
    (hu : HasFDerivAt (freeShift G ground pins β f s₀ s₁) A h) :
    jacobianCost A ≤ ((s₁ - s₀)⁻¹ * (4 * D * L)) ^ 2 *
        ∑ x : FreeSites pins, if (x : V) ∈ ground then 0 else
          ((component (contactGraph G (extendHeight pins β h) s₂) x).card : ℝ) ^ 3 := by
  classical
  rw [jacobianCost, Finset.mul_sum]
  apply Finset.sum_le_sum
  intro x _
  have hd : 0 < s₁ - s₀ := sub_pos.mpr hs
  by_cases hx : (x : V) ∈ ground
  · simp only [ite_eq_left hx, mul_zero, asMatrix_apply,
      freeShift_derivative_ground G ground pins β f h s₀ s₁ A hu x _ hx,
      abs_zero, Finset.sum_const_zero, zero_mul, le_refl]
  rw [ite_eq_right hx]
  calc
    _ ≤ (((s₁ - s₀)⁻¹ * (4 * D * L)) *
        ((component (contactGraph G (extendHeight pins β h) s₂) x).card : ℝ)^2) *
        (((s₁ - s₀)⁻¹ * (4 * D * L)) *
        (component (contactGraph G (extendHeight pins β h) s₂) x).card) :=
      mul_le_mul (freeShift_derivative_row G ground pins β f h s₀ s₁ s₂ L D hs hss hL hfground hfl hD A hu x)
        (freeShift_derivative_column G ground pins β f h s₀ s₁ s₂ L D hs hss hL hfground hfl hD A hu x)
        (norm_nonneg _) (by positivity)
    _ = _ := by ring

lemma freeShift_derivative_opNorm (G : SimpleGraph V) (ground pins : Finset V)
    (β f : V → ℝ) (h : FreeSites pins → ℝ)
    (s₀ s₁ s₂ L B : ℝ) (D : ℕ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (hB : 0 ≤ B) (hfground : ∀ x ∈ ground, f x = 0)
    (hfl : ∀ x y, G.Adj x y → |f x - f y| ≤ L)
    (hD : ∀ x, (neighbors G x).card ≤ D)
    (hgood : ∀ x, ((component (contactGraph G (extendHeight pins β h) s₂) x).card : ℝ) ≤ B)
    (A : (FreeSites pins → ℝ) →L[ℝ] (FreeSites pins → ℝ))
    (hu : HasFDerivAt (freeShift G ground pins β f s₀ s₁) A h) :
    ‖A‖ ≤ ((s₁ - s₀)⁻¹ * (4 * D * L)) * B ^ 2 := by
  have hd : 0 < s₁ - s₀ := sub_pos.mpr hs
  apply opNorm_le_of_row_sum A _ (by positivity)
  intro x
  exact (freeShift_derivative_row G ground pins β f h s₀ s₁ s₂ L D hs hss hL hfground hfl hD A hu x).trans
    (mul_le_mul_of_nonneg_left ((sq_le_sq₀ (by positivity) hB).mpr (hgood x)) (by positivity))

end FeasibleShift

namespace FeasibleShift

open TangentialJacobian

variable {V : Type*} [Fintype V] [DecidableEq V]

lemma freeShift_det_identity (G₀ G : SimpleGraph V) (ground pins walls : Finset V)
    (hp : pins ⊆ ground) (hw : walls ⊆ ground)
    (hG : ∀ x y, G₀.Adj x y → G.Adj x y ∨ (x ∈ ground ∧ y ∈ ground))
    (β f : V → ℝ) (I : V → Set ℝ) (s₀ s₁ M : ℝ) (hs : s₀ < s₁) (hs₀ : 0 < s₀)
    (hM : 0 ≤ M) (hfb : ∀ x, |f x| ≤ M)
    (hP : MeasurableSet (heightPolytope G₀ pins walls β I)) :
    ∃ δ : ℝ, 0 < δ ∧ ∀ t ∈ Set.Ioo (-δ) δ,
      ∫ h in heightPolytope G₀ pins walls β I,
        (1 + t • fderiv ℝ (freeShift G ground pins β f s₀ s₁) h).det =
        (volume (heightPolytope G₀ pins walls β I)).toReal := by
  have hdiff : 0 < s₁ - s₀ := sub_pos.mpr hs
  let K : NNReal := ⟨(s₁ - s₀)⁻¹ * (4 * M * Fintype.card (V × V)), by positivity⟩
  let δ : ℝ := min (s₀ / (2 * M + 1)) (1 / (K + 1))
  have hδ : 0 < δ := lt_min (by positivity) (by positivity)
  refine ⟨δ, hδ, ?_⟩
  intro t ht
  have ht' : |t| < δ := abs_lt.mpr ht
  have htM : |t| * (2 * M) ≤ s₀ := by
    have hh := (lt_div_iff₀ (show 0 < 2 * M + 1 by positivity)).mp
      (ht'.trans_le (min_le_left _ _))
    nlinarith [abs_nonneg t]
  have htK : |t| * K < 1 := by
    have hh := (lt_div_iff₀ (show 0 < (K : ℝ) + 1 by positivity)).mp
      (ht'.trans_le (min_le_right _ _))
    nlinarith [abs_nonneg t]
  have hu : LipschitzWith K (freeShift G ground pins β f s₀ s₁) :=
    freeShift_lipschitz G ground pins β f s₀ s₁ M hs hM hfb
  exact det_integral_of_invariant _ K hu _ hP t htK
    (identity_add_bijective _ K hu t htK).injective.injOn
    (freeShift_small_polytope_onto G₀ G ground pins walls hp hw hG β f I s₀ s₁ M t
      hs hs₀.le hM hfb htM htK)

lemma freeShift_divergence_identities (G₀ G : SimpleGraph V) (ground pins walls : Finset V)
    (hp : pins ⊆ ground) (hw : walls ⊆ ground)
    (hG : ∀ x y, G₀.Adj x y → G.Adj x y ∨ (x ∈ ground ∧ y ∈ ground))
    (β f : V → ℝ) (I : V → Set ℝ) (s₀ s₁ M : ℝ) (hs : s₀ < s₁) (hs₀ : 0 < s₀)
    (hM : 0 ≤ M) (hfb : ∀ x, |f x| ≤ M)
    (hP : MeasurableSet (heightPolytope G₀ pins walls β I))
    (hPfin : volume (heightPolytope G₀ pins walls β I) ≠ ⊤) :
    (∫ h in heightPolytope G₀ pins walls β I,
      (asMatrix (fderiv ℝ (freeShift G ground pins β f s₀ s₁) h)).trace) = 0 ∧
    (∫ h in heightPolytope G₀ pins walls β I,
      (asMatrix (fderiv ℝ (freeShift G ground pins β f s₀ s₁) h)).trace ^ 2) =
    (∫ h in heightPolytope G₀ pins walls β I,
      (asMatrix (fderiv ℝ (freeShift G ground pins β f s₀ s₁) h *
        fderiv ℝ (freeShift G ground pins β f s₀ s₁) h)).trace) := by
  let P := heightPolytope G₀ pins walls β I
  let u := freeShift G ground pins β f s₀ s₁
  have hdiff : 0 < s₁ - s₀ := sub_pos.mpr hs
  let K : NNReal := ⟨(s₁ - s₀)⁻¹ * (4 * M * Fintype.card (V × V)), by positivity⟩
  have hu : LipschitzWith K u := freeShift_lipschitz G ground pins β f s₀ s₁ M hs hM hfb
  let : IsFiniteMeasure (volume.restrict P) := ⟨by simpa [P] using hPfin.lt_top⟩
  obtain ⟨δ, hδ, hid⟩ := freeShift_det_identity G₀ G ground pins walls hp hw hG β f I s₀ s₁ M
    hs hs₀ hM hfb hP
  have hid' : ∀ t ∈ Set.Ioo (-δ) δ, ∫ h, (1 + t • fderiv ℝ u h).det ∂(volume.restrict P) =
      ((volume.restrict P) Set.univ).toReal := by simpa [P, u] using hid
  refine ⟨trace_integral_zero_of_det_identity (volume.restrict P) (fderiv ℝ u)
      (measurable_fderiv ℝ u) K (fun h => norm_fderiv_le_of_lipschitz ℝ hu) δ hδ hid',
    trace_square_integral_of_det_identity (volume.restrict P) (fderiv ℝ u)
      (measurable_fderiv ℝ u) K (fun h => norm_fderiv_le_of_lipschitz ℝ hu) δ hδ hid'⟩

end FeasibleShift

namespace TangentialJacobian

variable {V : Type*} [Fintype V] [DecidableEq V]

lemma continuous_trace : Continuous (fun A : (V → ℝ) →L[ℝ] (V → ℝ) => (asMatrix A).trace) := by
  simp_rw [← traceCLM_apply]
  exact (traceCLM (V := V)).continuous

lemma continuous_jacobianCost : Continuous (jacobianCost : ((V → ℝ) →L[ℝ] (V → ℝ)) → ℝ) := by
  unfold jacobianCost
  apply continuous_finsetSum
  intro i _
  apply Continuous.mul
  · apply continuous_finsetSum
    intro j _
    simp only [asMatrix_apply]
    fun_prop
  · fun_prop

omit [DecidableEq V] in
lemma uniform_image_area (P S : Set (V → ℝ)) (hP : MeasurableSet P) (hS : MeasurableSet S)
    (hSP : S ⊆ P) (T : (V → ℝ) → (V → ℝ)) (K : NNReal) (hT : LipschitzWith K T)
    (hinj : Set.InjOn T S) (hTP : T '' S ⊆ P) :
    (ProbabilityTheory.cond volume P).real (T '' S) =
      ∫ x in S, |(fderiv ℝ T x).det| ∂(ProbabilityTheory.cond volume P) := by
  have harea := lipschitz_area hT hS hinj
  have he : P ∩ (T '' S) = T '' S := Set.inter_eq_right.mpr hTP
  rw [measureReal_def, ProbabilityTheory.cond_apply hP, he, ENNReal.toReal_mul,
    ProbabilityTheory.cond, Measure.restrict_smul, Measure.restrict_restrict hS,
    Set.inter_eq_left.mpr hSP, MeasureTheory.integral_smul_measure]
  congr 1
  symm
  calc
    _ = (∫⁻ x in S, ENNReal.ofReal |(fderiv ℝ T x).det|).toReal :=
      integral_eq_lintegral_of_nonneg_ae (Filter.Eventually.of_forall fun x => abs_nonneg _)
        ((ContinuousLinearMap.continuous_det.measurable.comp (measurable_fderiv ℝ T)).abs.aestronglyMeasurable)
    _ = _ := congrArg ENNReal.toReal harea

omit [DecidableEq V] in
lemma jacobian_integrable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
    (B : Ω → (V → ℝ) →L[ℝ] (V → ℝ)) (hB : Measurable B) (K : ℝ)
    (hK : ∀ x, ‖B x‖ ≤ K) : Integrable (fun x => |(B x).det|) μ :=
  continuous_integrable_of_bounded μ B hB K hK _ (ContinuousLinearMap.continuous_det.abs)

omit [DecidableEq V] in
lemma uniform_image_lower_bound (P S : Set (V → ℝ)) (hP : MeasurableSet P) (hS : MeasurableSet S)
    (hSP : S ⊆ P) (hPzero : volume P ≠ 0) (hPfin : volume P ≠ ⊤)
    (T : (V → ℝ) → (V → ℝ)) (K : NNReal) (hT : LipschitzWith K T)
    (hinj : Set.InjOn T S) (hTP : T '' S ⊆ P) (c : ℝ)
    (hdet : ∀ᵐ x ∂(volume.restrict S), c ≤ |(fderiv ℝ T x).det|) :
    c * (ProbabilityTheory.cond volume P).real S ≤
      (ProbabilityTheory.cond volume P).real (T '' S) := by
  let μ := ProbabilityTheory.cond volume P
  let : IsProbabilityMeasure μ := ProbabilityTheory.cond_isProbabilityMeasure_of_finite hPzero hPfin
  rw [uniform_image_area P S hP hS hSP T K hT hinj hTP]
  have hdet' : ∀ᵐ x ∂(μ.restrict S), c ≤ |(fderiv ℝ T x).det| := by
    have hab : μ.restrict S ≪ volume.restrict S :=
      (show μ ≪ volume from ProbabilityTheory.cond_absolutelyContinuous).restrict S
    exact hab.ae_le hdet
  have hi := jacobian_integrable μ (fderiv ℝ T) (measurable_fderiv ℝ T) K
    (fun x => norm_fderiv_le_of_lipschitz ℝ hT)
  have hh := integral_mono_ae (integrable_const c : Integrable (fun _ : V → ℝ => c) (μ.restrict S))
    hi.integrableOn hdet'
  simpa only [MeasureTheory.integral_const, Measure.restrict_apply_univ, smul_eq_mul, mul_comm,
    measureReal_def] using hh

end TangentialJacobian

namespace TangentialJacobian

variable {V : Type*} [Fintype V] [DecidableEq V]

lemma markov_real {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
    (F : Ω → ℝ) (hF : Integrable F μ) (hn : ∀ x, 0 ≤ F x) (K : ℝ) (hK : 0 < K) :
    μ.real {x | K < F x} ≤ (∫ x, F x ∂μ) / K := by
  apply (le_div_iff₀ hK).mpr
  have hh := mul_meas_ge_le_integral_of_nonneg (Filter.Eventually.of_forall hn) hF K
  have hm : μ.real {x | K < F x} ≤ μ.real {x | K ≤ F x} :=
    measureReal_mono (fun x (hx : K < F x) => le_of_lt hx)
  nlinarith

lemma event_volume_of_moments (P G : Set (V → ℝ)) (hP : MeasurableSet P)
    (hG : MeasurableSet G) (hPzero : volume P ≠ 0) (hPfin : volume P ≠ ⊤)
    (u : (V → ℝ) → (V → ℝ)) (Klip : NNReal) (hu : LipschitzWith Klip u)
    (hinj : Set.InjOn (fun x => x + u x) G)
    (hfeas : ∀ x ∈ P ∩ G, x + u x ∈ P)
    (hnorm : ∀ x ∈ G, ‖fderiv ℝ u x‖ ≤ 1/2)
    (C p K : ℝ) (_hp : 0 < p) (hK : 1 ≤ K)
    (hmoment : (∫ x, (asMatrix (fderiv ℝ u x)).trace ^ 2 + jacobianCost (fderiv ℝ u x)
      ∂(ProbabilityTheory.cond volume P)) ≤ C)
    (hCK : C / K ≤ p/4)
    (hbad : (ProbabilityTheory.cond volume P).real Gᶜ ≤ p/4)
    (E : Set (V → ℝ)) (hE : MeasurableSet E)
    (hEp : p ≤ (ProbabilityTheory.cond volume P).real E) :
    ∃ S : Set (V → ℝ), MeasurableSet S ∧ S ⊆ E ∩ P ∩ G ∧
      p/2 ≤ (ProbabilityTheory.cond volume P).real S ∧
      Set.InjOn (fun x => x + u x) S ∧ (fun x => x + u x) '' S ⊆ P ∧
      MeasurableSet ((fun x => x + u x) '' S) ∧
      Real.exp (-2*K) * p/2 ≤ (ProbabilityTheory.cond volume P).real ((fun x => x + u x) '' S) := by
  let μ := ProbabilityTheory.cond volume P
  let : IsProbabilityMeasure μ := ProbabilityTheory.cond_isProbabilityMeasure_of_finite hPzero hPfin
  let A := fderiv ℝ u
  let F := fun x => (asMatrix (A x)).trace ^ 2 + jacobianCost (A x)
  have hFc : Continuous (fun B : (V → ℝ) →L[ℝ] (V → ℝ) => (asMatrix B).trace ^ 2 + jacobianCost B) :=
    (continuous_trace.pow 2).add continuous_jacobianCost
  have hFm : Measurable F := hFc.measurable.comp (measurable_fderiv ℝ u)
  have hFi : Integrable F μ := continuous_integrable_of_bounded μ A (measurable_fderiv ℝ u) Klip
    (fun x => norm_fderiv_le_of_lipschitz ℝ hu) _ hFc
  have hFn (x) : 0 ≤ F x := add_nonneg (sq_nonneg _) (jacobianCost_nonneg _)
  let B := Gᶜ ∪ {x | K < F x}
  have hBm : MeasurableSet B := hG.compl.union (measurableSet_lt measurable_const hFm)
  have hBm_bound : μ.real B ≤ p/2 := by
    have hmark := markov_real μ F hFi hFn K (by linarith)
    have hquot : (∫ x, F x ∂μ) / K ≤ C / K := div_le_div_of_nonneg_right hmoment (by linarith)
    have hh := measureReal_union_le (μ := μ) Gᶜ {x | K < F x}
    dsimp [B]
    linarith
  let S := (E ∩ P) \ B
  have hSm : MeasurableSet S := (hE.inter hP).diff hBm
  have hSsub : S ⊆ E ∩ P ∩ G := by
    intro x hx
    exact ⟨hx.1, by by_contra hg; exact hx.2 (Or.inl hg)⟩
  have hSmass : p/2 ≤ μ.real S := by
    have heq : μ.real (E ∩ P) = μ.real E := by
      unfold Measure.real
      congr 1
      rw [Set.inter_comm, ProbabilityTheory.cond_inter_self hP]
    have hh := le_measureReal_sdiff (μ := μ) (s₁ := E ∩ P) (s₂ := B)
    rw [heq] at hh
    linarith
  have hSinj : Set.InjOn (fun x => x + u x) S := hinj.mono (fun x hx => (hSsub hx).2)
  have hSP : S ⊆ P := fun x hx => (hSsub hx).1.2
  have hSTP : (fun x => x + u x) '' S ⊆ P := by
    rintro y ⟨x, hx, rfl⟩
    exact hfeas x ⟨hSP hx, (hSsub hx).2⟩
  have hSTm : MeasurableSet ((fun x => x + u x) '' S) :=
    hSm.image_of_continuousOn_injOn (continuous_id.add hu.continuous).continuousOn hSinj
  have hdet : ∀ᵐ x ∂(volume.restrict S), Real.exp (-2*K) ≤ |(fderiv ℝ (fun x => x + u x) x).det| := by
    filter_upwards [ae_restrict_mem hSm, ae_restrict_of_ae (ae_fderiv_id_add_smul hu 1)] with x hx hdx
    have hdx' : fderiv ℝ (fun x => x + u x) x = 1 + A x := by simpa [A] using hdx
    rw [hdx']
    have hAx := hnorm x ((hSsub hx).2)
    have hFK : F x ≤ K := le_of_not_gt (fun h => hx.2 (Or.inr h))
    have ht : |(asMatrix (A x)).trace| ≤ K := by
      have hcost := jacobianCost_nonneg (A x)
      have habsq := sq_abs (asMatrix (A x)).trace
      have hab := abs_nonneg (asMatrix (A x)).trace
      dsimp [F] at hFK
      nlinarith
    have hc : jacobianCost (A x) ≤ K := by
      dsimp [F] at hFK
      nlinarith [sq_nonneg (asMatrix (A x)).trace]
    have hlog := logdet_lower_bound (A x) hAx
    have hpos := det_one_add_pos (A x) (hAx.trans_lt (by norm_num))
    rw [abs_of_pos hpos, ← Real.exp_log hpos]
    apply Real.exp_le_exp.mpr
    have htt := (abs_le.mp ht).1
    linarith
  have harea := uniform_image_lower_bound P S hP hSm hSP hPzero hPfin
    (fun x => x + u x) (1 + Klip) (by simpa using lipschitz_id_add_smul hu 1)
    hSinj hSTP (Real.exp (-2*K)) hdet
  refine ⟨S, hSm, hSsub, hSmass, hSinj, hSTP, hSTm, ?_⟩
  have hexp : 0 ≤ Real.exp (-2*K) := (Real.exp_pos _).le
  nlinarith [mul_le_mul_of_nonneg_left hSmass hexp]

end TangentialJacobian

end OAI