import Mathlib
import OAI.Geometry.Cannon.Flows.Subdivision

namespace OAI

section
section
section
noncomputable section
section
section
section
section
section
section
open Set Finset MeasureTheory Filter

namespace CannonPairCost

attribute [local instance] Classical.propDecidable

lemma sum_measure_le_multiplicity {X I : Type*} [MeasurableSpace X]
    (μ : Measure X) [IsFiniteMeasure μ] (s : Finset I) (B : I → Set X)
    (hm : ∀ i ∈ s, MeasurableSet (B i)) {M : ℝ}
    (hM : ∀ x, (s.filter (fun i => x ∈ B i)).card ≤ M) :
    ∑ i ∈ s, μ.real (B i) ≤ M * μ.real univ := by
  classical
  have hint : ∀ i ∈ s, Integrable ((B i).indicator (fun _ => (1 : ℝ))) μ := by
    intro i hi
    exact (integrable_const 1).indicator (hm i hi)
  have hid : ∀ x, (∑ i ∈ s, (B i).indicator (fun _ => (1 : ℝ)) x) ≤ M := by
    intro x
    simpa only [Set.indicator_apply, Finset.sum_boole] using hM x
  have h := integral_mono (integrable_finsetSum s hint) (integrable_const M) hid
  rw [integral_finsetSum s hint, integral_const] at h
  have heq : (∑ i ∈ s, ∫ x, (B i).indicator (fun _ => (1 : ℝ)) x ∂μ) =
      ∑ i ∈ s, μ.real (B i) := by
    apply Finset.sum_congr rfl
    intro i hi
    rw [integral_indicator_const _ (hm i hi)]
    simp
  rw [heq] at h
  simpa only [smul_eq_mul, mul_comm] using h

theorem finite_pair_bound {X I P : Type*} [MeasurableSpace X]
    (μ : Measure X) [IsFiniteMeasure μ] (pairs : Finset P)
    (pay : P → I) (B : P → Set X) (Δ weight : I → ℝ)
    (hm : ∀ p ∈ pairs, MeasurableSet (B p))
    {c A Pstar M : ℝ} (hc : 0 ≤ c) (hA : 0 ≤ A) (hP : 0 ≤ Pstar)
    (hweight : ∀ p ∈ pairs, Pstar ≤ weight (pay p))
    (hgap : ∀ p ∈ pairs, A * weight (pay p) ≤ Δ (pay p))
    (hcost : ∀ p ∈ pairs, c * Δ (pay p)^2 ≤ μ.real (B p))
    (hmult : ∀ x, (pairs.filter (fun p => x ∈ B p)).card ≤ M) :
    (pairs.card : ℝ) * c * A^2 * Pstar^2 ≤ M * μ.real univ := by
  have hlocal : ∀ p ∈ pairs, c * A^2 * Pstar^2 ≤ μ.real (B p) := by
    intro p hp
    have h₁ := mul_le_mul_of_nonneg_left (hweight p hp) hA
    have h₂ := h₁.trans (hgap p hp)
    have h₃ : (A * Pstar)^2 ≤ Δ (pay p)^2 :=
      sq_le_sq₀ (mul_nonneg hA hP) (le_trans (mul_nonneg hA hP) h₂) |>.mpr h₂
    calc
      _ = c * (A * Pstar)^2 := by ring
      _ ≤ c * Δ (pay p)^2 := mul_le_mul_of_nonneg_left h₃ hc
      _ ≤ _ := hcost p hp
  calc
    _ = ∑ p ∈ pairs, c * A^2 * Pstar^2 := by simp; ring
    _ ≤ ∑ p ∈ pairs, μ.real (B p) := Finset.sum_le_sum hlocal
    _ ≤ _ := sum_measure_le_multiplicity μ pairs B hm hmult

lemma cost_comparison {N F c A Pstar M mass η k : ℝ}
    (hc : 0 ≤ c) (_hA : 0 ≤ A) (hP : 0 ≤ Pstar) (hη : 0 ≤ η)
    (hN : 0 ≤ N) (hk : 0 < k)
    (hfar : η * N^2 ≤ F) (hclass : 1 / k ≤ N * Pstar)
    (hbound : F * c * A^2 * Pstar^2 ≤ M * mass) :
    η * c * A^2 ≤ M * mass * k^2 := by
  have hh : (1 / k)^2 ≤ (N * Pstar)^2 :=
    (sq_le_sq₀ (by positivity) (mul_nonneg hN hP)).mpr hclass
  have hlow : η * c * A^2 * (1 / k)^2 ≤ F * c * A^2 * Pstar^2 := by
    calc
      _ ≤ η * c * A^2 * (N * Pstar)^2 :=
        mul_le_mul_of_nonneg_left hh (by positivity)
      _ = (η * N^2) * c * A^2 * Pstar^2 := by ring
      _ ≤ _ := by gcongr
  have h := mul_le_mul_of_nonneg_right (hlow.trans hbound) (sq_nonneg k)
  field_simp at h
  nlinarith

theorem not_frequently_exp_le_quadratic {c : ℝ} (hc : 0 < c)
    (C k₀ D : ℝ) :
    ¬ ∃ᶠ n : ℕ in atTop,
      Real.exp (c * n) ≤ C * (k₀ + D * n)^2 := by
  have h₀ := (isLittleO_pow_exp_pos_mul_atTop 0 hc).const_mul_left (C * k₀^2)
  have h₁ := (isLittleO_pow_exp_pos_mul_atTop 1 hc).const_mul_left (2*C*k₀*D)
  have h₂ := (isLittleO_pow_exp_pos_mul_atTop 2 hc).const_mul_left (C*D^2)
  have hpoly : (fun x : ℝ => C * (k₀ + D * x)^2) =o[atTop]
      (fun x => Real.exp (c * x)) := by
    have hsum := (h₀.add h₁).add h₂
    have heq : (fun x : ℝ => C * k₀^2 * x^0 + (2*C*k₀*D)*x^1 +
          (C*D^2)*x^2) = (fun x : ℝ => C * (k₀ + D*x)^2) := by
      funext x
      ring
    change (fun x : ℝ => C * k₀^2 * x^0 + (2*C*k₀*D)*x^1 +
      (C*D^2)*x^2) =o[atTop] (fun x => Real.exp (c*x)) at hsum
    rw [heq] at hsum
    exact hsum
  have hevent := hpoly.bound (show (0 : ℝ) < 1/2 by norm_num)
  have hevent' := tendsto_natCast_atTop_atTop.eventually hevent
  intro hfreq
  obtain ⟨n, hn, hn'⟩ := (hfreq.and_eventually hevent').exists
  have hepos := Real.exp_pos (c * (n : ℝ))
  simp only [Real.norm_eq_abs, abs_of_pos hepos] at hn'
  have hle := le_abs_self (C * (k₀ + D * (n : ℝ))^2)
  linarith

end CannonPairCost

namespace CannonPairCost

open Metric

theorem separated_level_energy {X ι : Type*} [MetricSpace X]
    [MeasurableSpace X] [BorelSpace X] [Fintype ι]
    (μ : Measure X) [IsFiniteMeasure μ] (x : ι → X) (Δ : ι → ℝ)
    (r H C E : ℝ) (hr : 0 < r) (hh : 2*C < H) (hE : 0 ≤ E)
    (hsep : ∀ i j, i ≠ j → H*r ≤ dist (x i) (x j))
    (hloc : ∀ i, (Δ i)^2 ≤ E*μ.real (closedBall (x i) (C*r))) :
    ∑ i, (Δ i)^2 ≤ E*μ.real Set.univ := by
  classical
  have hmul (z : X) : ((univ.filter (fun i => z ∈ closedBall (x i) (C*r))).card : ℝ) ≤ 1 := by
    have hc : (univ.filter (fun i => z ∈ closedBall (x i) (C*r))).card ≤ 1 := by
      apply card_le_one.mpr
      intro i hi j hj
      by_contra hij
      have hd := hsep i j hij
      have hi' := mem_closedBall.mp (mem_filter.mp hi).2
      have hj' := mem_closedBall.mp (mem_filter.mp hj).2
      have ht := dist_triangle (x i) z (x j)
      rw [dist_comm (x i) z] at ht
      have hh' := mul_lt_mul_of_pos_right hh hr
      linarith
    exact_mod_cast hc
  have hm := sum_measure_le_multiplicity μ univ (fun i => closedBall (x i) (C*r))
    (fun _ _ => isClosed_closedBall.measurableSet) hmul
  calc
    _ ≤ ∑ i, E*μ.real (closedBall (x i) (C*r)) := sum_le_sum (fun i _ => hloc i)
    _ = E*∑ i, μ.real (closedBall (x i) (C*r)) := (mul_sum ..).symm
    _ ≤ _ := mul_le_mul_of_nonneg_left (by simpa only [one_mul] using hm) hE

end CannonPairCost

end

namespace CannonNode.SourceConstruction

open Set Metric Finset Filter Topology CannonFlow

attribute [local instance] Classical.propDecidable

variable {X : Type*} [MetricSpace X] {f : X → ℝ} {x₀ : X}
  {ε ell c₀ A B H ρ : ℝ} {qdim n : ℕ}

variable (S : SourceConstruction f x₀ ε ell c₀ A B H ρ qdim n)

abbrev state (g : ℕ) := (S.rule.generation S.root g).state

abbrev good (v : SourceNode f x₀ ε ell c₀ (B+1) S.kmin) :=
  LiteralGood f (S.Y v) c₀ (radius ell (v.depth+160*(qdim+1)*n)) v.a v.b S.κ

noncomputable def flow := S.rule.flow S.root S.good

abbrev center (g : ℕ) (i : Fin (S.flow.size g)) := (S.state g i).center

abbrev len (g : ℕ) (i : Fin (S.flow.size g)) := (S.state g i).length

abbrev scale (g : ℕ) := radius ell (S.kmin+160*(qdim+1)*n*g)

abbrev step (g : ℕ) (i : Fin (S.flow.size (g+1))) := S.rule.probOf (S.rule.generation S.root g) i

lemma state_depth (g : ℕ) (i : Fin (S.flow.size g)) :
    (S.state g i).depth=S.kmin+160*(qdim+1)*n*g := by
  exact (S.rule.generation_depth S.root SourceNode.depth _ S.child_depth g i).trans
    (by rw [S.root_depth])

lemma scale_succ (g : ℕ) : S.scale (g+1)=radius ell (160*(qdim+1)*n)*S.scale g := by
  rw [scale,Nat.mul_succ,← Nat.add_assoc,radius_add]

lemma len_pos (g : ℕ) (i : Fin (S.flow.size g)) : 0 < S.len g i := (S.state g i).length_pos

lemma root_length (i : Fin (S.flow.size 0)) : S.len 0 i=S.root.length := rfl

lemma step_pos (g : ℕ) (i : Fin (S.flow.size (g+1))) : 0 < S.step g i := S.rule.prob_pos _ _

lemma weight_step (g : ℕ) (i : Fin (S.flow.size (g+1))) :
    S.flow.weight (g+1) i=S.step g i*S.flow.weight g (S.flow.parent g i) := rfl

lemma step_linear (g : ℕ) (i : Fin (S.flow.size (g+1))) :
    S.step g i*S.len g (S.flow.parent g i) ≤ Real.exp (-ell*n)*S.len (g+1) i :=
  S.child_linear _ _

lemma step_nested (g : ℕ) (i : Fin (S.flow.size (g+1))) :
    S.len (g+1) i ≤ S.len g (S.flow.parent g i) := S.child_length_le _ _

lemma weight_linear (g : ℕ) (i : Fin (S.flow.size g)) :
    S.root.length*S.flow.weight g i ≤ (Real.exp (-ell*n))^g*S.len g i :=
  S.flow.linear_transition_product S.step S.len S.root.length_pos.le (Real.exp_pos _).le
    S.root_length (fun g i => (S.step_pos g i).le) S.weight_step S.step_linear g i

lemma weight_conditional (g m : ℕ) (i : Fin (S.flow.size (g+m))) :
    S.flow.weight (g+m) i ≤ (Real.exp (-ell*n))^m*
      S.flow.weight g (S.flow.ancestor g m i) := by
  apply S.flow.conditional_weight (Real.exp_pos _).le
  intro j v
  have h := (S.step_linear j v).trans (mul_le_mul_of_nonneg_left (S.step_nested j v)
    (Real.exp_pos _).le)
  have hp : S.step j v ≤ Real.exp (-ell*n) :=
    (mul_le_mul_iff_left₀ (S.len_pos j (S.flow.parent j v))).mp h
  rw [S.weight_step]
  exact mul_le_mul_of_nonneg_right hp (S.flow.nonneg _ _)

lemma center_step (g : ℕ) (i : Fin (S.flow.size (g+1))) :
    dist (S.center (g+1) i) (S.center g (S.flow.parent g i)) ≤ (B+1)*S.scale g := by
  have h := S.child_move ((S.rule.generation S.root g).state (S.flow.parent g i))
    ((Fintype.equivFin (S.rule.Offspring (S.rule.generation S.root g))).symm i).2
  change dist (S.center (g+1) i) (S.center g (S.flow.parent g i)) ≤
    (B+1)*radius ell (S.state g (S.flow.parent g i)).depth at h
  rwa [S.state_depth] at h

lemma centers_separated (hθ : radius ell (160*(qdim+1)*n) < 1/4)
    (hB : 0 ≤ B+1) (hH : 4*(B+1) < H) :
    ∀ g i j, i ≠ j → H*S.scale g ≤ dist (S.center g i) (S.center g j) := by
  apply S.flow.centers_separated S.center S.scale (B+1) H (radius ell (160*(qdim+1)*n))
    (fun g => (radius_pos _ _).le) S.scale_succ
  · have hHp : 0 < H := by linarith only [hB,hH]
    nlinarith only [hθ,hB,hH,hHp]
  · intro i j hij
    change Fin 1 at i j
    exact (hij (Subsingleton.elim (α := Fin 1) i j)).elim
  · exact S.center_step
  · intro g i j hp hij
    have hs := S.rule.generation_siblings S.root SourceNode.center
      (fun v => H*radius ell (v.depth+160*(qdim+1)*n))
      (fun v i j hij => (S.child_sep v i j hij).le) g i j hp hij
    change H*radius ell ((S.state g (S.flow.parent g i)).depth+160*(qdim+1)*n) ≤
      dist (S.center (g+1) i) (S.center (g+1) j) at hs
    rw [S.state_depth] at hs
    simpa only [scale,Nat.mul_succ,Nat.add_assoc] using hs

lemma descendant_displacement (hθ : radius ell (160*(qdim+1)*n) < 1/4)
    (hB : 0 ≤ B+1) (g m : ℕ) (i : Fin (S.flow.size (g+m))) :
    dist (S.center (g+m) i) (S.center g (S.flow.ancestor g m i)) ≤ 2*(B+1)*S.scale g := by
  have h := S.flow.descendant_displacement S.center S.scale (B+1) (2*(B+1))
    (radius ell (160*(qdim+1)*n)) (fun g => (radius_pos _ _).le)
    (by nlinarith only [hθ,hB]) S.scale_succ S.center_step g m i
  have hp := mul_nonneg (by linarith only [hB] : 0 ≤ 2*(B+1)) (show 0 ≤ S.scale (g+m) from (radius_pos _ _).le)
  linarith only [h,hp]

lemma step_quadratic (g : ℕ) (i : Fin (S.flow.size (g+1))) :
    S.step g i*Real.exp ((160*(qdim+1)*ell*n)*
      (if S.flow.good g (S.flow.parent g i) then -(1/20:ℝ) else 1/2))*
      (S.len g (S.flow.parent g i))^2 ≤ (S.len (g+1) i)^2 := by
  let v := S.state g (S.flow.parent g i)
  let j := ((Fintype.equivFin (S.rule.Offspring (S.rule.generation S.root g))).symm i).2
  have h := S.child_quadratic v j
  have he (t : ℝ) : Real.exp (-t)*Real.exp t=1 := by rw [← Real.exp_add]; simp

  by_cases hg : S.good v
  · simp only [ite_eq_left hg] at h
    change S.step g i*S.len g (S.flow.parent g i)^2 ≤
      Real.exp (8*(qdim+1)*ell*n)*S.len (g+1) i^2 at h
    have hh := mul_le_mul_of_nonneg_left h (Real.exp_pos (-(8*(qdim+1)*ell*n))).le
    have heq : (160*(qdim+1)*ell*(n:ℝ))*(-(1/20:ℝ))=-(8*(qdim+1)*ell*n) := by ring
    change S.step g i*Real.exp ((160*(qdim+1)*ell*n)*(if S.good v then _ else _))*_ ≤ _
    rw [ite_eq_left hg,heq]
    calc
      _ = Real.exp (-(8*(qdim+1)*ell*n))*(S.step g i*S.len g (S.flow.parent g i)^2) := by ring
      _ ≤ _ := hh
      _ = _ := by rw [← mul_assoc,he,one_mul]
  · simp only [ite_eq_right hg] at h
    change S.step g i*S.len g (S.flow.parent g i)^2 ≤
      Real.exp (-((80*(qdim+1):ℝ)*ell*n))*S.len (g+1) i^2 at h
    have hh := mul_le_mul_of_nonneg_left h (Real.exp_pos ((80*(qdim+1):ℝ)*ell*n)).le
    have heq : (160*(qdim+1)*ell*(n:ℝ))*(1/2:ℝ)=(80*(qdim+1):ℝ)*ell*n := by ring
    change S.step g i*Real.exp ((160*(qdim+1)*ell*n)*(if S.good v then _ else _))*_ ≤ _
    rw [ite_eq_right hg,heq]
    calc
      _ = Real.exp ((80*(qdim+1):ℝ)*ell*n)*(S.step g i*S.len g (S.flow.parent g i)^2) := by ring
      _ ≤ _ := hh
      _ = _ := by rw [← mul_assoc, mul_comm (Real.exp _),he,one_mul]

end CannonNode.SourceConstruction

namespace CannonNode.SourceConstruction

open Set Metric Finset MeasureTheory CannonFlow

attribute [local instance] Classical.propDecidable

variable {X : Type*} [MetricSpace X] {f : X → ℝ} {x₀ : X}
  {ε ell c₀ A B H ρ : ℝ} {qdim n : ℕ}

variable (S : SourceConstruction f x₀ ε ell c₀ A B H ρ qdim n)

lemma weight_bound (g : ℕ) (i : Fin (S.flow.size g)) :
    S.flow.weight g i ≤ (Real.exp (-ell*n))^g := by
  have hlen : S.len g i ≤ S.root.length :=
    S.rule.generation_property S.root (fun v => v.length ≤ S.root.length) le_rfl
      (fun v j hv => (S.child_length_le v j).trans hv) g i
  have h := (S.weight_linear g i).trans
    (mul_le_mul_of_nonneg_left hlen (pow_nonneg (Real.exp_pos _).le g))
  rw [mul_comm ((Real.exp (-ell*n))^g) S.root.length] at h
  exact (mul_le_mul_iff_right₀ S.root.length_pos).mp h

lemma len_lt_one (g : ℕ) (i : Fin (S.flow.size g)) : S.len g i < 1 := by
  let v := S.state g i
  change v.b-v.a < 1
  linarith only [v.apos,v.bone]

lemma center_mem (hB : 0 ≤ B+1) (g : ℕ) (i : Fin (S.flow.size g)) :
    S.center g i ∈ closedBall x₀ ε := (S.state g i).center_mem hB

lemma level_energy [ProperSpace X] [MeasurableSpace X] [BorelSpace X]
    (μ : Measure X) [IsFiniteMeasure μ] (Cμ E : ℝ) (hE : 0 ≤ E)
    (hB : 0 ≤ B+1) (hc₀ : 0 ≤ c₀)
    (hθ : radius ell (160*(qdim+1)*n) < 1/4) (hH : 4*(B+1) < H)
    (hHμ : 2*(Cμ*c₀) < H)
    (hf : ∀ x ∈ closedBall x₀ ε, ∀ r : ℝ, 0 < r → r ≤ ρ →
      ContinuousOn f (closedBall x (c₀*r)))
    (hpair : ∀ x ∈ closedBall x₀ ε, ∀ r : ℝ, 0 < r → r ≤ ρ →
      ∀ y ∈ closedBall x (c₀*r), ∀ z ∈ closedBall x (c₀*r),
        (f y-f z)^2 ≤ E*μ.real (closedBall x (Cμ*(c₀*r)))) :
    ∀ g, ∑ i, (S.len g i)^2 ≤ E*μ.real univ := by
  intro g
  apply CannonPairCost.separated_level_energy μ (S.center g) (S.len g) (S.scale g) H
    (Cμ*c₀) E (radius_pos _ _) hHμ hE (S.centers_separated hθ hB hH g)
  intro i
  let v := S.state g i
  have hr : 0 < S.scale g := radius_pos _ _
  have hsmall : S.scale g ≤ ρ := by
    have hh := S.small v.depth v.lowerDepth
    simpa only [v,S.state_depth] using hh
  have hx := S.center_mem hB g i
  obtain ⟨⟨z,hz,hzv⟩,⟨y,hy,hyv⟩⟩ := ball_extrema (mul_nonneg hc₀ hr.le)
    (hf (S.center g i) hx (S.scale g) hr hsmall)
  have hs : lower f (S.center g i) (c₀*S.scale g) ≤ v.a ∧
      v.b ≤ upper f (S.center g i) (c₀*S.scale g) := by
    simpa only [v,S.state_depth] using v.straddle
  have hlen : S.len g i ≤ f y-f z := by
    change v.b-v.a ≤ _
    rw [hyv,hzv]
    linarith only [hs.1,hs.2]
  have hsq := pow_le_pow_left₀ (S.len_pos g i).le hlen 2
  have hp := hpair _ hx _ hr hsmall y hy z hz
  exact hsq.trans (by simpa only [mul_assoc] using hp)

theorem arbitrarily_late_good (hell : 0 < ell) (hn : 0 < n)
    (E : ℝ) (henergy : ∀ g, ∑ i, (S.len g i)^2 ≤ E) :
    ∀ N : ℕ, ∃ g ≥ N, (1/2:ℝ) ≤ S.flow.goodMass g := by
  apply S.flow.good_levels_of_transitions S.step S.len S.root.length_pos
    (show 0 < (160*(qdim+1):ℝ)*ell*n by positivity)
    S.root_length (fun g i => (S.step_pos g i).le) S.weight_step S.step_quadratic henergy

end CannonNode.SourceConstruction

end

section

section

section

section

open Set Metric Filter Topology

namespace CannonMagnification

theorem preimage_distance_bound {X : Type*} [MetricSpace X]
    (h : X ≃ₜ X) (x z₀ z : X) (r C L e d : ℝ)
    (hr : 0 < r) (hC : 0 ≤ C) (he : 0 < e) (hd : 0 < d)
    (hexp : Expansion h x r C L)
    (hdiam : ∀ y z : X, dist y z ≤ 1)
    (hz₀ : d ≤ dist x z₀) (hz : e ≤ dist z (h z₀)) :
    dist x (h.symm z) ≤ (C/(e*d))*r := by
  have hh := (hexp (h.symm z) z₀).1
  rw [h.apply_symm_apply] at hh
  have h₁ : e*dist x (h.symm z)*d ≤
      dist z (h z₀)*max r (dist x (h.symm z))*max r (dist x z₀) := by
    apply mul_le_mul
    · exact mul_le_mul hz (le_max_right _ _) dist_nonneg (dist_nonneg)
    · exact hz₀.trans (le_max_right _ _)
    · exact hd.le
    · positivity
  have h₂ : C*r*dist (h.symm z) z₀ ≤ C*r := by
    exact (mul_le_mul_of_nonneg_left (hdiam _ _) (mul_nonneg hC hr.le)).trans_eq (mul_one _)
  have hh' := h₁.trans (hh.trans h₂)
  have hh'' : dist x (h.symm z) ≤ (C*r)/(e*d) := by
    apply (le_div_iff₀ (mul_pos he hd)).mpr
    calc
      dist x (h.symm z)*(e*d) = e*dist x (h.symm z)*d := by ring
      _ ≤ C*r := hh'
  exact hh''.trans_eq (by ring)

theorem inverse_lipschitz_on_preimages {X : Type*} [MetricSpace X]
    (h : X ≃ₜ X) (x z w : X) (r C L B : ℝ)
    (hr : 0 < r) (hL : 0 ≤ L) (hexp : Expansion h x r C L)
    (hz : dist x (h.symm z) ≤ B*r) (hw : dist x (h.symm w) ≤ B*r) :
    dist (h.symm z) (h.symm w) ≤ (L*(max 1 B)^2)*r*dist z w := by
  have hb : 0 ≤ max 1 B := (by norm_num : (0:ℝ) ≤ 1).trans (le_max_left _ _)
  have hmax (v : X) (hv : dist x v ≤ B*r) : max r (dist x v) ≤ max 1 B*r := by
    apply max_le
    · simpa using mul_le_mul_of_nonneg_right (le_max_left (1:ℝ) B) hr.le
    · exact hv.trans (mul_le_mul_of_nonneg_right (le_max_right (1:ℝ) B) hr.le)
  have hh := (hexp (h.symm z) (h.symm w)).2
  rw [h.apply_symm_apply,h.apply_symm_apply] at hh
  have hprod : L*dist z w*max r (dist x (h.symm z))*max r (dist x (h.symm w)) ≤
      L*dist z w*(max 1 B*r)*(max 1 B*r) := by
    apply mul_le_mul
    · exact mul_le_mul_of_nonneg_left (hmax _ hz) (mul_nonneg hL dist_nonneg)
    · exact hmax _ hw
    · exact hr.le.trans (le_max_left _ _)
    · positivity
  have hh' : r*dist (h.symm z) (h.symm w) ≤ r*((L*(max 1 B)^2)*r*dist z w) :=
    (hh.trans hprod).trans_eq (by ring)
  exact (mul_le_mul_iff_right₀ hr).mp hh'

theorem image_ball_avoids_puncture {X : Type*} [MetricSpace X]
    (h : X ≃ₜ X) (x z₀ y : X) (r C L d : ℝ)
    (hr : 0 < r) (hL : 0 < L) (_hd : 0 < d) (hrd : r ≤ d/2)
    (hexp : Expansion h x r C L) (hdiam : ∀ y z : X, dist y z ≤ 1)
    (hz₀ : d ≤ dist x z₀) (hy : dist x y ≤ r) :
    d/(2*L) ≤ dist (h y) (h z₀) := by
  have hdone : d ≤ 1 := hz₀.trans (hdiam _ _)
  have hrone : r ≤ 1 := by linarith
  have hfar : d/2 ≤ dist y z₀ := by
    have hh := dist_triangle x y z₀
    linarith
  have hh := (hexp y z₀).2
  rw [max_eq_left hy] at hh
  have hmax : max r (dist x z₀) ≤ 1 := max_le hrone (hdiam _ _)
  have hbound : L*dist (h y) (h z₀)*r*max r (dist x z₀) ≤
      L*dist (h y) (h z₀)*r := by
    exact (mul_le_mul_of_nonneg_left hmax (by positivity)).trans_eq (mul_one _)
  have heq : dist y z₀ ≤ L*dist (h y) (h z₀) := by
    have hh' : r*dist y z₀ ≤ r*(L*dist (h y) (h z₀)) :=
      (hh.trans hbound).trans_eq (by ring)
    exact (mul_le_mul_iff_right₀ hr).mp hh'
  apply (div_le_iff₀ (mul_pos (by norm_num) hL)).mpr
  nlinarith

end CannonMagnification

end

namespace CannonMagnification

open Set Metric

def denominator {X : Type*} [MetricSpace X] (x : X) (R : ℝ) (y : X) : ℝ :=
  max R (dist x y)

lemma denominator_triangle {X : Type*} [MetricSpace X] (x y z : X) (R : ℝ) :
    denominator x R z ≤ denominator x R y+dist y z := by
  apply max_le
  · exact (le_max_left _ _).trans (le_add_of_nonneg_right dist_nonneg)
  · exact (dist_triangle x y z).trans (add_le_add (le_max_right _ _) le_rfl)

theorem puncture_bounds {X : Type*} [MetricSpace X] (h : X ≃ₜ X)
    (x z₀ : X) (R C L d : ℝ) (hR : 0 < R) (hC : 0 ≤ C) (hL : 0 < L)
    (hd : 0 < d) (hRone : R ≤ 1) (hz₀ : d ≤ dist x z₀)
    (hdiam : ∀ y z : X, dist y z ≤ 1) (hexp : Expansion h x R C L) :
    (∀ y, dist (h y) (h z₀)*denominator x R y ≤ (C/d)*R) ∧
    (∀ y, denominator x R y ≤ d/2 →
      R ≤ (2*L/d)*dist (h y) (h z₀)*denominator x R y) := by
  constructor
  · intro y
    have hh := (hexp y z₀).1
    have hm : dist (h y) (h z₀)*max R (dist x y)*d ≤
        dist (h y) (h z₀)*max R (dist x y)*max R (dist x z₀) :=
      mul_le_mul_of_nonneg_left (hz₀.trans (le_max_right _ _)) (by positivity)
    have ht : C*R*dist y z₀ ≤ C*R :=
      (mul_le_mul_of_nonneg_left (hdiam y z₀) (mul_nonneg hC hR.le)).trans_eq (mul_one _)
    have hh' := hm.trans (hh.trans ht)
    calc
      _ ≤ C*R/d := (le_div_iff₀ hd).mpr hh'
      _ = _ := by ring
  · intro y hy
    have hxy : dist x y ≤ d/2 := (le_max_right _ _).trans hy
    have hdist : d/2 ≤ dist y z₀ := by linarith only [dist_triangle x y z₀,hz₀,hxy]
    have hh := (hexp y z₀).2
    have hmax : max R (dist x z₀) ≤ 1 := max_le hRone (hdiam _ _)
    have hm : L*dist (h y) (h z₀)*max R (dist x y)*max R (dist x z₀) ≤
        L*dist (h y) (h z₀)*max R (dist x y) :=
      (mul_le_mul_of_nonneg_left hmax (by positivity)).trans_eq (mul_one _)
    have hdR := mul_le_mul_of_nonneg_left hdist hR.le
    have hh' := hdR.trans (hh.trans hm)
    calc
      R ≤ 2*(L*dist (h y) (h z₀)*max R (dist x y))/d :=
        (le_div_iff₀ hd).mpr (by linarith only [hh'])
      _ = _ := by dsimp [denominator]; ring

theorem cost_ball_geometry {X : Type*} [MetricSpace X] (h : X ≃ₜ X)
    (x p p' : X) (R C L U V cutoff A B S t : ℝ)
    (hR : 0 < R) (hC : 0 ≤ C) (hL : 0 ≤ L) (hU : 0 < U) (hV : 0 < V)
    (hA : 0 < A) (hB : 0 < B) (hS : 0 < S) (ht : 0 < t) (htone : t ≤ 1)
    (hexp : Expansion h x R C L)
    (hupper : ∀ y, dist (h y) p*denominator x R y ≤ U*R)
    (hlower : ∀ y, denominator x R y ≤ cutoff →
      R ≤ V*dist (h y) p*denominator x R y)
    (hscale : R = dist p' p*t)
    (hfar : 2*A*R ≤ dist p' p)
    (hlocal : U*t ≤ cutoff)
    (hcoef : 2*L*A*U^2 ≤ S)
    (hsmall : 2*V*B*S*t ≤ 1) :
    let z := h.symm p'
    let s := S*t^2
    h.symm '' closedBall p' (A*R) ⊆ closedBall z s ∧
    h '' closedBall z (B*s) ⊆ closedBall p' ((2*C*V^2*B*S)*R) ∧
    closedBall z (B*s) ⊆ closedBall x ((U+B*S)*t) := by
  dsimp only
  let z := h.symm p'
  let δ := dist p' p
  have hδ : 0 < δ := by
    change 0 < dist p' p
    nlinarith only [hscale,hR,ht,dist_nonneg (x:=p') (y:=p)]
  have hz : h z = p' := h.apply_symm_apply _
  have hDznon : 0 < denominator x R z := hR.trans_le (le_max_left _ _)
  have hDz : denominator x R z ≤ U*t := by
    have hh : δ*denominator x R z ≤ δ*(U*t) := by
      calc
        _ ≤ U*R := by simpa only [δ,hz] using hupper z
        _ = _ := by rw [hscale]; dsimp [δ]; ring
    exact (mul_le_mul_iff_right₀ hδ).mp hh
  have htDz : t ≤ V*denominator x R z := by
    have hh : δ*t ≤ δ*(V*denominator x R z) := by
      calc
        _ = R := hscale.symm
        _ ≤ V*dist (h z) p*denominator x R z := hlower z (hDz.trans hlocal)
        _ = _ := by rw [hz]; dsimp [δ]; ring
    exact (mul_le_mul_iff_right₀ hδ).mp hh
  have hrad : 2*(B*(S*t^2)) ≤ denominator x R z := by
    have hh := mul_le_mul_of_nonneg_right hsmall ht.le
    have hh' : V*(2*(B*(S*t^2))) ≤ V*denominator x R z := by
      calc
        _ ≤ t := by nlinarith only [hh]
        _ ≤ _ := htDz
    exact (mul_le_mul_iff_right₀ hV).mp hh'
  constructor
  · rintro y ⟨w,hw,rfl⟩
    let y := h.symm w
    have hy : h y = w := h.apply_symm_apply _
    have hwδ : δ/2 ≤ dist w p := by
      have hh := dist_triangle p' w p
      have hw' := mem_closedBall.mp hw
      rw [dist_comm w p'] at hw'
      dsimp [δ]
      linarith only [hh,hw',hfar]
    have hDy : denominator x R y ≤ 2*U*t := by
      have hDypos : 0 ≤ denominator x R y := hR.le.trans (le_max_left _ _)
      have hh : δ/2*denominator x R y ≤ U*(δ*t) := by
        calc
          _ ≤ dist w p*denominator x R y := mul_le_mul_of_nonneg_right hwδ hDypos
          _ ≤ U*R := by simpa only [hy] using hupper y
          _ = _ := by rw [hscale]
      apply (mul_le_mul_iff_right₀ hδ).mp
      nlinarith only [hh]
    have hh := (hexp y z).2
    change R*dist y z ≤ L*dist (h y) (h z)*denominator x R y*denominator x R z at hh
    rw [hy,hz] at hh
    have hw' := mem_closedBall.mp hw
    have hm : L*dist w p'*denominator x R y*denominator x R z ≤
        L*(A*R)*(2*U*t)*(U*t) := by
      apply mul_le_mul
      · apply mul_le_mul
        · exact mul_le_mul_of_nonneg_left hw' hL
        · exact hDy
        · exact hR.le.trans (le_max_left _ _)
        · positivity
      · exact hDz
      · exact hDznon.le
      · positivity
    have hh' : R*dist y z ≤ R*(2*L*A*U^2*t^2) :=
      (hh.trans hm).trans_eq (by ring)
    have hdist := (mul_le_mul_iff_right₀ hR).mp hh'
    apply mem_closedBall.mpr
    exact hdist.trans (mul_le_mul_of_nonneg_right hcoef (sq_nonneg _))
  constructor
  · rintro w ⟨y,hy,rfl⟩
    have hyz := mem_closedBall.mp hy
    have hDy : denominator x R z/2 ≤ denominator x R y := by
      have hh := denominator_triangle x y z R
      linarith only [hh,hyz,hrad]
    have htDy : t ≤ 2*V*denominator x R y := by
      have hh := mul_le_mul_of_nonneg_left hDy hV.le
      linarith only [hh,htDz]
    have htprod : t^2 ≤ 2*V^2*denominator x R y*denominator x R z := by
      calc
        t^2 = t*t := by ring
        _ ≤ (2*V*denominator x R y)*(V*denominator x R z) :=
          mul_le_mul htDy htDz ht.le (ht.le.trans htDy)
        _ = _ := by ring
    have hh := (hexp y z).1
    change dist (h y) (h z)*denominator x R y*denominator x R z ≤ C*R*dist y z at hh
    rw [hz] at hh
    have hdistnon := dist_nonneg (x:=h y) (y:=p')
    have hm := mul_le_mul_of_nonneg_left htprod hdistnon
    have hE := mul_le_mul_of_nonneg_right hh (by positivity : 0 ≤ 2*V^2)
    have hradE := mul_le_mul_of_nonneg_left hyz (by positivity : 0 ≤ 2*V^2*C*R)
    have hall : t^2*dist (h y) p' ≤ t^2*((2*C*V^2*B*S)*R) := by
      nlinarith only [hm,hE,hradE]
    exact mem_closedBall.mpr ((mul_le_mul_iff_right₀ (sq_pos_of_pos ht)).mp hall)
  · intro y hy
    have hyz := mem_closedBall.mp hy
    have hxy := dist_triangle x z y
    rw [dist_comm z y] at hxy
    have hxz : dist x z ≤ U*t := (le_max_right _ _).trans hDz
    have htsq : t^2 ≤ t := by nlinarith only [ht,htone]
    have hm := mul_le_mul_of_nonneg_left htsq (by positivity : 0 ≤ B*S)
    apply mem_closedBall.mpr
    rw [dist_comm]
    nlinarith only [hxy,hxz,hyz,hm]

end CannonMagnification

end

end
end
end
end
end
end
end
end
end
end

end OAI