import Mathlib
import OAI.Probability.LatticeSurface.Coercivity.SparseClusters
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.ShiftAnalysis
import OAI.Probability.LatticeSurface.Dynamics.ShiftAsymptotics
import OAI.Probability.LatticeSurface.Dynamics.ShiftData

namespace OAI

universe u v

open Set MeasureTheory

namespace FeasibleShift.ShiftData

open SparseClusters

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

variable {W : Type v} [Fintype W] [DecidableEq W]

variable {n D Db B : ℕ} {ρ : ENNReal} {sstar L M N : ℝ}

variable (S : ShiftData (V := V) W n D Db B ρ sstar L M N)

noncomputable def active := shiftGraph S.graph S.ground

noncomputable def H (s : ℝ) (x : V) (h : FreeSites S.pins → ℝ) : ℕ :=
  (FeasibleShift.component (contactGraph S.active (extendHeight S.pins S.boundary h) s) x).card

noncomputable def good (s R : ℝ) : Set (FreeSites S.pins → ℝ) := {h | ∀ x, (S.H s x h : ℝ) ≤ R}

instance law_isProbabilityMeasure : IsProbabilityMeasure S.law :=
  ProbabilityTheory.cond_isProbabilityMeasure_of_finite S.polytope_positive S.polytope_finite

lemma active_le : S.active ≤ S.graph := fun _ _ h => h.1

lemma active_degree (x : V) : (neighbors S.active x).card ≤ D := by
  apply (Finset.card_le_card ?_).trans (S.degree x)
  intro y hy
  exact (mem_neighbors _ _ _).mpr (S.active_le ((mem_neighbors _ _ _).mp hy))

lemma H_pos (s : ℝ) (x : V) (h : FreeSites S.pins → ℝ) : 0 < S.H s x h :=
  Finset.card_pos.mpr ⟨x, self_mem_component _ x⟩

lemma H_le_card (s : ℝ) (x : V) (h : FreeSites S.pins → ℝ) : S.H s x h ≤ Fintype.card V :=
  Finset.card_le_univ _

lemma H_measurable (s : ℝ) (x : V) : Measurable (S.H s x) := by
  apply measurable_graph_statistic (fun h => contactGraph S.active (extendHeight S.pins S.boundary h) s) ?_
    (fun G => (FeasibleShift.component G x).card)
  intro y z
  by_cases hG : S.active.Adj y z
  · have hm : Measurable (fun h : FreeSites S.pins → ℝ =>
        1 - |extendHeight S.pins S.boundary h y - extendHeight S.pins S.boundary h z|) :=
      (measurable_const.sub (((continuous_apply y).comp (extendHeight_lipschitz S.pins S.boundary).continuous).measurable.sub
        (((continuous_apply z).comp (extendHeight_lipschitz S.pins S.boundary).continuous).measurable)).abs)
    simpa only [contactGraph, hG, true_and] using measurableSet_le hm measurable_const
  · simp only [contactGraph, hG, false_and, Set.ofPred_false, MeasurableSet.empty]

lemma good_measurable (s R : ℝ) : MeasurableSet (S.good s R) := by
  unfold good
  simp_rw [Set.ofPred_forall]
  apply MeasurableSet.iInter
  intro x
  exact measurableSet_le ((measurable_of_countable (fun k : ℕ => (k : ℝ))).comp (S.H_measurable s x)) measurable_const

lemma H_tail (s : ℝ) (hs : s ≤ sstar) (hρ : ρ ≤ 1)
    (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2) (x : V) (m : ℕ) (hm : 1 ≤ m) :
    S.law {h | B*m+1 ≤ S.H s x h} ≤ (1/2 : ENNReal)^m := by
  classical
  have hh := sparse_cover_component_tail S.law S.boxGraph Db B S.box_degree S.boxMap S.box_fiber
    (fun h => contactGraph S.active (extendHeight S.pins S.boundary h) s) S.badBoxes
    (fun h x y hadj => S.box_adjacent x y hadj.1.1)
    (fun h x y hadj => S.contact_bad h x y ⟨hadj.1, hadj.2.trans hs⟩)
    ρ hρ S.sparse x m hm
  exact hh.trans (pow_le_pow_left' hsparse m)

lemma H_integrable (s : ℝ) (x : V) (k : ℕ) :
    Integrable (fun h => (S.H s x h : ℝ)^k) S.law :=
  nat_pow_integrable_of_bound S.law (S.H s x) (S.H_measurable s x)
    (Fintype.card V) (S.H_le_card s x) k

lemma H_moment (s : ℝ) (hs : s ≤ sstar) (hB : 0 < B) (hρ : ρ ≤ 1)
    (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2) (x : V) (k : ℕ) :
    (∫ h, (S.H s x h : ℝ)^k ∂S.law) ≤ boxMoment B k :=
  nat_real_moment_of_geometric_tail S.law (S.H s x) (S.H_measurable s x) (S.H_pos s x)
    B hB (S.H_tail s hs hρ hsparse x) k

lemma mem_local_of_not_ground {x : V} (hx : x ∉ S.ground) : x ∈ localSites S.graph S.ground := by
  classical
  exact Finset.mem_filter.mpr ⟨Finset.mem_univ x, Or.inl hx⟩

lemma H_outside_local (s : ℝ) (x : V) (hx : x ∉ localSites S.graph S.ground)
    (h : FreeSites S.pins → ℝ) : S.H s x h = 1 := by
  classical
  have hxg : x ∈ S.ground := by
    by_contra hh
    exact hx (S.mem_local_of_not_ground hh)
  have hno (y : V) : ¬ (contactGraph S.active (extendHeight S.pins S.boundary h) s).Adj x y := by
    intro hh
    have hy : y ∉ S.ground := fun hyy => hh.1.2 ⟨hxg, hyy⟩
    exact hx (Finset.mem_filter.mpr ⟨Finset.mem_univ x, Or.inr ⟨y, hy, hh.1.1⟩⟩)
  have he : FeasibleShift.component (contactGraph S.active (extendHeight S.pins S.boundary h) s) x = {x} := by
    ext y
    rw [mem_component, Finset.mem_singleton]
    constructor
    · rintro ⟨w⟩
      cases w with
      | nil => rfl
      | cons hadj w => exact (hno _ hadj).elim
    · rintro rfl
      exact SimpleGraph.Reachable.refl _
  change (FeasibleShift.component _ x).card = 1
  rw [he, Finset.card_singleton]

lemma bad_good_bound (s R : ℝ) (hs : s ≤ sstar) (hB : 0 < B) (hρ : ρ ≤ 1)
    (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2) (hR : 1 ≤ R) (k : ℕ) (hk : 0 < k) :
    S.law.real (S.good s R)ᶜ ≤ ((localSites S.graph S.ground).card : ℝ) * boxMoment B k / R^k := by
  classical
  let U := {x // x ∈ localSites S.graph S.ground}
  have he : (S.good s R)ᶜ = {h | ∃ x : U, R < (S.H s x h : ℝ)} := by
    ext h
    simp only [good, Set.mem_compl_iff, Set.mem_ofPred_eq, not_forall, not_le]
    constructor
    · rintro ⟨x, hx⟩
      have hxl : x ∈ localSites S.graph S.ground := by
        by_contra hh
        rw [S.H_outside_local s x hh, Nat.cast_one] at hx
        exact (not_lt_of_ge hR) hx
      exact ⟨⟨x, hxl⟩, hx⟩
    · rintro ⟨x, hx⟩
      exact ⟨x, hx⟩
  rw [he]
  have hh := maximum_nat_moment_bound S.law (fun x : U => S.H s x)
    (fun x => S.H_measurable s x) (Fintype.card V) (fun x => S.H_le_card s x)
    k hk _ R (by linarith) (fun x => S.H_moment s hs hB hρ hsparse x k)
  simpa only [U, Fintype.card_coe] using hh

lemma active_or_ground {x y : V} (hxy : S.graph.Adj x y) :
    S.active.Adj x y ∨ (x ∈ S.ground ∧ y ∈ S.ground) := by
  by_cases hh : x ∈ S.ground ∧ y ∈ S.ground
  · exact Or.inr hh
  · exact Or.inl ⟨hxy, hh⟩

lemma shift_lipschitz (s₀ s₁ : ℝ) (hs : s₀ < s₁) (hM : 0 ≤ M) :
    LipschitzWith ⟨(s₁-s₀)⁻¹ * (4*M*Fintype.card (V × V)), by positivity⟩ (S.shift s₀ s₁) :=
  freeShift_lipschitz S.active S.ground S.pins S.boundary S.prescribed s₀ s₁ M hs hM S.prescribed_bound

lemma extend_map (s₀ s₁ : ℝ) (h : FreeSites S.pins → ℝ) :
    extendHeight S.pins S.boundary (S.map s₀ s₁ h) =
      extendHeight S.pins S.boundary h +
        averagedShift S.active S.ground S.prescribed (extendHeight S.pins S.boundary h) s₀ s₁ := by
  simpa only [one_smul, map, shift, active] using extendHeight_shift S.active S.ground S.pins S.pins_ground
    S.boundary S.prescribed s₀ s₁ 1 h

lemma map_feasible (s₀ s₁ s₂ R : ℝ) (hs : s₀ < s₁) (hss : s₁ ≤ s₂) (hL : 0 ≤ L)
    (hsmall : L / n * (2*R+1) ≤ s₀) (h : FreeSites S.pins → ℝ)
    (hP : h ∈ S.polytope) (hg : h ∈ S.good s₂ R) : S.map s₀ s₁ h ∈ S.polytope := by
  change (∀ x y, S.graph.Adj x y → |extendHeight S.pins S.boundary (S.map s₀ s₁ h) x -
    extendHeight S.pins S.boundary (S.map s₀ s₁ h) y| ≤ 1) ∧ _
  rw [S.extend_map]
  constructor
  · intro x y hxy
    rcases S.active_or_ground hxy with ha | ⟨hx, hy⟩
    · exact averagedShift_feasible S.active S.ground S.prescribed
        (extendHeight S.pins S.boundary h) s₀ s₁ s₂ (L/n) R hs hss (by positivity)
        S.prescribed_ground (fun x y hh => S.prescribed_gradient x y hh.1) hg hsmall
        (fun x y hh => hP.1 x y hh.1) x y ha
    · simpa only [Pi.add_apply, averagedShift_ground S.active S.ground S.prescribed
        (extendHeight S.pins S.boundary h) s₀ s₁ hx,
        averagedShift_ground S.active S.ground S.prescribed
        (extendHeight S.pins S.boundary h) s₀ s₁ hy, add_zero] using hP.1 x y hxy
  · intro x hx
    simpa only [Pi.add_apply, averagedShift_ground S.active S.ground S.prescribed
      (extendHeight S.pins S.boundary h) s₀ s₁ (S.walls_ground hx), add_zero] using hP.2 x hx

lemma map_injective (s₀ s₁ s₂ R : ℝ) (hs : s₀ < s₁) (hss : s₁ ≤ s₂)
    (hL : 0 ≤ L) (hR : 0 ≤ R) (hbuf : s₁ + 4*(L/n)*R ≤ s₂)
    (hsmall : (s₁-s₀)⁻¹ * (4*D*(L/n)) * R^2 < 1) :
    Set.InjOn (S.map s₀ s₁) (S.good s₂ R) := by
  intro h hh k hk hc
  have hh' := averagedShift_injective_good S.active S.ground S.prescribed s₀ s₁ s₂ (L/n) R D
    hs hss (by positivity) hR S.prescribed_ground
    (fun x y hxy => S.prescribed_gradient x y hxy.1) S.active_degree hbuf hsmall hh hk
  have he := congrArg (extendHeight S.pins S.boundary) hc
  rw [S.extend_map, S.extend_map] at he
  have hhk := hh' he
  ext x
  simpa only [extendHeight_free] using congrFun hhk (x : V)

lemma approximation_on_good (s₀ s₁ s₂ R : ℝ) (hs : s₀ < s₁) (hss : s₁ ≤ s₂)
    (hL : 0 ≤ L) (hR : 0 ≤ R) (h : FreeSites S.pins → ℝ) (hg : h ∈ S.good s₂ R) :
    ‖S.map s₀ s₁ h - h - (fun x : FreeSites S.pins => S.prescribed x)‖ ≤ (L/n)*R := by
  apply (pi_norm_le_iff_of_nonneg (by positivity)).mpr
  intro x
  change |(h x + S.shift s₀ s₁ h x) - h x - S.prescribed x| ≤ _
  rw [add_sub_cancel_left]
  exact (averagedShift_approximation S.active S.ground S.prescribed
    (extendHeight S.pins S.boundary h) s₀ s₁ s₂ (L/n) hs hss (by positivity)
    S.prescribed_ground (fun x y hh => S.prescribed_gradient x y hh.1) x).trans
      (mul_le_mul_of_nonneg_left (hg x) (by positivity))

open TangentialJacobian

lemma derivative_on_good (s₀ s₁ s₂ R : ℝ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (hR : 0 ≤ R) (h : FreeSites S.pins → ℝ) (hg : h ∈ S.good s₂ R) :
    ‖fderiv ℝ (S.shift s₀ s₁) h‖ ≤ (s₁-s₀)⁻¹ * (4*D*(L/n)) * R^2 := by
  have hd : 0 < s₁-s₀ := sub_pos.mpr hs
  by_cases hu : DifferentiableAt ℝ (S.shift s₀ s₁) h
  · exact freeShift_derivative_opNorm S.active S.ground S.pins S.boundary S.prescribed h
      s₀ s₁ s₂ (L/n) R D hs hss (by positivity) hR S.prescribed_ground
      (fun x y hh => S.prescribed_gradient x y hh.1) S.active_degree hg _ hu.hasFDerivAt
  · rw [fderiv_zero_of_not_differentiableAt hu, norm_zero]; positivity

lemma derivative_cost_bound (s₀ s₁ s₂ : ℝ) (hs : s₀ < s₁) (hss : s₁ < s₂)
    (hL : 0 ≤ L) (h : FreeSites S.pins → ℝ) :
    jacobianCost (fderiv ℝ (S.shift s₀ s₁) h) ≤
      ((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ∑ x ∈ localSites S.graph S.ground, (S.H s₂ x h : ℝ)^3 := by
  classical
  have hd : 0 < s₁-s₀ := sub_pos.mpr hs
  by_cases hu : DifferentiableAt ℝ (S.shift s₀ s₁) h
  · apply (freeShift_derivative_cost S.active S.ground S.pins S.boundary S.prescribed h
      s₀ s₁ s₂ (L/n) D hs hss (by positivity) S.prescribed_ground
      (fun x y hh => S.prescribed_gradient x y hh.1) S.active_degree _ hu.hasFDerivAt).trans
    apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
    calc
      _ ≤ ∑ x : FreeSites S.pins, if (x:V) ∈ localSites S.graph S.ground then (S.H s₂ x h : ℝ)^3 else 0 := by
        apply Finset.sum_le_sum; intro x _
        by_cases hx : (x:V) ∈ S.ground
        · simp only [ite_eq_left hx]; split_ifs <;> positivity
        · simp only [ite_eq_right hx, ite_eq_left (S.mem_local_of_not_ground hx)]
          exact le_rfl
      _ ≤ ∑ x : V, if x ∈ localSites S.graph S.ground then (S.H s₂ x h : ℝ)^3 else 0 := by
        rw [← Finset.sum_subtype (Finset.univ.filter fun x : V => x ∉ S.pins) (by simp)
          (fun x => if x ∈ localSites S.graph S.ground then (S.H s₂ x h : ℝ)^3 else 0)]
        exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (by intros; split_ifs <;> positivity)
      _ = ∑ x ∈ localSites S.graph S.ground, (S.H s₂ x h : ℝ)^3 := by
        rw [← Finset.sum_filter]
        congr 1
        ext x; simp

  · rw [fderiv_zero_of_not_differentiableAt hu]
    simp only [jacobianCost, asMatrix_apply, zero_apply,
      Finset.sum_const_zero, norm_zero, mul_zero]
    positivity

lemma derivative_integrable (s₀ s₁ : ℝ) (hs : s₀ < s₁) (hM : 0 ≤ M)
    (F : ((FreeSites S.pins → ℝ) →L[ℝ] (FreeSites S.pins → ℝ)) → ℝ) (hF : Continuous F) :
    Integrable (fun h => F (fderiv ℝ (S.shift s₀ s₁) h)) S.law :=
  continuous_integrable_of_bounded S.law _ (measurable_fderiv ℝ _) _
    (fun _h => norm_fderiv_le_of_lipschitz ℝ (S.shift_lipschitz s₀ s₁ hs hM)) F hF

lemma divergence_square_identity (s₀ s₁ : ℝ) (hs : s₀ < s₁) (hs₀ : 0 < s₀) (hM : 0 ≤ M) :
    (∫ h, (asMatrix (fderiv ℝ (S.shift s₀ s₁) h)).trace^2 ∂S.law) =
      ∫ h, (asMatrix (fderiv ℝ (S.shift s₀ s₁) h * fderiv ℝ (S.shift s₀ s₁) h)).trace ∂S.law := by
  have hid := (freeShift_divergence_identities S.graph S.active S.ground S.pins S.walls
    S.pins_ground S.walls_ground (fun _ _ hh => S.active_or_ground hh)
    S.boundary S.prescribed S.intervals s₀ s₁ M hs hs₀ hM S.prescribed_bound
    S.polytope_measurable S.polytope_finite).2
  change ∫ h, _ ∂((volume S.polytope)⁻¹ • volume.restrict S.polytope) =
    ∫ h, _ ∂((volume S.polytope)⁻¹ • volume.restrict S.polytope)
  rw [MeasureTheory.integral_smul_measure, MeasureTheory.integral_smul_measure]
  exact congrArg (fun r : ℝ => (volume S.polytope)⁻¹.toReal • r) hid

lemma trace_square_le_cost_integral (s₀ s₁ : ℝ) (hs : s₀ < s₁)
    (hs₀ : 0 < s₀) (hM : 0 ≤ M) :
    (∫ h, (asMatrix (fderiv ℝ (S.shift s₀ s₁) h)).trace^2 ∂S.law) ≤
      ∫ h, jacobianCost (fderiv ℝ (S.shift s₀ s₁) h) ∂S.law := by
  rw [S.divergence_square_identity s₀ s₁ hs hs₀ hM]
  apply integral_mono (S.derivative_integrable s₀ s₁ hs hM _
    (continuous_trace.comp (continuous_id.mul continuous_id)))
      (S.derivative_integrable s₀ s₁ hs hM _ continuous_jacobianCost)
  intro h
  let A := fderiv ℝ (S.shift s₀ s₁) h
  have hb := trace_sandwich_bound A 1
  rw [mul_one] at hb
  calc
    _ ≤ |(asMatrix (A*A)).trace| := le_abs_self _
    _ ≤ ‖(1 : (FreeSites S.pins → ℝ) →L[ℝ] (FreeSites S.pins → ℝ))‖ * jacobianCost A := hb
    _ ≤ 1 * jacobianCost A := mul_le_mul_of_nonneg_right ContinuousLinearMap.norm_id_le (jacobianCost_nonneg A)
    _ = _ := one_mul _

lemma cost_integral_bound (s₀ s₁ s₂ : ℝ) (hs : s₀ < s₁) (hss : s₁ < s₂) (hstar : s₂ ≤ sstar)
    (hL : 0 ≤ L) (hM : 0 ≤ M) (hB : 0 < B) (hρ : ρ ≤ 1)
    (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2) :
    (∫ h, jacobianCost (fderiv ℝ (S.shift s₀ s₁) h) ∂S.law) ≤
      ((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ((localSites S.graph S.ground).card : ℝ) * boxMoment B 3 := by
  have hi : Integrable (fun h => ∑ x ∈ localSites S.graph S.ground, (S.H s₂ x h : ℝ)^3) S.law :=
    integrable_finsetSum _ (fun x _ => S.H_integrable s₂ x 3)
  calc
    _ ≤ ∫ h, ((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ∑ x ∈ localSites S.graph S.ground, (S.H s₂ x h : ℝ)^3 ∂S.law := by
      exact integral_mono (S.derivative_integrable s₀ s₁ hs hM _ continuous_jacobianCost)
        (hi.const_mul _) (S.derivative_cost_bound s₀ s₁ s₂ hs hss hL)
    _ = ((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ∑ x ∈ localSites S.graph S.ground, ∫ h, (S.H s₂ x h : ℝ)^3 ∂S.law := by
      rw [MeasureTheory.integral_const_mul, integral_finsetSum _ (fun x _ => S.H_integrable s₂ x 3)]
    _ ≤ ((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ∑ x ∈ localSites S.graph S.ground, boxMoment B 3 := by
      apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
      exact Finset.sum_le_sum (fun x _ => S.H_moment s₂ hstar hB hρ hsparse x 3)
    _ = _ := by simp only [Finset.sum_const, nsmul_eq_mul]; ring

lemma uniform_moment_bound (s₀ s₁ s₂ : ℝ) (hs₀ : 0 < s₀) (hs : s₀ < s₁)
    (hss : s₁ < s₂) (hstar : s₂ ≤ sstar) (hn : 0 < n)
    (hL : 0 ≤ L) (hM : 0 ≤ M) (hB : 0 < B) (hρ : ρ ≤ 1)
    (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2) :
    (∫ h, (asMatrix (fderiv ℝ (S.shift s₀ s₁) h)).trace^2 +
      jacobianCost (fderiv ℝ (S.shift s₀ s₁) h) ∂S.law) ≤
      2 * ((s₁-s₀)⁻¹ * (4*D*L))^2 * N * boxMoment B 3 := by
  rw [integral_add (S.derivative_integrable s₀ s₁ hs hM (fun A => (asMatrix A).trace^2) (continuous_trace.pow 2))
    (S.derivative_integrable s₀ s₁ hs hM _ continuous_jacobianCost)]
  have hc := S.cost_integral_bound s₀ s₁ s₂ hs hss hstar hL hM hB hρ hsparse
  have ht := S.trace_square_le_cost_integral s₀ s₁ hs hs₀ hM
  have hb : 0 ≤ boxMoment B 3 := boxMoment_nonneg B 3
  have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne'
  calc
    _ ≤ 2 * (((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * ((localSites S.graph S.ground).card : ℝ) * boxMoment B 3) := by linarith
    _ ≤ 2 * (((s₁-s₀)⁻¹ * (4*D*(L/n)))^2 * (N*(n:ℝ)^2) * boxMoment B 3) := by
      gcongr
      exact S.vertex_count
    _ = _ := by field_simp

end FeasibleShift.ShiftData

open Filter

namespace FeasibleShift

open Filter

theorem feasible_shifts (D Db B : ℕ) (ρ : ENNReal) (s₀ s₁ s₂ sstar L M N p : ℝ)
    (hB : 0 < B) (hρ : ρ ≤ 1) (hsparse : (Db : ENNReal)^2 * ρ ≤ 1/2)
    (hs₀ : 0 < s₀) (hs : s₀ < s₁) (hss : s₁ < s₂) (hstar : s₂ < sstar)
    (hL : 0 ≤ L) (hM : 0 ≤ M) (hN : 0 ≤ N) (hp : 0 < p) :
    ∃ c : ℝ, 0 < c ∧ ∃ n₀ : ℕ,
      Tendsto (fun n : ℕ => (L / n) * (n : ℝ)^(1/8 : ℝ)) atTop (nhds 0) ∧
      ∀ (n : ℕ), n₀ ≤ n → ∀ (V : Type u) [Fintype V] [DecidableEq V]
        (W : Type v) [Fintype W] [DecidableEq W]
        (S : ShiftData (V := V) W n D Db B ρ sstar L M N)
        (E : Set (FreeSites S.pins → ℝ)), MeasurableSet E → p ≤ S.law.real E →
        ∃ E' : Set (FreeSites S.pins → ℝ), MeasurableSet E' ∧ E' ⊆ E ∧
          p/2 ≤ S.law.real E' ∧ Set.InjOn (S.map s₀ s₁) E' ∧
          (S.map s₀ s₁) '' E' ⊆ S.polytope ∧ MeasurableSet ((S.map s₀ s₁) '' E') ∧
          (∀ h ∈ E', ‖S.map s₀ s₁ h - h - (fun x : FreeSites S.pins => S.prescribed x)‖ ≤
            (L / n) * (n : ℝ)^(1/8 : ℝ)) ∧ c ≤ S.law.real ((S.map s₀ s₁) '' E') := by
  classical
  let C : ℝ := 2 * ((s₁-s₀)⁻¹ * (4*D*L))^2 * N * SparseClusters.boxMoment B 3
  have hC : 0 ≤ C := by
    dsimp [C]
    exact mul_nonneg (mul_nonneg (mul_nonneg (by norm_num) (sq_nonneg _)) hN)
      (SparseClusters.boxMoment_nonneg B 3)
  let K : ℝ := 1+4*C/p
  have hK : 1 ≤ K := by
    have hh : 0 ≤ 4*C/p := by positivity
    dsimp [K]; linarith
  have hKpos : 0 < K := by linarith
  have hCK : C/K ≤ p/4 := by
    apply (div_le_iff₀ hKpos).mpr
    have he : p/4*(4*C/p) = C := by field_simp
    have hm := mul_le_mul_of_nonneg_left (show 4*C/p ≤ K by dsimp [K]; linarith)
      (show 0 ≤ p/4 by positivity)
    linarith
  obtain ⟨n₀, hn₀⟩ := (small_parameter_eventually D s₀ s₁ s₂ L
    (N*SparseClusters.boxMoment B 32) p hs₀ hs hss hp).exists_forall_of_atTop
  refine ⟨Real.exp (-2*K)*p/2, by positivity, n₀,
    scaled_radius_tendsto L (1/8) (by norm_num), ?_⟩
  intro n hn V iV dV W iW dW S E hE hEp
  obtain ⟨hnpos, hfeas, hbuf, hnorm, htail⟩ := hn₀ n hn
  let R : ℝ := (n:ℝ)^(1/8:ℝ)
  have hR : 1 ≤ R := Real.one_le_rpow (by exact_mod_cast hnpos) (by norm_num)
  have hRpos : 0 < R := by linarith
  have hj := S.map_injective s₀ s₁ s₂ R hs hss.le hL (by linarith) hbuf
    (hnorm.trans_lt (by norm_num))
  have hm := S.uniform_moment_bound s₀ s₁ s₂ hs₀ hs hss hstar.le hnpos hL hM hB hρ hsparse
  have hb : S.law.real (S.good s₂ R)ᶜ ≤ p/4 := by
    calc
      _ ≤ ((localSites S.graph S.ground).card : ℝ) * SparseClusters.boxMoment B 32 / R^32 :=
        S.bad_good_bound s₂ R hstar.le hB hρ hsparse hR 32 (by norm_num)
      _ ≤ (N*(n:ℝ)^2)*SparseClusters.boxMoment B 32 / R^32 := by
        apply div_le_div_of_nonneg_right _ (by positivity)
        exact mul_le_mul_of_nonneg_right S.vertex_count (SparseClusters.boxMoment_nonneg B 32)
      _ = (N*SparseClusters.boxMoment B 32)*(n:ℝ)^2 / R^32 := by ring
      _ ≤ p/4 := htail
  obtain ⟨E', hEm, hsub, hmass, hinj, himage, himagem, himagep⟩ :=
    TangentialJacobian.event_volume_of_moments S.polytope (S.good s₂ R)
      S.polytope_measurable (S.good_measurable s₂ R) S.polytope_positive S.polytope_finite
      (S.shift s₀ s₁) _ (S.shift_lipschitz s₀ s₁ hs hM) hj
      (fun h hh => S.map_feasible s₀ s₁ s₂ R hs hss.le hL hfeas h hh.1 hh.2)
      (fun h hh => (S.derivative_on_good s₀ s₁ s₂ R hs hss hL hRpos.le h hh).trans hnorm)
      C p K hp hK hm hCK hb E hE hEp
  refine ⟨E', hEm, fun h hh => (hsub hh).1.1, hmass, hinj, himage, himagem, ?_, himagep⟩
  intro h hh
  exact S.approximation_on_good s₀ s₁ s₂ R hs hss.le hL hRpos.le h (hsub hh).2

end FeasibleShift

end OAI