import Mathlib

namespace OAI

/-! Balancing, collapsed circles and singular homology of conic blocks. -/

namespace AmbientMultiplicity.InnerGeometry
noncomputable section
open Filter Topology

 
def scaleTo (r : ℝ) (z : ℂ) : ℂ := (r / ‖z‖) • z

lemma scaleTo_zero (r : ℝ) : scaleTo r 0 = 0 := by
  simp [scaleTo]

lemma norm_scaleTo (r : ℝ) {z : ℂ} (hz : z ≠ 0) : ‖scaleTo r z‖ = ‖r‖ := by
  rw [scaleTo, norm_smul, norm_div, norm_norm,
    div_mul_cancel₀ _ (norm_ne_zero_iff.mpr hz)]

lemma norm_scaleTo_le (r : ℝ) (z : ℂ) : ‖scaleTo r z‖ ≤ ‖r‖ := by
  by_cases hz : z = 0
  · simp [hz, scaleTo]
  · rw [norm_scaleTo r hz]

lemma scaleTo_norm (z : ℂ) : scaleTo ‖z‖ z = z := by
  by_cases hz : z = 0
  · simp [hz, scaleTo]
  · simp [scaleTo, norm_ne_zero_iff.mpr hz]

 

lemma continuous_scaleTo {X : Type*} [TopologicalSpace X] {r : X → ℝ} {z : X → ℂ}
    (hr : Continuous r) (hz : Continuous z) (hzero : ∀ x, z x = 0 → r x = 0) :
    Continuous (fun x => scaleTo (r x) (z x)) := by
  rw [continuous_iff_continuousAt]
  intro x
  by_cases hx : z x = 0
  · change Tendsto (fun x => scaleTo (r x) (z x)) (𝓝 x)
      (𝓝 (scaleTo (r x) (z x)))
    rw [hx, scaleTo_zero]
    apply tendsto_zero_iff_norm_tendsto_zero.mpr
    apply squeeze_zero (fun _ => norm_nonneg _) (fun x => norm_scaleTo_le (r x) (z x))
    simpa [hzero x hx] using (hr.continuousAt (x := x)).norm.tendsto
  · exact (hr.continuousAt.div hz.continuousAt.norm
      (norm_ne_zero_iff.mpr hx)).smul hz.continuousAt

 
def discriminant (t a b : ℝ) : ℝ :=
  Real.sqrt (((1-t)*(a-b))^2 + 4*a*b)

 
def mass (t a b : ℝ) : ℝ :=
  (discriminant t a b + (1-t)*(a-b))/2

lemma discriminant_swap (t a b : ℝ) : discriminant t b a = discriminant t a b := by
  unfold discriminant
  congr 1
  ring

lemma discriminant_sq (t : ℝ) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    discriminant t a b ^ 2 = ((1-t)*(a-b))^2 + 4*a*b := by
  apply Real.sq_sqrt
  positivity

lemma mass_nonneg (t : ℝ) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    0 ≤ mass t a b := by
  have h : -((1-t)*(a-b)) ≤ discriminant t a b := by
    apply Real.le_sqrt_of_sq_le
    have : 0 ≤ 4*a*b := by positivity
    nlinarith
  unfold mass
  linarith

lemma mass_difference (t a b : ℝ) :
    mass t a b - mass t b a = (1-t)*(a-b) := by
  unfold mass
  rw [discriminant_swap]
  ring

lemma mass_product (t : ℝ) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    mass t a b * mass t b a = a*b := by
  have hd := discriminant_sq t ha hb
  unfold mass
  rw [discriminant_swap t a b]
  nlinarith

lemma mass_at_zero {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) : mass 0 a b = a := by
  have h : (a-b)^2+4*a*b = (a+b)^2 := by ring
  simp only [mass, discriminant, sub_zero, one_mul, h, Real.sqrt_sq (add_nonneg ha hb)]
  ring

lemma mass_at_one {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    mass 1 a b = Real.sqrt (a*b) := by
  have h0 := mass_nonneg 1 ha hb
  have h1 := mass_product 1 ha hb
  have h2 := mass_difference 1 a b
  have h3 := Real.sq_sqrt (mul_nonneg ha hb)
  have h4 := Real.sqrt_nonneg (a*b)
  simp only [sub_self, zero_mul] at h2
  nlinarith

lemma mass_zero_left {t b : ℝ} (ht : t ≤ 1) (hb : 0 ≤ b) : mass t 0 b = 0 := by
  have h : (1-t)*(-b) ≤ 0 := mul_nonpos_of_nonneg_of_nonpos (by linarith) (by linarith)
  simp only [mass, discriminant, zero_sub, mul_zero, zero_mul, add_zero,
    Real.sqrt_sq_eq_abs, abs_of_nonpos h]
  ring

lemma mass_same (t a : ℝ) (ha : 0 ≤ a) : mass t a a = a := by
  have h : 4*a*a = (2*a)^2 := by ring
  simp only [mass, discriminant, sub_self, mul_zero, zero_pow (by decide : 2 ≠ 0),
    zero_add, h, Real.sqrt_sq (by linarith : 0 ≤ 2*a), add_zero]
  ring

lemma discriminant_le_add {t a b : ℝ} (ht0 : 0 ≤ t) (ht1 : t ≤ 1)
    (ha : 0 ≤ a) (hb : 0 ≤ b) : discriminant t a b ≤ a+b := by
  apply Real.sqrt_le_iff.mpr
  refine ⟨add_nonneg ha hb, ?_⟩
  have ht : (1-t)^2 ≤ 1 := by nlinarith [mul_nonneg ht0 (sub_nonneg.mpr ht1)]
  have h := mul_le_mul_of_nonneg_right ht (sq_nonneg (a-b))
  nlinarith

lemma mass_le_max {t a b : ℝ} (ht0 : 0 ≤ t) (ht1 : t ≤ 1)
    (ha : 0 ≤ a) (hb : 0 ≤ b) : mass t a b ≤ max a b := by
  have hd := discriminant_le_add ht0 ht1 ha hb
  unfold mass
  rcases le_total a b with hab | hba
  · rw [max_eq_right hab]
    have h : (1-t)*(a-b) ≤ 0 :=
      mul_nonpos_of_nonneg_of_nonpos (by linarith) (by linarith)
    linarith
  · rw [max_eq_left hba]
    have h : (1-t)*(a-b) ≤ a-b := by
      nlinarith [mul_nonneg ht0 (sub_nonneg.mpr hba)]
    linarith

 
def radius (t a b : ℝ) : ℝ := Real.sqrt (mass t (a^2) (b^2))

lemma radius_nonneg (t a b : ℝ) : 0 ≤ radius t a b := Real.sqrt_nonneg _

lemma radius_sq (t a b : ℝ) : radius t a b ^ 2 = mass t (a^2) (b^2) := by
  exact Real.sq_sqrt (mass_nonneg t (sq_nonneg _) (sq_nonneg _))

lemma radius_at_zero {a b : ℝ} (ha : 0 ≤ a) : radius 0 a b = a := by
  rw [radius, mass_at_zero (sq_nonneg _) (sq_nonneg _), Real.sqrt_sq ha]

lemma radius_same (t : ℝ) {a : ℝ} (ha : 0 ≤ a) : radius t a a = a := by
  rw [radius, mass_same t _ (sq_nonneg _), Real.sqrt_sq ha]

lemma radius_zero_left {t b : ℝ} (ht : t ≤ 1) : radius t 0 b = 0 := by
  simp only [radius, zero_pow (by decide : 2 ≠ 0),
    mass_zero_left ht (sq_nonneg b), Real.sqrt_zero]

lemma radius_product (t : ℝ) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    radius t a b * radius t b a = a*b := by
  have hp : (a^2)*(b^2) = (a*b)^2 := by ring
  rw [radius, radius, ← Real.sqrt_mul (mass_nonneg t (sq_nonneg a) (sq_nonneg b)),
    mass_product t (sq_nonneg a) (sq_nonneg b), hp, Real.sqrt_sq (mul_nonneg ha hb)]

lemma radius_at_one_swap (a b : ℝ) : radius 1 a b = radius 1 b a := by
  simp only [radius, mass_at_one (sq_nonneg _) (sq_nonneg _), mul_comm]

lemma radius_le_max {t a b : ℝ} (ht0 : 0 ≤ t) (ht1 : t ≤ 1)
    (ha : 0 ≤ a) (hb : 0 ≤ b) : radius t a b ≤ max a b := by
  have h := mass_le_max ht0 ht1 (sq_nonneg a) (sq_nonneg b)
  apply Real.sqrt_le_iff.mpr
  refine ⟨le_trans ha (le_max_left _ _), ?_⟩
  calc mass t (a^2) (b^2) ≤ max (a^2) (b^2) := h
       _ ≤ (max a b)^2 := max_le
         (by nlinarith [le_max_left a b]) (by nlinarith [le_max_right a b])

lemma continuous_radius : Continuous (fun p : ℝ × ℝ × ℝ => radius p.1 p.2.1 p.2.2) := by
  unfold radius mass discriminant
  fun_prop

open scoped unitInterval

 
def balance (t : I) (p : ℂ × ℂ) : ℂ × ℂ :=
  (scaleTo (radius t ‖p.1‖ ‖p.2‖) p.1,
   scaleTo (radius t ‖p.2‖ ‖p.1‖) p.2)

lemma balance_zero (p : ℂ × ℂ) : balance 0 p = p := by
  simp [balance, radius_at_zero (norm_nonneg _), scaleTo_norm]

lemma norm_balance_fst (t : I) (p : ℂ × ℂ) :
    ‖(balance t p).1‖ = radius t ‖p.1‖ ‖p.2‖ := by
  by_cases hy : p.1 = 0
  · simp [balance, hy, radius_zero_left t.property.2, scaleTo_zero]
  · simp only [balance, norm_scaleTo _ hy, Real.norm_eq_abs,
      abs_of_nonneg (radius_nonneg _ _ _)]

lemma norm_balance_snd (t : I) (p : ℂ × ℂ) :
    ‖(balance t p).2‖ = radius t ‖p.2‖ ‖p.1‖ := by
  by_cases hz : p.2 = 0
  · simp [balance, hz, radius_zero_left t.property.2, scaleTo_zero]
  · simp only [balance, norm_scaleTo _ hz, Real.norm_eq_abs,
      abs_of_nonneg (radius_nonneg _ _ _)]

lemma balance_one_equal_norms (p : ℂ × ℂ) :
    ‖(balance 1 p).1‖ = ‖(balance 1 p).2‖ := by
  rw [norm_balance_fst, norm_balance_snd]
  exact radius_at_one_swap _ _

lemma balance_fixed (t : I) {p : ℂ × ℂ} (hp : ‖p.1‖ = ‖p.2‖) : balance t p = p := by
  apply Prod.ext
  · change scaleTo (radius t ‖p.1‖ ‖p.2‖) p.1 = p.1
    rw [← hp, radius_same t (norm_nonneg _), scaleTo_norm]
  · change scaleTo (radius t ‖p.2‖ ‖p.1‖) p.2 = p.2
    rw [hp, radius_same t (norm_nonneg _), scaleTo_norm]

lemma balance_product (t : I) (p : ℂ × ℂ) :
    (balance t p).1 * (balance t p).2 = p.1*p.2 := by
  by_cases hy : p.1 = 0
  · simp [balance, hy, scaleTo_zero]
  by_cases hz : p.2 = 0
  · simp [balance, hz, scaleTo_zero]
  have hyn : ‖p.1‖ ≠ 0 := norm_ne_zero_iff.mpr hy
  have hzn : ‖p.2‖ ≠ 0 := norm_ne_zero_iff.mpr hz
  have hrad := radius_product (t : ℝ) (norm_nonneg p.1) (norm_nonneg p.2)
  have hscale : (radius t ‖p.1‖ ‖p.2‖ / ‖p.1‖) *
      (radius t ‖p.2‖ ‖p.1‖ / ‖p.2‖) = 1 := by
    rw [div_mul_div_comm, hrad, div_self (mul_ne_zero hyn hzn)]
  change ((radius t ‖p.1‖ ‖p.2‖ / ‖p.1‖) • p.1) *
    ((radius t ‖p.2‖ ‖p.1‖ / ‖p.2‖) • p.2) = _
  rw [smul_mul_smul_comm, hscale, one_smul]

lemma balance_bound (t : I) {p : ℂ × ℂ} {M : ℝ}
    (hy : ‖p.1‖ ≤ M) (hz : ‖p.2‖ ≤ M) :
    ‖(balance t p).1‖ ≤ M ∧ ‖(balance t p).2‖ ≤ M := by
  rw [norm_balance_fst, norm_balance_snd]
  exact ⟨(radius_le_max t.property.1 t.property.2 (norm_nonneg _) (norm_nonneg _)).trans
    (max_le hy hz),
    (radius_le_max t.property.1 t.property.2 (norm_nonneg _) (norm_nonneg _)).trans
    (max_le hz hy)⟩

lemma continuous_balance : Continuous (fun p : I × (ℂ × ℂ) => balance p.1 p.2) := by
  have ht : Continuous (fun p : I × (ℂ × ℂ) => (p.1 : ℝ)) :=
    continuous_subtype_val.comp continuous_fst
  have hy : Continuous (fun p : I × (ℂ × ℂ) => p.2.1) := continuous_snd.fst
  have hz : Continuous (fun p : I × (ℂ × ℂ) => p.2.2) := continuous_snd.snd
  have hr1 : Continuous (fun p : I × (ℂ × ℂ) => radius p.1 ‖p.2.1‖ ‖p.2.2‖) :=
    continuous_radius.comp (ht.prodMk (hy.norm.prodMk hz.norm))
  have hr2 : Continuous (fun p : I × (ℂ × ℂ) => radius p.1 ‖p.2.2‖ ‖p.2.1‖) :=
    continuous_radius.comp (ht.prodMk (hz.norm.prodMk hy.norm))
  have hc1 := continuous_scaleTo hr1 hy (by
    intro p hp
    simp [hp, radius_zero_left p.1.property.2])
  have hc2 := continuous_scaleTo hr2 hz (by
    intro p hp
    simp [hp, radius_zero_left p.1.property.2])
  exact hc1.prodMk hc2

 
def coreCoords (c : ℂ) (u : Circle) : ℂ × ℂ :=
  ((Real.sqrt ‖c‖) • (u : ℂ), scaleTo (Real.sqrt ‖c‖) c * (u : ℂ)⁻¹)

lemma coreCoords_zero (u : Circle) : coreCoords 0 u = (0, 0) := by
  simp [coreCoords, scaleTo_zero]

lemma coreCoords_norm_fst (c : ℂ) (u : Circle) :
    ‖(coreCoords c u).1‖ = Real.sqrt ‖c‖ := by
  simp [coreCoords, Circle.norm_coe, Real.norm_eq_abs,
    abs_of_nonneg (Real.sqrt_nonneg _)]

lemma coreCoords_norm_snd (c : ℂ) (u : Circle) :
    ‖(coreCoords c u).2‖ = Real.sqrt ‖c‖ := by
  by_cases hc : c = 0
  · simp [hc, coreCoords_zero]
  · simp [coreCoords, norm_inv, norm_scaleTo _ hc,
      Circle.norm_coe, Real.norm_eq_abs, abs_of_nonneg (Real.sqrt_nonneg _)]

lemma coreCoords_product (c : ℂ) (u : Circle) :
    (coreCoords c u).1 * (coreCoords c u).2 = c := by
  by_cases hc : c = 0
  · simp [hc, coreCoords_zero]
  have hn : ‖c‖ ≠ 0 := norm_ne_zero_iff.mpr hc
  have ha : Real.sqrt ‖c‖ * (Real.sqrt ‖c‖ / ‖c‖) = 1 := by
    rw [← mul_div_assoc, ← pow_two, Real.sq_sqrt (norm_nonneg c), div_self hn]
  change (Real.sqrt ‖c‖ • (u : ℂ)) *
    (((Real.sqrt ‖c‖ / ‖c‖) • c) * (u : ℂ)⁻¹) = c
  rw [← mul_assoc, smul_mul_smul_comm, smul_mul_assoc, ha, one_smul]
  rw [mul_comm (u : ℂ) c, mul_assoc, mul_inv_cancel₀ (Circle.coe_ne_zero u), mul_one]

lemma continuous_coreCoords : Continuous (fun p : ℂ × Circle => coreCoords p.1 p.2) := by
  have ha : Continuous (fun p : ℂ × Circle => Real.sqrt ‖p.1‖) := continuous_fst.norm.sqrt
  have hu : Continuous (fun p : ℂ × Circle => (p.2 : ℂ)) :=
    continuous_subtype_val.comp continuous_snd
  have hs := continuous_scaleTo ha continuous_fst (by
    intro p hp
    simp [hp])
  exact (ha.smul hu).prodMk (hs.mul (hu.inv₀ (fun p => Circle.coe_ne_zero p.2)))

lemma coreCoords_eq_iff (c : ℂ) (u v : Circle) :
    coreCoords c u = coreCoords c v ↔ c = 0 ∨ u = v := by
  by_cases hc : c = 0
  · simp [hc, coreCoords_zero]
  · have ha : Real.sqrt ‖c‖ ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (norm_pos_iff.mpr hc))
    constructor
    · intro h
      right
      apply Circle.ext
      have hf : Real.sqrt ‖c‖ • (u : ℂ) = Real.sqrt ‖c‖ • (v : ℂ) :=
        congrArg Prod.fst h
      have hi := congrArg (fun z : ℂ => (Real.sqrt ‖c‖)⁻¹ • z) hf
      simpa only [smul_smul, inv_mul_cancel₀ ha, one_smul] using hi
    · rintro (h | rfl)
      · exact (hc h).elim
      · rfl

lemma coreCoords_surj {c : ℂ} (p : ℂ × ℂ)
    (hp : p.1*p.2 = c) (hn : ‖p.1‖ = ‖p.2‖) : ∃ u : Circle, coreCoords c u = p := by
  have hc : ‖c‖ = ‖p.1‖^2 := by rw [← hp, norm_mul, ← hn, pow_two]
  have ha : Real.sqrt ‖c‖ = ‖p.1‖ := by rw [hc, Real.sqrt_sq (norm_nonneg _)]
  by_cases hy : p.1 = 0
  · have hz : p.2 = 0 := norm_eq_zero.mp (by simpa [hy] using hn.symm)
    have hc0 : c = 0 := by simp [hy] at hp; exact hp.symm
    refine ⟨1, ?_⟩
    apply Prod.ext <;> simp [hc0, coreCoords_zero, hy, hz]
  · have hyn : ‖p.1‖ ≠ 0 := norm_ne_zero_iff.mpr hy
    let u : Circle := ⟨‖p.1‖⁻¹ • p.1, mem_sphere_zero_iff_norm.mpr (by
      rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (inv_nonneg.mpr (norm_nonneg _)),
        inv_mul_cancel₀ hyn])⟩
    have hfirst : (coreCoords c u).1 = p.1 := by
      change Real.sqrt ‖c‖ • (‖p.1‖⁻¹ • p.1) = p.1
      rw [ha, ← mul_smul, mul_inv_cancel₀ hyn, one_smul]
    refine ⟨u, Prod.ext hfirst ?_⟩
    apply mul_left_cancel₀ hy
    rw [← hfirst, coreCoords_product]
    simpa only [hfirst] using hp.symm

section Blocks
variable {G : Type*} [TopologicalSpace G]

 

abbrev ConicBlock (R : G → ℂ) (M : ℝ) :=
  {p : G × (ℂ × ℂ) // p.2.1 * p.2.2 = R p.1 ∧ ‖p.2.1‖ ≤ M ∧ ‖p.2.2‖ ≤ M}

abbrev BalancedBlock (R : G → ℂ) (M : ℝ) :=
  {p : ConicBlock R M // ‖p.val.2.1‖ = ‖p.val.2.2‖}

variable (R : G → ℂ) (M : ℝ)

def balanceBlock (t : I) (p : ConicBlock R M) : ConicBlock R M :=
  ⟨(p.val.1, balance t p.val.2), by
    refine ⟨?_, balance_bound t p.property.2.1 p.property.2.2⟩
    exact (balance_product t p.val.2).trans p.property.1⟩

lemma continuous_balanceBlock :
    Continuous (fun p : I × ConicBlock R M => balanceBlock R M p.1 p.2) := by
  have hc : Continuous (fun p : I × ConicBlock R M => p.2.val) :=
    continuous_subtype_val.comp continuous_snd
  have hp : Continuous (fun p : I × ConicBlock R M => (p.1, p.2.val.2)) :=
    continuous_fst.prodMk hc.snd
  have hb := continuous_balance.comp hp
  exact (hc.fst.prodMk hb).subtype_mk _

omit [TopologicalSpace G] in
lemma balanceBlock_zero (p : ConicBlock R M) : balanceBlock R M 0 p = p := by
  apply Subtype.ext
  change (p.val.1, balance 0 p.val.2) = p.val
  rw [balance_zero]

omit [TopologicalSpace G] in
lemma balanceBlock_fixed (t : I) {p : ConicBlock R M}
    (hp : ‖p.val.2.1‖ = ‖p.val.2.2‖) : balanceBlock R M t p = p := by
  apply Subtype.ext
  change (p.val.1, balance t p.val.2) = p.val
  rw [balance_fixed t hp]

 
def coreInclusion : C(BalancedBlock R M, ConicBlock R M) :=
  ⟨Subtype.val, continuous_subtype_val⟩

 
def coreRetraction : C(ConicBlock R M, BalancedBlock R M) where
  toFun p := ⟨balanceBlock R M 1 p, balance_one_equal_norms p.val.2⟩
  continuous_toFun := (continuous_balanceBlock R M |>.comp
    (continuous_const.prodMk continuous_id)).subtype_mk _

lemma coreRetraction_inclusion (p : BalancedBlock R M) :
    coreRetraction R M (coreInclusion R M p) = p := by
  apply Subtype.ext
  exact balanceBlock_fixed R M 1 p.property

 
def blockHomotopy : ContinuousMap.Homotopy (ContinuousMap.id (ConicBlock R M))
    ((coreInclusion R M).comp (coreRetraction R M)) where
  toFun p := balanceBlock R M p.1 p.2
  continuous_toFun := continuous_balanceBlock R M
  map_zero_left := balanceBlock_zero R M
  map_one_left _ := rfl

 

lemma blockHomotopy_fixed (t : I) (p : BalancedBlock R M) :
    blockHomotopy R M (t, coreInclusion R M p) = coreInclusion R M p :=
  balanceBlock_fixed R M t p.property

 
def blockCoreHomotopyEquiv : ContinuousMap.HomotopyEquiv (ConicBlock R M) (BalancedBlock R M) where
  toFun := coreRetraction R M
  invFun := coreInclusion R M
  left_inv := ⟨(blockHomotopy R M).symm⟩
  right_inv := by
    have h : (coreRetraction R M).comp (coreInclusion R M) =
        ContinuousMap.id (BalancedBlock R M) := by
      apply ContinuousMap.ext
      intro p
      exact coreRetraction_inclusion R M p
    rw [h]

 

def collapseSetoid : Setoid (G × Circle) where
  r p q := p.1 = q.1 ∧ (R p.1 = 0 ∨ p.2 = q.2)
  iseqv := {
    refl := fun _ => ⟨rfl, Or.inr rfl⟩
    symm := by
      rintro p q ⟨hb, hc⟩
      refine ⟨hb.symm, ?_⟩
      rcases hc with hc | hc
      · exact Or.inl (hb ▸ hc)
      · exact Or.inr hc.symm
    trans := by
      rintro p q r ⟨hb1, hc1⟩ ⟨hb2, hc2⟩
      refine ⟨hb1.trans hb2, ?_⟩
      rcases hc1 with hc1 | hc1
      · exact Or.inl hc1
      rcases hc2 with hc2 | hc2
      · exact Or.inl (hb1 ▸ hc2)
      · exact Or.inr (hc1.trans hc2) }

abbrev CircleCollapse := Quotient (collapseSetoid R)

variable (hbound : ∀ g, Real.sqrt ‖R g‖ ≤ M)

 
def coreParam (p : G × Circle) : BalancedBlock R M :=
  ⟨⟨(p.1, coreCoords (R p.1) p.2), by
    refine ⟨coreCoords_product _ _, ?_, ?_⟩
    · rw [coreCoords_norm_fst]; exact hbound p.1
    · rw [coreCoords_norm_snd]; exact hbound p.1⟩, by
    exact (coreCoords_norm_fst _ _).trans (coreCoords_norm_snd _ _).symm⟩

lemma continuous_coreParam (hR : Continuous R) : Continuous (coreParam R M hbound) := by
  apply Continuous.subtype_mk
  apply Continuous.subtype_mk
  exact continuous_fst.prodMk (continuous_coreCoords.comp
    ((hR.comp continuous_fst).prodMk continuous_snd))

omit [TopologicalSpace G] in
lemma coreParam_eq_iff (p q : G × Circle) :
    coreParam R M hbound p = coreParam R M hbound q ↔ collapseSetoid R p q := by
  constructor
  · intro h
    have hb : p.1 = q.1 := congrArg (fun x : BalancedBlock R M => x.val.val.1) h
    have hc : coreCoords (R p.1) p.2 = coreCoords (R q.1) q.2 :=
      congrArg (fun x : BalancedBlock R M => x.val.val.2) h
    refine ⟨hb, ?_⟩
    rw [← hb] at hc
    exact (coreCoords_eq_iff _ _ _).mp hc
  · rintro ⟨hb, hc⟩
    apply Subtype.ext
    apply Subtype.ext
    refine Prod.ext ?_ ?_
    · exact hb
    change coreCoords (R p.1) p.2 = coreCoords (R q.1) q.2
    rw [← hb]
    exact (coreCoords_eq_iff _ _ _).mpr hc

omit [TopologicalSpace G] in
lemma coreParam_surjective : Function.Surjective (coreParam R M hbound) := by
  intro p
  obtain ⟨u, hu⟩ := coreCoords_surj p.val.val.2 p.val.property.1 p.property
  refine ⟨(p.val.val.1, u), ?_⟩
  apply Subtype.ext
  apply Subtype.ext
  exact Prod.ext rfl hu

 
def collapseToCore : CircleCollapse R → BalancedBlock R M :=
  Quotient.lift (coreParam R M hbound)
    (fun p q h => (coreParam_eq_iff R M hbound p q).mpr h)

lemma continuous_collapseToCore (hR : Continuous R) :
    Continuous (collapseToCore R M hbound) :=
  (continuous_coreParam R M hbound hR).quotient_lift _

omit [TopologicalSpace G] in
lemma collapseToCore_bijective : Function.Bijective (collapseToCore R M hbound) := by
  constructor
  · intro p q
    induction p using Quotient.inductionOn with | h p =>
      induction q using Quotient.inductionOn with | h q =>
        intro h
        exact Quotient.sound ((coreParam_eq_iff R M hbound p q).mp h)
  · intro p
    obtain ⟨q, hq⟩ := coreParam_surjective R M hbound p
    exact ⟨Quotient.mk _ q, hq⟩

 

def collapseCoreHomeomorph [CompactSpace G] [T2Space G] (hR : Continuous R) :
    CircleCollapse R ≃ₜ BalancedBlock R M :=
  Continuous.homeoOfEquivCompactToT2
    (f := Equiv.ofBijective (collapseToCore R M hbound) (collapseToCore_bijective R M hbound))
    (continuous_collapseToCore R M hbound hR)

 

def blockCollapseHomotopyEquiv [CompactSpace G] [T2Space G] (hR : Continuous R) :
    ContinuousMap.HomotopyEquiv (ConicBlock R M) (CircleCollapse R) :=
  (blockCoreHomotopyEquiv R M).trans (collapseCoreHomeomorph R M hbound hR).symm.toHomotopyEquiv

 
abbrev WeightedConicBlock (scale : ℝ) :=
  {p : G × (ℂ × ℂ) // p.2.1*p.2.2 = R p.1 ∧
    ‖p.2.1‖ ≤ scale*M ∧ ‖p.2.2‖ ≤ scale⁻¹*M}

 

def normalizeBlock (scale : ℝ) (hscale : 0 < scale) :
    WeightedConicBlock R M scale ≃ₜ ConicBlock R M where
  toFun p := ⟨(p.val.1, scale⁻¹ • p.val.2.1, scale • p.val.2.2), by
    refine ⟨?_, ?_, ?_⟩
    · rw [smul_mul_smul_comm, inv_mul_cancel₀ hscale.ne', one_smul]
      exact p.property.1
    · rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hscale)]
      have hh := mul_le_mul_of_nonneg_left p.property.2.1 (inv_nonneg.mpr hscale.le)
      simpa only [← mul_assoc, inv_mul_cancel₀ hscale.ne', one_mul] using hh
    · rw [norm_smul, Real.norm_eq_abs, abs_of_pos hscale]
      have hh := mul_le_mul_of_nonneg_left p.property.2.2 hscale.le
      simpa only [← mul_assoc, mul_inv_cancel₀ hscale.ne', one_mul] using hh⟩
  invFun p := ⟨(p.val.1, scale • p.val.2.1, scale⁻¹ • p.val.2.2), by
    refine ⟨?_, ?_, ?_⟩
    · rw [smul_mul_smul_comm, mul_inv_cancel₀ hscale.ne', one_smul]
      exact p.property.1
    · rw [norm_smul, Real.norm_eq_abs, abs_of_pos hscale]
      exact mul_le_mul_of_nonneg_left p.property.2.1 hscale.le
    · rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hscale)]
      exact mul_le_mul_of_nonneg_left p.property.2.2 (inv_nonneg.mpr hscale.le)⟩
  left_inv p := by
    apply Subtype.ext
    simp only [← mul_smul, mul_inv_cancel₀ hscale.ne', inv_mul_cancel₀ hscale.ne', one_smul]
  right_inv p := by
    apply Subtype.ext
    simp only [← mul_smul, mul_inv_cancel₀ hscale.ne', inv_mul_cancel₀ hscale.ne', one_smul]
  continuous_toFun := by
    apply Continuous.subtype_mk
    exact continuous_subtype_val.fst.prodMk
      ((continuous_subtype_val.snd.fst.const_smul scale⁻¹).prodMk
        (continuous_subtype_val.snd.snd.const_smul scale))
  continuous_invFun := by
    apply Continuous.subtype_mk
    exact continuous_subtype_val.fst.prodMk
      ((continuous_subtype_val.snd.fst.const_smul scale).prodMk
        (continuous_subtype_val.snd.snd.const_smul scale⁻¹))

 

def weightedBlockCollapseHomotopyEquiv [CompactSpace G] [T2Space G]
    (hR : Continuous R) (scale : ℝ) (hscale : 0 < scale) :
    ContinuousMap.HomotopyEquiv (WeightedConicBlock R M scale) (CircleCollapse R) :=
  (normalizeBlock R M scale hscale).toHomotopyEquiv.trans
    (blockCollapseHomotopyEquiv R M hbound hR)

end Blocks

section SingularHomology
open CategoryTheory AlgebraicTopology

 

abbrev integralHomologyFunctor (n : ℕ) : TopCat ⥤ ModuleCat ℤ :=
  (singularHomologyFunctor (ModuleCat ℤ) n).obj (ModuleCat.of ℤ ℤ)

abbrev IntegralHomology (n : ℕ) (X : Type) [TopologicalSpace X] : ModuleCat ℤ :=
  (integralHomologyFunctor n).obj (TopCat.of X)

lemma integralHomologyMap_eq_of_homotopic {X Y : Type}
    [TopologicalSpace X] [TopologicalSpace Y] {f g : C(X,Y)}
    (h : f.Homotopic g) (n : ℕ) :
    (integralHomologyFunctor n).map (TopCat.ofHom f) =
      (integralHomologyFunctor n).map (TopCat.ofHom g) := by
  obtain ⟨H⟩ := h
  exact TopCat.Homotopy.congr_homologyMap_singularChainComplexFunctor
    (f := TopCat.ofHom f) (g := TopCat.ofHom g) H (ModuleCat.of ℤ ℤ) n

 

def integralHomologyIso {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y]
    (e : ContinuousMap.HomotopyEquiv X Y) (n : ℕ) :
    IntegralHomology n X ≅ IntegralHomology n Y where
  hom := (integralHomologyFunctor n).map (TopCat.ofHom e.toFun)
  inv := (integralHomologyFunctor n).map (TopCat.ofHom e.invFun)
  hom_inv_id := by
    rw [← Functor.map_comp]
    change (integralHomologyFunctor n).map (TopCat.ofHom (e.invFun.comp e.toFun)) = _
    rw [integralHomologyMap_eq_of_homotopic e.left_inv]
    exact (integralHomologyFunctor n).map_id _
  inv_hom_id := by
    rw [← Functor.map_comp]
    change (integralHomologyFunctor n).map (TopCat.ofHom (e.toFun.comp e.invFun)) = _
    rw [integralHomologyMap_eq_of_homotopic e.right_inv]
    exact (integralHomologyFunctor n).map_id _

 

def weightedBlockHomologyIso {G : Type} [TopologicalSpace G] [CompactSpace G]
    [T2Space G] (R : G → ℂ) (hR : Continuous R) (M : ℝ)
    (hbound : ∀ g, Real.sqrt ‖R g‖ ≤ M) (scale : ℝ) (hscale : 0 < scale) (n : ℕ) :
    IntegralHomology n (WeightedConicBlock R M scale) ≅
      IntegralHomology n (CircleCollapse R) :=
  integralHomologyIso (weightedBlockCollapseHomotopyEquiv R M hbound hR scale hscale) n

end SingularHomology
end
end AmbientMultiplicity.InnerGeometry

end OAI