import Mathlib
import OAI.Geometry.HypersurfaceGerms.InnerGeometry
import OAI.Geometry.HypersurfaceGerms.Preparation
import OAI.Geometry.HypersurfaceGerms.RelativeChains
import OAI.Geometry.HypersurfaceGerms.RootBounds

namespace OAI

/-! Homeomorphic inner-root models and naturality of the root-to-base projection. -/

namespace AmbientMultiplicity.SourceInnerPage
noncomputable section
open Preparation InnerQuartic InnerGeometry Filter Topology

abbrev Base := Fin 2 → ℂ

 
def sourceH (p : Base) : ℂ := p 1*(p 0-(p 1)^2)*(p 0-2*(p 1)^2)

lemma continuous_sourceH : Continuous sourceH := by unfold sourceH; fun_prop

 

def low0 (p : Base) (j : Fin 4) : ℂ := coeff0 p ⟨j, by omega⟩
def low1 (p : Base) (j : Fin 4) : ℂ := coeff1 p ⟨j, by omega⟩

lemma low0_analytic : AnalyticAt ℂ low0 0 := by
  apply AnalyticAt.pi
  intro j
  exact ((proj ⟨j, by omega⟩).analyticAt _).comp coeff0_spec.1

lemma low1_analytic : AnalyticAt ℂ low1 0 := by
  apply AnalyticAt.pi
  intro j
  exact ((proj ⟨j, by omega⟩).analyticAt _).comp coeff1_spec.1

 
def R0 (s : ℝ) (p : Base) (w : ℂ) : ℂ := rescaledQuartic low0 s p w
def R1 (s : ℝ) (p : Base) (w : ℂ) : ℂ := rescaledQuartic low1 s p w

lemma R0_eq_source (s : ℝ) (hs : s ≠ 0) (p : Base) (w : ℂ) :
    R0 s p w = (s : ℂ)^4 * root0 p (w/(s : ℂ)) := by
  have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs
  simp only [R0, rescaledQuartic, low0, root0, eval_rootPoly, Fin.sum_univ_four]
  norm_num
  field_simp

lemma R1_eq_source (s : ℝ) (hs : s ≠ 0) (p : Base) (w : ℂ) :
    R1 s p w = (s : ℂ)^4 * root1 p (w/(s : ℂ)) := by
  have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs
  simp only [R1, rescaledQuartic, low1, root1, eval_rootPoly, Fin.sum_univ_four]
  norm_num
  field_simp

lemma common_base_cut : ∃ baseRadius : ℝ, 0 < baseRadius ∧
    ContinuousOn low0 (Metric.closedBall 0 baseRadius) ∧
    ContinuousOn low1 (Metric.closedBall 0 baseRadius) := by
  have hh : ∀ᶠ p : Base in 𝓝 0, ContinuousAt low0 p ∧ ContinuousAt low1 p := by
    filter_upwards [low0_analytic.eventually_analyticAt, low1_analytic.eventually_analyticAt]
      with p h0 h1
    exact ⟨h0.continuousAt, h1.continuousAt⟩
  obtain ⟨r, hr, hsub⟩ := Metric.mem_nhds_iff.mp hh
  refine ⟨r/2, by positivity, ?_, ?_⟩
  · intro p hp
    have hp' : p ∈ Metric.ball 0 r := by
      rw [Metric.mem_ball]
      have := Metric.mem_closedBall.mp hp
      linarith
    exact (hsub hp').1.continuousWithinAt
  · intro p hp
    have hp' : p ∈ Metric.ball 0 r := by
      rw [Metric.mem_ball]
      have := Metric.mem_closedBall.mp hp
      linarith
    exact (hsub hp').2.continuousWithinAt

 
abbrev BasePage (baseRadius : ℝ) (c : ℂ) :=
  {p : Base // ‖p‖ ≤ baseRadius ∧ sourceH p = c}

instance basePage_compact (baseRadius : ℝ) (c : ℂ) : CompactSpace (BasePage baseRadius c) := by
  apply isCompact_iff_compactSpace.mp
  change IsCompact {p : Base | ‖p‖ ≤ baseRadius ∧ sourceH p = c}
  have he : {p : Base | ‖p‖ ≤ baseRadius ∧ sourceH p = c} =
      Metric.closedBall 0 baseRadius ∩ sourceH ⁻¹' {c} := by
    ext p
    simp [Metric.mem_closedBall, dist_eq_norm]
  rw [he]
  exact (isCompact_closedBall _ _).inter_right
    (isClosed_singleton.preimage continuous_sourceH)

abbrev Disk (radius : ℝ) := ↑(Metric.closedBall (0 : ℂ) radius)
abbrev RootBase (baseRadius : ℝ) (c : ℂ) (radius : ℝ) := BasePage baseRadius c × Disk radius

def onRootBase (R : Base → ℂ → ℂ) (baseRadius : ℝ) (c : ℂ) (radius : ℝ) :
    RootBase baseRadius c radius → ℂ := fun g => R g.1.val g.2.val

 

abbrev Model (R : Base → ℂ → ℂ) (baseRadius : ℝ) (c : ℂ)
    (radius M alpha beta : ℝ) :=
  {v : RootBase baseRadius c radius × (ℂ × ℂ) //
    v.2.1*v.2.2 = onRootBase R baseRadius c radius v.1 ∧
      ‖v.2.1‖ ≤ M*radius^alpha ∧ ‖v.2.2‖ ≤ M*radius^beta}

lemma y_bound_eq {radius alpha beta M : ℝ} (hradius : 0 < radius)
    (hweights : alpha+beta = 4) :
    radius^((alpha-beta)/2)*(M*radius^2) = M*radius^alpha := by
  have he : (alpha-beta)/2 + (2 : ℝ) = alpha := by linarith
  have hp := Real.rpow_add hradius ((alpha-beta)/2) 2
  rw [he, Real.rpow_two] at hp
  calc
    _ = M*(radius^((alpha-beta)/2)*radius^2) := by ring
    _ = _ := by rw [← hp]

lemma z_bound_eq {radius alpha beta M : ℝ} (hradius : 0 < radius)
    (hweights : alpha+beta = 4) :
    (radius^((alpha-beta)/2))⁻¹*(M*radius^2) = M*radius^beta := by
  rw [← Real.rpow_neg hradius.le]
  have he : -((alpha-beta)/2) + (2 : ℝ) = beta := by linarith
  have hp := Real.rpow_add hradius (-((alpha-beta)/2)) 2
  rw [he, Real.rpow_two] at hp
  calc
    _ = M*(radius^(-((alpha-beta)/2))*radius^2) := by ring
    _ = _ := by rw [← hp]

 

def weightedModelHomeomorph (R : Base → ℂ → ℂ) (baseRadius : ℝ) (c : ℂ)
    (radius M alpha beta : ℝ) (hradius : 0 < radius) (hweights : alpha+beta = 4) :
    WeightedConicBlock (onRootBase R baseRadius c radius) (M*radius^2)
        (radius^((alpha-beta)/2)) ≃ₜ Model R baseRadius c radius M alpha beta :=
  Homeomorph.setCongr (by
    ext v
    simp only [y_bound_eq hradius hweights, z_bound_eq hradius hweights])

lemma continuous_onRootBase_rescaled {A : Base → Fin 4 → ℂ} {baseRadius : ℝ}
    (hA : ContinuousOn A (Metric.closedBall 0 baseRadius)) (c : ℂ) (radius s : ℝ) :
    Continuous (onRootBase (rescaledQuartic A s) baseRadius c radius) := by
  have hcA : Continuous (fun p : BasePage baseRadius c => A p.val) :=
    hA.comp_continuous continuous_subtype_val (fun p => by
      simpa [Metric.mem_closedBall, dist_eq_norm] using p.property.1)
  have hc := continuous_rescaledQuartic (fun p : BasePage baseRadius c => A p.val) hcA
  have hk : Continuous (fun p : RootBase baseRadius c radius => (s, (p.1, p.2.val))) :=
    continuous_const.prodMk (continuous_fst.prodMk continuous_snd.subtype_val)
  have hh := hc.comp hk
  exact hh

lemma eventually_bound_on_base {A : Base → Fin 4 → ℂ} {baseRadius : ℝ}
    (hA : ContinuousOn A (Metric.closedBall 0 baseRadius))
    (radius : ℝ) (hradius : 0 < radius) :
    ∀ᶠ s : ℝ in 𝓝 0, ∀ p : Base, ‖p‖ ≤ baseRadius →
      ∀ w : ℂ, ‖w‖ ≤ radius → ‖rescaledQuartic A s p w‖ ≤ 2*radius^4 := by
  have hcA : Continuous (fun p : ↑(Metric.closedBall (0 : Base) baseRadius) => A p.val) :=
    hA.comp_continuous continuous_subtype_val (fun p => p.property)
  have hh := eventually_quartic_norm_le (fun p : ↑(Metric.closedBall (0 : Base) baseRadius) => A p.val)
    hcA radius hradius
  filter_upwards [hh] with s hs p hp w hw
  exact hs ⟨p, by simpa [Metric.mem_closedBall, dist_eq_norm] using hp⟩ w hw

 

def modelCollapseHomotopyEquiv {A : Base → Fin 4 → ℂ} {baseRadius : ℝ}
    (hA : ContinuousOn A (Metric.closedBall 0 baseRadius))
    (c : ℂ) (radius M alpha beta s : ℝ) (hradius : 0 < radius) (hM : 3 < M)
    (hweights : alpha+beta = 4)
    (hbound : ∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ, ‖w‖ ≤ radius →
      ‖rescaledQuartic A s p w‖ ≤ 2*radius^4) :
    ContinuousMap.HomotopyEquiv (Model (rescaledQuartic A s) baseRadius c radius M alpha beta)
      (CircleCollapse (onRootBase (rescaledQuartic A s) baseRadius c radius)) := by
  let R := onRootBase (rescaledQuartic A s) baseRadius c radius
  have hb : ∀ p : RootBase baseRadius c radius, Real.sqrt ‖R p‖ ≤ M*radius^2 := by
    intro p
    apply sqrt_quartic_bound hradius.le hM (norm_nonneg _)
    exact hbound p.1.val p.1.property.1 p.2.val (by
      have hd := Metric.mem_closedBall.mp p.2.property
      rwa [dist_zero_right] at hd)
  exact (weightedModelHomeomorph (rescaledQuartic A s) baseRadius c radius M alpha beta
      hradius hweights).symm.toHomotopyEquiv.trans
    (weightedBlockCollapseHomotopyEquiv R (M*radius^2) hb
      (continuous_onRootBase_rescaled hA c radius s) (radius^((alpha-beta)/2))
      (Real.rpow_pos_of_pos hradius _))

 

theorem exact_inner_models : ∃ baseRadius : ℝ, 0 < baseRadius ∧
    ∀ radius : ℝ, 0 < radius → ∀ M : ℝ, 3 < M → ∀ alpha beta : ℝ,
      alpha+beta = 4 → ∀ᶠ s : ℝ in 𝓝 0, 0 < s → ∀ c : ℂ,
        Nonempty (ContinuousMap.HomotopyEquiv (Model (R0 s) baseRadius c radius M alpha beta)
          (CircleCollapse (onRootBase (R0 s) baseRadius c radius))) ∧
        Nonempty (ContinuousMap.HomotopyEquiv (Model (R1 s) baseRadius c radius M alpha beta)
          (CircleCollapse (onRootBase (R1 s) baseRadius c radius))) := by
  obtain ⟨baseRadius, hb, h0, h1⟩ := common_base_cut
  refine ⟨baseRadius, hb, ?_⟩
  intro radius hr M hM alpha beta hweights
  filter_upwards [eventually_bound_on_base h0 radius hr, eventually_bound_on_base h1 radius hr]
    with s hs0 hs1 hpos c
  exact ⟨⟨modelCollapseHomotopyEquiv h0 c radius M alpha beta s hr hM hweights hs0⟩,
    ⟨modelCollapseHomotopyEquiv h1 c radius M alpha beta s hr hM hweights hs1⟩⟩

end

 

noncomputable section
open Preparation InnerQuartic InnerGeometry RootConfinement Filter Topology

 
def pi0 (q : ℂ × ℂ) : Base := ![q.1^2 + q1 q.1 q.2, q.1]
def pi1 (q : ℂ × ℂ) : Base := ![q.1, psi q.1 q.2]
def d0 (q : ℂ × ℂ) : ℂ := sourceH (pi0 q)
def d1 (q : ℂ × ℂ) : ℂ := sourceH (pi1 q)

lemma continuous_pi0 : Continuous pi0 := by unfold pi0 q1; fun_prop
lemma continuous_pi1 : Continuous pi1 := by unfold pi1 psi q2 q1; fun_prop

lemma low0_zero : low0 0 = 0 := by
  funext j
  simp only [low0, coeff0_spec.2.1]
  change (graph0 0).coeff j = 0
  rw [graph0_specialization, Polynomial.coeff_X_pow_mul', ite_eq_right (by omega)]

lemma low1_zero : low1 0 = 0 := by
  funext j
  simp only [low1, coeff1_spec.2.1]
  change (graph1 0).coeff j = 0
  rw [graph1_specialization, Polynomial.coeff_X_pow_mul', ite_eq_right (by omega)]

lemma root0_eq_quartic (p : Base) (w : ℂ) :
    root0 p w = w^4 + ∑ j : Fin 4, low0 p j*w^(j:ℕ) := by
  simp [root0, eval_rootPoly, low0]

lemma root1_eq_quartic (p : Base) (w : ℂ) :
    root1 p w = w^4 + ∑ j : Fin 4, low1 p j*w^(j:ℕ) := by
  simp [root1, eval_rootPoly, low1]

 
lemma eventually_root_graph : ∀ᶠ z : V 3 in 𝓝 0,
    (r0 z = 0 ↔ z 0 = (z 1)^2+q1 (z 1) (z 2)) ∧
    (r1 z = 0 ↔ z 1 = psi (z 0) (z 2)) := by
  have h0 : ∀ᶠ z in 𝓝 (0 : V 3), u0 z ≠ 0 :=
    u0_analytic.continuousAt.eventually_ne (by rw [u0_zero]; norm_num)
  have h1 : ∀ᶠ z in 𝓝 (0 : V 3), u1 z ≠ 0 :=
    u1_analytic.continuousAt.eventually_ne (by rw [u1_zero]; norm_num)
  filter_upwards [graph0_factor, graph1_factor, h0, h1] with z hz0 hz1 hn0 hn1
  constructor
  · have hh : r0 z = 0 ↔ z 0-(z 1)^2-q1 (z 1) (z 2) = 0 := by
      rw [hz0, mul_eq_zero, or_iff_left hn0]
    rw [hh]
    constructor <;> intro h <;> linear_combination h
  · have hh : r1 z = 0 ↔ z 1-psi (z 0) (z 2) = 0 := by
      rw [hz1, mul_eq_zero, or_iff_left hn1]
    exact hh.trans sub_eq_zero

 
def join (p : Base) (w : ℂ) : V 3 := ![p 0,p 1,w]

lemma join_small {p : Base} {w : ℂ} {r : ℝ} (hr : 0 < r)
    (hp : ‖p‖ < r) (hw : ‖w‖ < r) : ‖join p w‖ < r := by
  apply (pi_norm_lt_iff hr).mpr
  intro j
  fin_cases j
  · exact (norm_le_pi_norm p 0).trans_lt hp
  · exact (norm_le_pi_norm p 1).trans_lt hp
  · exact hw

lemma base3_join (p : Base) (w : ℂ) : base3 (join p w) = p := by
  ext j
  fin_cases j <;> rfl

 

theorem common_root_chart : ∃ baseRadius rootRadius : ℝ,
    0 < baseRadius ∧ 0 < rootRadius ∧
    ContinuousOn low0 (Metric.closedBall 0 baseRadius) ∧
    ContinuousOn low1 (Metric.closedBall 0 baseRadius) ∧
    (∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ,
      (root0 p w = 0 → ‖w‖ < rootRadius) ∧
      (root1 p w = 0 → ‖w‖ < rootRadius)) ∧
    (∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ, ‖w‖ < rootRadius →
      (root0 p w = 0 ↔ pi0 (p 1,w) = p) ∧
      (root1 p w = 0 ↔ pi1 (p 0,w) = p)) := by
  obtain ⟨r, hr, hsub⟩ := Metric.mem_nhds_iff.mp eventually_root_graph
  have hε : 0 < r/2 := by positivity
  have hall0 := eventually_all_roots_small low0 low0_analytic.continuousAt low0_zero (r/2) hε
  have hall1 := eventually_all_roots_small low1 low1_analytic.continuousAt low1_zero (r/2) hε
  have hcont : ∀ᶠ p : Base in 𝓝 0, ContinuousAt low0 p ∧ ContinuousAt low1 p := by
    filter_upwards [low0_analytic.eventually_analyticAt, low1_analytic.eventually_analyticAt]
      with p h0 h1
    exact ⟨h0.continuousAt,h1.continuousAt⟩
  obtain ⟨b, hb, hball⟩ := Metric.mem_nhds_iff.mp (hall0.and (hall1.and hcont))
  refine ⟨min b r / 2, r/2, by positivity, hε, ?_, ?_, ?_, ?_⟩
  · intro p hp
    have hp' : p ∈ Metric.ball (0 : Base) b := by
      rw [Metric.mem_ball, dist_zero_right]
      have hh := Metric.mem_closedBall.mp hp
      rw [dist_zero_right] at hh
      have hmin := min_le_left b r
      linarith
    exact (hball hp').2.2.1.continuousWithinAt
  · intro p hp
    have hp' : p ∈ Metric.ball (0 : Base) b := by
      rw [Metric.mem_ball, dist_zero_right]
      have hh := Metric.mem_closedBall.mp hp
      rw [dist_zero_right] at hh
      have hmin := min_le_left b r
      linarith
    exact (hball hp').2.2.2.continuousWithinAt
  · intro p hp w
    have hp' : p ∈ Metric.ball (0 : Base) b := by
      rw [Metric.mem_ball, dist_zero_right]
      have hmin := min_le_left b r
      linarith
    exact ⟨fun hz => (hball hp').1 w (by rwa [← root0_eq_quartic]),
      fun hz => (hball hp').2.1 w (by rwa [← root1_eq_quartic])⟩
  · intro p hp w hw
    have jp : join p w ∈ Metric.ball 0 r := by
      rw [Metric.mem_ball, dist_zero_right]
      apply join_small hr
      · have hmin := min_le_right b r
        linarith
      · linarith
    obtain ⟨h0,h1⟩ := hsub jp
    simp only [r0, r1, base3_join] at h0 h1
    constructor
    · constructor
      · intro hz
        ext j
        fin_cases j
        · exact (h0.mp hz).symm
        · rfl
      · intro he
        apply h0.mpr
        exact (congrFun he 0).symm
    · constructor
      · intro hz
        ext j
        fin_cases j
        · rfl
        · exact (h1.mp hz).symm
      · intro he
        apply h1.mpr
        exact (congrFun he 1).symm

 
abbrev RootPage (R : Base → ℂ → ℂ) (baseRadius : ℝ) (c : ℂ) (radius : ℝ) :=
  {g : RootBase baseRadius c radius // onRootBase R baseRadius c radius g = 0}

 
abbrev GraphPage (pi : ℂ × ℂ → Base) (baseRadius : ℝ) (c : ℂ) (rootRadius : ℝ) :=
  {q : ℂ × ℂ // ‖pi q‖ ≤ baseRadius ∧ ‖q.2‖ < rootRadius ∧ sourceH (pi q) = c}

section RootHomeomorph
variable (pi : ℂ × ℂ → Base) (j : Fin 2) (root R : Base → ℂ → ℂ)
variable (baseRadius rootRadius radius s : ℝ) (c : ℂ)
variable (hs : 0 < s) (hsize : s*rootRadius ≤ radius)
variable (hscale : ∀ p w, R p w = (s : ℂ)^4*root p (w/(s : ℂ)))
variable (hconfine : ∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ,
  root p w = 0 → ‖w‖ < rootRadius)
variable (hgraph : ∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ, ‖w‖ < rootRadius →
  (root p w = 0 ↔ pi (p j,w) = p))

include hs hscale in
lemma rootPage_unscaled_zero (g : RootPage R baseRadius c radius) :
    root g.val.1.val (g.val.2.val/(s : ℂ)) = 0 := by
  have hz := g.property
  change R g.val.1.val g.val.2.val = 0 at hz
  rw [hscale] at hz
  have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs.ne'
  exact (mul_eq_zero.mp hz).resolve_left (pow_ne_zero _ hs')

include hs hscale hconfine in
lemma rootPage_unscaled_small (g : RootPage R baseRadius c radius) :
    ‖g.val.2.val/(s : ℂ)‖ < rootRadius :=
  hconfine _ g.val.1.property.1 _ (rootPage_unscaled_zero root R _ _ _ _ hs hscale g)

include hs hscale hconfine hgraph in
lemma rootPage_graph_eq (g : RootPage R baseRadius c radius) :
    pi (g.val.1.val j,g.val.2.val/(s : ℂ)) = g.val.1.val :=
  (hgraph _ g.val.1.property.1 _
    (rootPage_unscaled_small root R _ _ _ _ _ hs hscale hconfine g)).mp
    (rootPage_unscaled_zero root R _ _ _ _ hs hscale g)

 
def rootToGraph (g : RootPage R baseRadius c radius) :
    GraphPage pi baseRadius c rootRadius := by
  let q : ℂ × ℂ := (g.val.1.val j,g.val.2.val/(s : ℂ))
  have he : pi q = g.val.1.val :=
    rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g
  refine ⟨q, ?_, ?_, ?_⟩
  · rw [he]; exact g.val.1.property.1
  · exact rootPage_unscaled_small root R _ _ _ _ _ hs hscale hconfine g
  · rw [he]; exact g.val.1.property.2

variable (hpi : ∀ q : ℂ × ℂ, pi q j = q.1)

 
def graphToRoot (q : GraphPage pi baseRadius c rootRadius) :
    RootPage R baseRadius c radius := by
  have hb : (s : ℂ)*q.val.2 ∈ Metric.closedBall 0 radius := by
    rw [Metric.mem_closedBall, dist_zero_right, norm_mul, Complex.norm_real,
      Real.norm_eq_abs, abs_of_pos hs]
    exact (mul_le_mul_of_nonneg_left q.property.2.1.le hs.le).trans hsize
  have hroot : root (pi q.val) q.val.2 = 0 :=
    (hgraph _ q.property.1 _ q.property.2.1).mpr (by rw [hpi])
  refine ⟨(⟨pi q.val, q.property.1, q.property.2.2⟩,
      ⟨(s : ℂ)*q.val.2, hb⟩), ?_⟩
  change R (pi q.val) ((s : ℂ)*q.val.2) = 0
  have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs.ne'
  rw [hscale, mul_div_cancel_left₀ _ hs', hroot, mul_zero]

lemma graph_root_left_inverse : Function.LeftInverse
    (graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi)
    (rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph) := by
  intro g
  apply Subtype.ext
  apply Prod.ext
  · apply Subtype.ext
    exact rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g
  · apply Subtype.ext
    change (s : ℂ)*(g.val.2.val/(s : ℂ)) = g.val.2.val
    have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs.ne'
    exact mul_div_cancel₀ _ hs'

lemma root_graph_right_inverse : Function.RightInverse
    (graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi)
    (rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph) := by
  intro q
  apply Subtype.ext
  apply Prod.ext
  · exact hpi q.val
  · change (s : ℂ)*q.val.2/(s : ℂ) = q.val.2
    have hs' : (s : ℂ) ≠ 0 := by exact_mod_cast hs.ne'
    exact mul_div_cancel_left₀ _ hs'

 

def rootGraphHomeomorph (hpi_cont : Continuous pi) :
    RootPage R baseRadius c radius ≃ₜ GraphPage pi baseRadius c rootRadius where
  toFun := rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph
  invFun := graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi
  left_inv := graph_root_left_inverse pi j root R _ _ _ _ _ hs hsize hscale hconfine hgraph hpi
  right_inv := root_graph_right_inverse pi j root R _ _ _ _ _ hs hsize hscale hconfine hgraph hpi
  continuous_toFun := by
    apply Continuous.subtype_mk
    change Continuous (fun g : RootPage R baseRadius c radius =>
      (g.val.1.val j,g.val.2.val/(s : ℂ)))
    have cp : Continuous (fun g : RootPage R baseRadius c radius => g.val.1.val) :=
      continuous_subtype_val.fst.subtype_val
    have cw : Continuous (fun g : RootPage R baseRadius c radius => g.val.2.val) :=
      continuous_subtype_val.snd.subtype_val
    exact ((continuous_apply j).comp cp).prodMk (cw.div_const (s : ℂ))
  continuous_invFun := by
    apply Continuous.subtype_mk
    apply Continuous.prodMk
    · apply Continuous.subtype_mk
      exact hpi_cont.comp continuous_subtype_val
    · apply Continuous.subtype_mk
      change Continuous (fun q : GraphPage pi baseRadius c rootRadius => (s : ℂ)*q.val.2)
      fun_prop

end RootHomeomorph

 

theorem exact_root_pages : ∃ baseRadius rootRadius : ℝ,
    0 < baseRadius ∧ 0 < rootRadius ∧
    ∀ radius : ℝ, 0 < radius → ∀ᶠ s : ℝ in 𝓝 0, 0 < s → ∀ c : ℂ,
      Nonempty (RootPage (R0 s) baseRadius c radius ≃ₜ
        GraphPage pi0 baseRadius c rootRadius) ∧
      Nonempty (RootPage (R1 s) baseRadius c radius ≃ₜ
        GraphPage pi1 baseRadius c rootRadius) := by
  obtain ⟨b, e, hb, he, _, _, hconf, hgraph⟩ := common_root_chart
  refine ⟨b, e, hb, he, ?_⟩
  intro radius hradius
  have hc : ContinuousAt (fun s : ℝ => s*e) 0 := by fun_prop
  have hsmall : ∀ᶠ s : ℝ in 𝓝 0, s*e < radius :=
    hc.eventually (gt_mem_nhds (by simpa using hradius))
  filter_upwards [hsmall] with s hsize hs c
  constructor
  · exact ⟨rootGraphHomeomorph pi0 1 root0 (R0 s) b e radius s c hs hsize.le
      (R0_eq_source s hs.ne') (fun p hp w => (hconf p hp w).1)
      (fun p hp w hw => (hgraph p hp w hw).1) (fun _ => rfl) continuous_pi0⟩
  · exact ⟨rootGraphHomeomorph pi1 0 root1 (R1 s) b e radius s c hs hsize.le
      (R1_eq_source s hs.ne') (fun p hp w => (hconf p hp w).2)
      (fun p hp w hw => (hgraph p hp w hw).2) (fun _ => rfl) continuous_pi1⟩

end

 

noncomputable section
open InnerGeometry Preparation Filter Topology CategoryTheory

 
def graphPageProjection (pi : ℂ × ℂ → Base) (hpi : Continuous pi)
    (baseRadius : ℝ) (c : ℂ) (rootRadius : ℝ) :
    C(GraphPage pi baseRadius c rootRadius, BasePage baseRadius c) where
  toFun q := ⟨pi q.val, q.property.1, q.property.2.2⟩
  continuous_toFun := (hpi.comp continuous_subtype_val).subtype_mk _

 
def rootPageProjection (R : Base → ℂ → ℂ)
    (baseRadius : ℝ) (c : ℂ) (radius : ℝ) :
    C(RootPage R baseRadius c radius, BasePage baseRadius c) where
  toFun g := g.val.1
  continuous_toFun := continuous_fst.comp continuous_subtype_val

section Naturality
variable (pi : ℂ × ℂ → Base) (j : Fin 2) (root R : Base → ℂ → ℂ)
variable (baseRadius rootRadius radius s : ℝ) (c : ℂ)
variable (hs : 0 < s) (hsize : s*rootRadius ≤ radius)
variable (hscale : ∀ p w, R p w = (s : ℂ)^4*root p (w/(s : ℂ)))
variable (hconfine : ∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ,
  root p w = 0 → ‖w‖ < rootRadius)
variable (hgraph : ∀ p : Base, ‖p‖ ≤ baseRadius → ∀ w : ℂ, ‖w‖ < rootRadius →
  (root p w = 0 ↔ pi (p j,w) = p))
variable (hpi : ∀ q : ℂ × ℂ, pi q j = q.1) (hcont : Continuous pi)

lemma rootGraphHomeomorph_over_base :
    (graphPageProjection pi hcont baseRadius c rootRadius).comp
      (rootGraphHomeomorph pi j root R baseRadius rootRadius radius s c
        hs hsize hscale hconfine hgraph hpi hcont).toHomotopyEquiv.toFun =
      rootPageProjection R baseRadius c radius := by
  apply ContinuousMap.ext
  intro g
  apply Subtype.ext
  exact rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g

 

lemma rootGraphHomeomorph_homology_over_base (n : ℕ) :
    (integralHomologyFunctor n).map (TopCat.ofHom
      (rootGraphHomeomorph pi j root R baseRadius rootRadius radius s c
        hs hsize hscale hconfine hgraph hpi hcont).toHomotopyEquiv.toFun) ≫
    (integralHomologyFunctor n).map (TopCat.ofHom
      (graphPageProjection pi hcont baseRadius c rootRadius)) =
    (integralHomologyFunctor n).map (TopCat.ofHom
      (rootPageProjection R baseRadius c radius)) := by
  rw [← Functor.map_comp]
  have he := rootGraphHomeomorph_over_base pi j root R baseRadius rootRadius radius s c
      hs hsize hscale hconfine hgraph hpi hcont
  exact congrArg ((integralHomologyFunctor n).map ∘ TopCat.ofHom) he

end Naturality

 
def baseSection (baseRadius : ℝ) (c : ℂ) (radius : ℝ) (hradius : 0 ≤ radius) :
    C(BasePage baseRadius c, RootBase baseRadius c radius) where
  toFun p := (p, ⟨0, by simpa using hradius⟩)
  continuous_toFun := continuous_id.prodMk continuous_const

 
def rootBaseHomotopyEquiv (baseRadius : ℝ) (c : ℂ) (radius : ℝ) (hradius : 0 ≤ radius) :
    ContinuousMap.HomotopyEquiv (RootBase baseRadius c radius) (BasePage baseRadius c) where
  toFun := ⟨Prod.fst, continuous_fst⟩
  invFun := baseSection baseRadius c radius hradius
  left_inv := by
    refine ⟨{ toFun := fun z => (z.2.1, ⟨(z.1 : ℝ) • z.2.2.val, ?_⟩)
              continuous_toFun := ?_
              map_zero_left := ?_
              map_one_left := ?_ }⟩
    · rw [Metric.mem_closedBall, dist_zero_right, norm_smul, Real.norm_eq_abs,
        abs_of_nonneg z.1.property.1]
      have hw := Metric.mem_closedBall.mp z.2.2.property
      rw [dist_zero_right] at hw
      exact (mul_le_of_le_one_left (norm_nonneg _) z.1.property.2).trans hw
    · apply Continuous.prodMk
      · exact continuous_snd.fst
      · apply Continuous.subtype_mk
        exact continuous_fst.subtype_val.smul continuous_snd.snd.subtype_val
    · intro g
      apply Prod.ext
      · rfl
      · apply Subtype.ext
        simp [baseSection]
    · intro g
      apply Prod.ext
      · rfl
      · apply Subtype.ext
        simp
  right_inv := by
    apply ContinuousMap.Homotopic.refl

 
def rootBaseHomologyIso (baseRadius : ℝ) (c : ℂ) (radius : ℝ) (hradius : 0 ≤ radius)
    (n : ℕ) : IntegralHomology n (RootBase baseRadius c radius) ≅
      IntegralHomology n (BasePage baseRadius c) :=
  integralHomologyIso (rootBaseHomotopyEquiv baseRadius c radius hradius) n

end
end AmbientMultiplicity.SourceInnerPage

end OAI