import Mathlib
import OAI.Algebra.GroupRing.Simplicial

namespace OAI

noncomputable section

open Set Metric Topology BigOperators
open Set Metric Topology

namespace GroupRingTopology.Cellular
universe u
variable {X : Type u} [TopologicalSpace X] [T2Space X]
variable {C : Set X} [CWComplex C]

omit [T2Space X] in
/-- Closure finiteness in terms of a single finite list of open cells. -/
lemma closedCell_subset_finite_openCells (n : ℕ) (i : RelCWComplex.cell C n) :
    ∃ I : Finset (Σ m, RelCWComplex.cell C m),
      CWComplex.closedCell n i ⊆ ⋃ p ∈ I, CWComplex.openCell p.1 p.2 := by
  classical
  obtain ⟨J,hJ⟩ := CWComplex.cellFrontier_subset_finite_openCell n i
  refine ⟨insert ⟨n,i⟩ ((Finset.range n).sigma J),?_⟩
  intro x hx
  rw [← CWComplex.cellFrontier_union_openCell_eq_closedCell] at hx
  rcases hx with hx | hx
  swap
  · exact Set.mem_iUnion.mpr ⟨⟨n,i⟩,Set.mem_iUnion.mpr ⟨Finset.mem_insert_self _ _,hx⟩⟩
  · have hxx := hJ hx
    simp only [Set.mem_iUnion] at hxx
    obtain ⟨m,hm,j,hj,hx⟩ := hxx
    exact Set.mem_iUnion.mpr ⟨⟨m,j⟩,Set.mem_iUnion.mpr
      ⟨Finset.mem_insert_of_mem (by simp only [Finset.mem_sigma,Finset.mem_range]; exact ⟨hm,hj⟩),hx⟩⟩

/-- Any selection of at most one point from each open cell has all its subsets
closed. This is the closure-finite weak-topology argument behind compactness. -/
lemma cellSelection_closed {I : Type u} (c : I → Σ n, RelCWComplex.cell C n)
    (hc : Function.Injective c) (x : I → X)
    (hx : ∀ i, x i ∈ CWComplex.openCell (c i).1 (c i).2) (S : Set X)
    (hS : S ⊆ Set.range x) : IsClosed S := by
  apply (CWComplex.closed C S ?_).mpr
  · intro n j
    obtain ⟨J,hJ⟩ := closedCell_subset_finite_openCells n j
    have hfinite : (S ∩ CWComplex.closedCell n j).Finite := by
      have hcpre : (c ⁻¹' (J : Set (Σ n, RelCWComplex.cell C n))).Finite :=
        J.finite_toSet.preimage hc.injOn
      apply (hcpre.image x).subset
      rintro y ⟨hyS,hycell⟩
      obtain ⟨i,rfl⟩ := hS hyS
      have hxx := hJ hycell
      simp only [Set.mem_iUnion] at hxx
      obtain ⟨p,hpJ,hxp⟩ := hxx
      have heq : c i = p := by
        by_contra hne
        exact (CWComplex.disjoint_openCell_of_ne hne).notMem_of_mem_left (hx i) hxp
      exact ⟨i,by change c i ∈ J; rw [heq]; exact hpJ,rfl⟩
    exact hfinite.isClosed
  · rintro y hy
    obtain ⟨i,rfl⟩ := hS hy
    exact CWComplex.openCell_subset_complex (c i).1 (c i).2 (hx i)

/-- A compact part of a CW complex can meet only finitely many open cells. -/
theorem compact_finitely_many_cells {K : Set X} (hK : IsCompact K) :
    {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}.Finite := by
  classical
  let I := {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}
  let x : I → X := fun i => i.2.choose
  have hx (i : I) : x i ∈ CWComplex.openCell i.1.1 i.1.2 := i.2.choose_spec.2
  have hxK (i : I) : x i ∈ K := i.2.choose_spec.1
  have hinj : Function.Injective x := by
    intro i j hij
    apply Subtype.ext
    by_contra hne
    exact (CWComplex.disjoint_openCell_of_ne hne).notMem_of_mem_left (hx i) (hij ▸ hx j)
  have hall : ∀ S ⊆ Set.range x, IsClosed S :=
    cellSelection_closed (C := C) Subtype.val Subtype.val_injective x hx
  have hcompact : IsCompact (Set.range x) :=
    hK.of_isClosed_subset (hall _ subset_rfl) (Set.range_subset_iff.mpr hxK)
  have hdiscrete : IsDiscrete (Set.range x) := by
    apply isDiscrete_iff_forall_mem_exists_isClosed.mpr
    intro S hS
    exact ⟨S,hall S hS,Set.inter_eq_left.mpr hS⟩
  have hrange := hcompact.finite hdiscrete
  have : Finite I := (Set.finite_range_iff hinj).mp hrange
  exact Set.toFinite I

/-- Compact maps cannot run out through infinitely many dimensions. -/
theorem compact_bounded_skeleton {K : Set X} (hK : IsCompact K) (hKC : K ⊆ C) :
    ∃ n : ℕ, K ⊆ CWComplex.skeletonLT C n := by
  classical
  let S := {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}
  have hS : S.Finite := compact_finitely_many_cells hK
  let I := hS.toFinset
  refine ⟨I.sup (fun p => p.1+1),?_⟩
  intro x hx
  have hxC := hKC hx
  rw [← CWComplex.iUnion_openCell_eq_complex (C := C)] at hxC
  simp only [Set.mem_iUnion] at hxC
  obtain ⟨m,j,hj⟩ := hxC
  have hmem : (⟨m,j⟩ : Σ n, RelCWComplex.cell C n) ∈ I := by
    exact hS.mem_toFinset.mpr ⟨x,hx,hj⟩
  have hm : m+1 ≤ I.sup (fun p => p.1+1) := Finset.le_sup (f := fun p => p.1+1) hmem
  apply CWComplex.skeletonLT_mono (C := C)
    (m := (m : ℕ∞)+1) (n := ((I.sup (fun p => p.1+1) : ℕ) : ℕ∞)) (by exact_mod_cast hm)
  exact CWComplex.closedCell_subset_skeletonLT m j (CWComplex.openCell_subset_closedCell m j hj)

/-- The bounded-skeleton property in its map form, used for spheres and disks. -/
theorem compactMap_bounded_skeleton {A : Type*} [TopologicalSpace A] [CompactSpace A]
    (f : C(A,X)) (hf : ∀ a, f a ∈ C) :
    ∃ n : ℕ, ∀ a, f a ∈ CWComplex.skeletonLT C n := by
  obtain ⟨n,hn⟩ := compact_bounded_skeleton (C := C) (isCompact_range f.continuous)
    (Set.range_subset_iff.mpr hf)
  exact ⟨n,fun a => hn (Set.mem_range_self a)⟩

end GroupRingTopology.Cellular

namespace GroupRingTopology.Simplicial
open Set Metric Topology BigOperators
open scoped Classical
universe u
variable {V : Type u} (K : PreAbstractSimplicialComplex V)

lemma compact_bounded_vertices {A : Set (Space K)} (hA : IsCompact A) :
    ∃ S : Finset V, ∀ x ∈ A, x.1.support ⊆ S := by
  let T := {p : Σ n, Topology.RelCWComplex.cell (Set.univ : Set (Space K)) n |
    (A ∩ CWComplex.openCell p.1 p.2).Nonempty}
  have hT : T.Finite := Cellular.compact_finitely_many_cells hA
  let S := hT.toFinset.biUnion (fun p => p.2.1.1)
  refine ⟨S,?_⟩
  intro x hx
  let s : Face K := ⟨x.1.support,x.2.2.2⟩
  let c := cellOfFace K s
  have hc : (⟨s.1.card-1,c⟩ : Σ n, Topology.RelCWComplex.cell (Set.univ : Set (Space K)) n) ∈ hT.toFinset := by
    rw [hT.mem_toFinset]
    refine ⟨x,hx,?_⟩
    change x ∈ characteristicPE K c '' ball 0 1
    rw [characteristicPE_open]
    rfl
  exact Finset.subset_biUnion_of_mem (fun p => p.2.1.1) hc

end GroupRingTopology.Simplicial

open Set Metric Topology
namespace GroupRingTopology.SphereTopology
abbrev Disk (n : ℕ) := closedBall (0 : Fin n → ℝ) 1
abbrev Sphere (n : ℕ) := sphere (0 : Fin n → ℝ) 1

def boundary (n : ℕ) : C(Sphere n,Disk n) :=
  ⟨fun x => ⟨x.1,sphere_subset_closedBall x.2⟩,continuous_subtype_val.subtype_mk _⟩

lemma sphere_norm {n : ℕ} (x : Sphere n) : ‖x.1‖ = 1 := by
  simpa only [mem_sphere,dist_zero_right] using x.2
lemma disk_norm {n : ℕ} (x : Disk n) : ‖x.1‖ ≤ 1 := by
  simpa only [mem_closedBall,dist_zero_right] using x.2

def cone (n : ℕ) : C(unitInterval × Sphere n,Disk n) := by
  have hm (p : unitInterval × Sphere n) : (p.1:ℝ) • p.2.1 ∈ closedBall (0 : Fin n → ℝ) 1 := by
    simp only [mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_nonneg p.1.2.1,sphere_norm,mul_one]
    exact p.1.2.2
  exact ⟨fun p => ⟨(p.1:ℝ) • p.2.1,hm p⟩,
    ((continuous_subtype_val.comp continuous_fst).smul
      (continuous_subtype_val.comp continuous_snd)).subtype_mk hm⟩

lemma cone_norm {n : ℕ} (p : unitInterval × Sphere n) : ‖(cone n p).1‖ = (p.1:ℝ) := by
  simp only [cone,ContinuousMap.coe_mk,norm_smul,Real.norm_eq_abs,abs_of_nonneg p.1.2.1,sphere_norm,mul_one]

lemma cone_surjective (n : ℕ) [Nonempty (Sphere n)] : Function.Surjective (cone n) := by
  intro x
  by_cases hx : x.1 = 0
  · obtain ⟨s⟩ := ‹Nonempty (Sphere n)›
    refine ⟨(0,s),Subtype.ext ?_⟩
    simp only [cone,ContinuousMap.coe_mk,Set.Icc.coe_zero,zero_smul,hx]
  · let s : Sphere n := ⟨‖x.1‖⁻¹ • x.1,by
      simp only [mem_sphere,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_inv,abs_norm,
        inv_mul_cancel₀ (norm_ne_zero_iff.mpr hx)]⟩
    refine ⟨(⟨‖x.1‖,norm_nonneg _,disk_norm x⟩,s),Subtype.ext ?_⟩
    change ‖x.1‖ • (‖x.1‖⁻¹ • x.1) = x.1
    rw [smul_smul,mul_inv_cancel₀ (norm_ne_zero_iff.mpr hx),one_smul]

lemma cone_quotient (n : ℕ) [Nonempty (Sphere n)] : IsQuotientMap (cone n) :=
  IsQuotientMap.of_surjective_continuous (cone_surjective n) (cone n).continuous

variable {Y : Type*} [TopologicalSpace Y] {n : ℕ}

def Extends (f : C(Sphere n,Y)) : Prop := ∃ F : C(Disk n,Y), F.comp (boundary n) = f

lemma extends_of_nullhomotopic [Nonempty (Sphere n)] {y : Y} {f : C(Sphere n,Y)}
    (H : (ContinuousMap.const (Sphere n) y).Homotopy f) : Extends f := by
  have hf : Function.FactorsThrough H.toContinuousMap (cone n) := by
    intro p q hpq
    have ht : p.1 = q.1 := Subtype.ext ((cone_norm p).symm.trans ((congrArg (fun z : Disk n => ‖z.1‖) hpq).trans (cone_norm q)))
    by_cases hzero : (p.1:ℝ) = 0
    · have hp : p.1 = 0 := Subtype.ext hzero
      have hq : q.1 = 0 := ht.symm.trans hp
      change H (p.1,p.2) = H (q.1,q.2)
      rw [hp,hq,H.apply_zero,H.apply_zero]
      rfl
    · have hs : p.2 = q.2 := by
        apply Subtype.ext
        have heq := congrArg (fun z : Disk n => z.1) hpq
        change (p.1:ℝ) • p.2.1 = (q.1:ℝ) • q.2.1 at heq
        rw [← ht] at heq
        exact (smul_right_injective _ hzero) heq
      exact congrArg H.toContinuousMap (Prod.ext ht hs)
  let F : C(Disk n,Y) := (cone_quotient n).lift H.toContinuousMap hf
  refine ⟨F,?_⟩
  ext s
  have hh := ContinuousMap.congr_fun ((cone_quotient n).lift_comp H.toContinuousMap hf) (1,s)
  have hcone : cone n (1,s) = boundary n s := by apply Subtype.ext; simp [cone,boundary]
  simpa only [ContinuousMap.comp_apply,hcone,ContinuousMap.Homotopy.coe_toContinuousMap,
    ContinuousMap.Homotopy.apply_one] using hh

lemma nullhomotopic_of_extends {f : C(Sphere n,Y)} (hf : Extends f) :
    ∃ y : Y, Nonempty ((ContinuousMap.const (Sphere n) y).Homotopy f) := by
  obtain ⟨F,hF⟩ := hf
  let z : Disk n := ⟨0,by simp⟩
  refine ⟨F z,⟨{
    toFun := fun p => F (cone n p)
    continuous_toFun := F.continuous.comp (cone n).continuous
    map_zero_left := ?_
    map_one_left := ?_ }⟩⟩
  · intro s
    exact congrArg F (Subtype.ext (by simp [cone,z]))
  · intro s
    have hs : cone n (1,s) = boundary n s := by apply Subtype.ext; simp [cone,boundary]
    rw [hs]
    exact ContinuousMap.congr_fun hF s

lemma extends_of_homotopy [Nonempty (Sphere n)] {f g : C(Sphere n,Y)}
    (H : f.Homotopy g) (hg : Extends g) : Extends f := by
  obtain ⟨y,⟨J⟩⟩ := nullhomotopic_of_extends hg
  exact extends_of_nullhomotopic (J.trans H.symm)

lemma sphere_nonempty (n : ℕ) : Nonempty (Sphere (n+1)) :=
  (NormedSpace.sphere_nonempty.mpr (by norm_num : (0:ℝ) ≤ 1)).coe_sort

end GroupRingTopology.SphereTopology

/-! Classical cellular lifting and its geometric foundations.
No classifying-space existence or Hurewicz theorem is assumed. -/
open Set Metric Topology

namespace GroupRingTopology.Cellular
universe u v w

abbrev Disk (n : ℕ) := closedBall (0 : Fin n → ℝ) 1
abbrev Sphere (n : ℕ) := sphere (0 : Fin n → ℝ) 1

def boundary (n : ℕ) : Sphere n → Disk n :=
  fun x => ⟨x.1, sphere_subset_closedBall x.2⟩

lemma continuous_boundary (n : ℕ) : Continuous (boundary n) :=
  continuous_subtype_val.subtype_mk _

variable {X : Type u} [TopologicalSpace X] [T2Space X]
variable {C : Set X} [CWComplex C]

/-- A characteristic map on its closed disk. -/
def characteristic (n : ℕ) (i : RelCWComplex.cell C n) : C(Disk n, X) :=
  ⟨fun x => RelCWComplex.map n i x.1, (RelCWComplex.continuousOn n i).domRestrict⟩

omit [T2Space X] in
lemma range_characteristic (n : ℕ) (i : RelCWComplex.cell C n) :
    Set.range (characteristic n i) = CWComplex.closedCell n i := by
  ext x
  constructor
  · rintro ⟨y,rfl⟩; exact ⟨y.1,y.2,rfl⟩
  · rintro ⟨y,hy,rfl⟩; exact ⟨⟨y,hy⟩,rfl⟩

/-- The weak topology is genuinely final with respect to closed characteristic
maps; no finiteness or local-finiteness hypothesis is needed. -/
lemma continuousOn_iff_characteristic {Y : Type v} [TopologicalSpace Y] (f : X → Y) :
    ContinuousOn f C ↔ ∀ n (i : RelCWComplex.cell C n),
      Continuous (f ∘ characteristic n i) := by
  constructor
  · intro hf n i
    exact hf.comp_continuous (characteristic n i).continuous
      (fun x => CWComplex.closedCell_subset_complex n i ⟨x.1,x.2,rfl⟩)
  · intro hf
    rw [continuousOn_iff_continuous_domRestrict, continuous_iff_isClosed]
    intro S hS
    have hclosed : IsClosed (C ∩ f ⁻¹' S) := by
      apply (CWComplex.closed C _ inter_subset_left).2
      intro n i
      have hpre : IsClosed ((f ∘ characteristic n i) ⁻¹' S) :=
        hS.preimage (hf n i)
      have hcompact := hpre.isCompact.image (characteristic n i).continuous
      convert hcompact.isClosed using 1
      ext x
      constructor
      · rintro ⟨⟨hxC,hxS⟩, y,hy,rfl⟩
        exact ⟨⟨y,hy⟩,hxS,rfl⟩
      · rintro ⟨y,hy,rfl⟩
        exact ⟨⟨CWComplex.closedCell_subset_complex n i ⟨y.1,y.2,rfl⟩,hy⟩,
          y.1,y.2,rfl⟩
    convert hclosed.preimage continuous_subtype_val using 1
    ext x
    simp only [Set.mem_preimage, Set.mem_inter_iff, and_iff_right x.2, Set.domRestrict_apply]

abbrev Skeleton (C : Set X) [CWComplex C] (n : ℕ) : Set X :=
  CWComplex.skeletonLT C n

lemma skeleton_mono {m n : ℕ} (h : m ≤ n) :
    Skeleton C m ⊆ Skeleton C n :=
  CWComplex.skeletonLT_mono (by exact_mod_cast h)

lemma sphere_mem_skeleton (n : ℕ) (i : RelCWComplex.cell C n) (x : Sphere n) :
    characteristic n i (boundary n x) ∈ Skeleton C n :=
  CWComplex.cellFrontier_subset_skeletonLT n i ⟨x.1,x.2,rfl⟩

lemma characteristic_mem_skeleton {m n : ℕ} (h : m < n)
    (i : RelCWComplex.cell C m) (x : Disk m) :
    characteristic m i x ∈ Skeleton C n := by
  apply skeleton_mono (Nat.succ_le_of_lt h)
  exact CWComplex.closedCell_subset_skeletonLT m i ⟨x.1,x.2,rfl⟩

lemma openCell_not_skeleton (n : ℕ) (i : RelCWComplex.cell C n) {x : X}
    (hx : x ∈ CWComplex.openCell n i) : x ∉ Skeleton C n :=
  (CWComplex.disjoint_skeletonLT_openCell (C := C) (j := i) le_rfl).notMem_of_mem_right hx

/-- A continuous partial lift on the (n-1)-skeleton, represented by a total
function only to avoid transported subtype terms. Values outside the skeleton
carry no condition and are never used. -/
structure PartialLift {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B]
    (p : C(E,B)) (f : C(X,B)) (n : ℕ) where
  val : X → E
  continuousOn : ContinuousOn val (Skeleton C n)
  fac : ∀ x ∈ Skeleton C n, p (val x) = f x

/-- The concrete disk-boundary right lifting property. -/
def DiskRLP {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B]
    (p : C(E,B)) : Prop :=
  ∀ n (a : C(Sphere n,E)) (b : C(Disk n,B)),
    (∀ x, p (a x) = b (boundary n x)) →
    ∃ e : C(Disk n,E), (∀ x, e (boundary n x) = a x) ∧ ∀ x, p (e x) = b x

variable {E : Type v} [TopologicalSpace E] {n : ℕ}

/-- Glue the old skeleton map to a prescribed disk map on each new cell. -/
noncomputable def attachValue (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
    (x : X) : E := by
  classical
  exact if x ∈ Skeleton C n then a x
    else if h : ∃ i : RelCWComplex.cell C n, x ∈ CWComplex.openCell n i then
      let i := h.choose
      let y := h.choose_spec.choose
      e i ⟨y,ball_subset_closedBall h.choose_spec.choose_spec.1⟩
    else a x

lemma attachValue_old (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
    {x : X} (hx : x ∈ Skeleton C n) : attachValue a e x = a x := by
  classical
  simp only [attachValue, ite_eq_left hx]

lemma attachValue_interior (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
    (i : RelCWComplex.cell C n) (y : Disk n) (hy : y.1 ∈ ball 0 1) :
    attachValue a e (characteristic n i y) = e i y := by
  classical
  have hx : characteristic n i y ∈ CWComplex.openCell n i := ⟨y.1,hy,rfl⟩
  have h : ∃ j : RelCWComplex.cell C n,
      characteristic n i y ∈ CWComplex.openCell n j := ⟨i,hx⟩
  rw [attachValue,ite_eq_right (openCell_not_skeleton n i hx),dite_eq_left h]
  have hi : h.choose = i := by
    by_contra hne
    have hd := CWComplex.disjoint_openCell_of_ne (C := C) (i := h.choose) (j := i)
      (fun hEq => hne (sigma_mk_injective hEq))
    exact Set.disjoint_left.mp hd h.choose_spec hx
  have hz := h.choose_spec.choose_spec.1
  have hmap : RelCWComplex.map n i h.choose_spec.choose = characteristic n i y := by
    calc
      RelCWComplex.map n i h.choose_spec.choose =
          RelCWComplex.map n h.choose h.choose_spec.choose :=
        congrArg (fun k => RelCWComplex.map n k h.choose_spec.choose) hi.symm
      _ = _ := h.choose_spec.choose_spec.2
  have hcoord : h.choose_spec.choose = y.1 :=
    (RelCWComplex.map n i).injOn
      (by simpa only [RelCWComplex.source_eq] using hz)
      (by simpa only [RelCWComplex.source_eq] using hy) hmap
  exact (congrArg (fun k => e k ⟨h.choose_spec.choose,ball_subset_closedBall hz⟩) hi).trans
    (congrArg (e i) (Subtype.ext hcoord))

lemma attachValue_characteristic (a : X → E)
    (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
    (he : ∀ i (x : Sphere n), e i (boundary n x) =
      a (characteristic n i (boundary n x)))
    (i : RelCWComplex.cell C n) (y : Disk n) :
    attachValue a e (characteristic n i y) = e i y := by
  by_cases hy : y.1 ∈ ball 0 1
  · exact attachValue_interior a e i y hy
  · have hs : y.1 ∈ sphere 0 1 := le_antisymm y.2 (le_of_not_gt hy)
    have hx : characteristic n i y ∈ Skeleton C n := sphere_mem_skeleton n i ⟨y,hs⟩
    rw [attachValue_old a e hx]
    exact (he i ⟨y,hs⟩).symm

lemma attachValue_continuous (a : X → E) (ha : ContinuousOn a (Skeleton C n))
    (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
    (he : ∀ i (x : Sphere n), e i (boundary n x) =
      a (characteristic n i (boundary n x))) :
    ContinuousOn (attachValue a e) (Skeleton C (n+1)) := by
  apply (continuousOn_iff_characteristic (C := Skeleton C (n+1)) _).2
  intro m j
  change Continuous (fun x : Disk m => attachValue a e (characteristic m j.1 x))
  have hm : m < n+1 := by
    have h : (m : ℕ∞) < ((n+1 : ℕ) : ℕ∞) := by
      simpa only [RelCWComplex.skeletonLT_I,Set.mem_ofPred_eq] using j.2
    exact_mod_cast h
  rcases Nat.lt_succ_iff_lt_or_eq.mp hm with hm | hm
  · have hEq : (fun x : Disk m => attachValue a e (characteristic m j.1 x)) =
        (fun x : Disk m => a (characteristic m j.1 x)) := by
      funext x
      exact attachValue_old a e (characteristic_mem_skeleton hm j.1 x)
    rw [hEq]
    exact ha.comp_continuous (characteristic m j.1).continuous
      (characteristic_mem_skeleton hm j.1)
  · subst m
    have hEq : (fun x : Disk n => attachValue a e (characteristic n j.1 x)) = e j.1 := by
      funext x
      exact attachValue_characteristic a e he j.1 x
    rw [hEq]
    exact (e j.1).continuous

end GroupRingTopology.Cellular

end

end OAI