l3lab/ntp-mathlib huggingface dataset:
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ EqvGen
    (Types.CoequalizerRel ⇑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ⇑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y

Next tactic:
have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
    simp
    rfl
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ colimit.ι diagram one x = colimit.ι diagram one y

Next tactic:
dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      x =
    (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ colimit.ι diagram one x = colimit.ι diagram one y

Next tactic:
erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
    

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      x =
    (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ (preservesColimitIso (forget TopCat)
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom
      ((colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
        y) =
    (⇑(colimit.ι
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
            one) ≫
        (preservesColimitIso (forget TopCat)
            (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
              (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom)
      y

Next tactic:
simp
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
    simp
    

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      x =
    (colimit.ι
        (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
        one)
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
⊢ (preservesColimitIso (forget TopCat)
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom
      ((colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
        y) =
    (preservesColimitIso (forget TopCat)
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))).hom
      ((colimit.ι
          (parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
            (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
          one)
        y)

Next tactic:
rfl
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
    simp
    rfl
  

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
this : colimit.ι diagram one x = colimit.ι diagram one y
⊢ EqvGen
    (Types.CoequalizerRel ⇑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ⇑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y

Next tactic:
have :
    (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ =
      (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ :=
    (congr_arg
        (colim.map (diagramIsoParallelPair diagram).hom ≫
          (colimit.isoColimitCocone (Types.coequalizerColimit _ _)).hom)
        this :
      _)
theorem eqvGen_of_π_eq
    -- Porting note: was `{x y : ∐ D.U} (h : 𝖣.π x = 𝖣.π y)`
    {x y : sigmaObj (β := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
    (h : 𝖣.π x = 𝖣.π y) :
    EqvGen
      -- Porting note: was (Types.CoequalizerRel 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      (Types.CoequalizerRel
        (X := sigmaObj (β := D.toGlueData.diagram.L) (C := TopCat) (D.toGlueData.diagram).left)
        (Y := sigmaObj (β := D.toGlueData.diagram.R) (C := TopCat) (D.toGlueData.diagram).right)
        𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap)
      x y := by
  delta GlueData.π Multicoequalizer.sigmaπ at h
  -- Porting note: inlined `inferInstance` instead of leaving as a side goal.
  replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer 𝖣.diagram).inv).mp
    inferInstance h
  let diagram := parallelPair 𝖣.diagram.fstSigmaMap 𝖣.diagram.sndSigmaMap ⋙ forget _
  have : colimit.ι diagram one x = colimit.ι diagram one y := by
    dsimp only [coequalizer.π, ContinuousMap.toFun_eq_coe] at h
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    erw [← ι_preservesColimitsIso_hom, forget_map_eq_coe, types_comp_apply, h]
    simp
    rfl
  have :
    (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ =
      (colimit.ι diagram _ ≫ colim.map _ ≫ (colimit.isoColimitCocone _).hom) _ :=
    (congr_arg
        (colim.map (diagramIsoParallelPair diagram).hom ≫
          (colimit.isoColimitCocone (Types.coequalizerColimit _ _)).hom)
        this :
      _)
  -- Porting note: was
  -- simp only [eqToHom_refl, types_comp_apply, colimit.ι_map_assoc,
  --   diagramIsoParallelPair_hom_app, colimit.isoColimitCocone_ι_hom, types_id_apply] at this
  -- See https://github.com/leanprover-community/mathlib4/issues/5026
  rw [colimit.ι_map_assoc, diagramIsoParallelPair_hom_app, eqToHom_refl,
    colimit.isoColimitCocone_ι_hom, types_comp_apply, types_id_apply, types_comp_apply,
    types_id_apply] at this
  

Proof state:
D : GlueData
x y : ↑(∐ D.U)
h :
  (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      x =
    (coequalizer.π (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
          (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))).1
      y
diagram : WalkingParallelPair ⥤ Type u :=
  parallelPair (MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      (MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)) ⋙
    forget TopCat
this✝ : colimit.ι diagram one x = colimit.ι diagram one y
this :
  (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
              (diagram.map WalkingParallelPairHom.right)).cocone.ι.app
      one x =
    (Types.coequalizerColimit (diagram.map WalkingParallelPairHom.left)
              (diagram.map WalkingParallelPairHom.right)).cocone.ι.app
      one y
⊢ EqvGen
    (Types.CoequalizerRel ⇑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData))
      ⇑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData)))
    x y

Next tactic:
exact Quot.eq.1 this
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  

Proof state:
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ (GlueData.ι D.toGlueData i) x = (GlueData.ι D.toGlueData j) y ↔ Rel D { fst := i, snd := x } { fst := j, snd := y }

Next tactic:
constructor
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · 

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ (GlueData.ι D.toGlueData i) x = (GlueData.ι D.toGlueData j) y → Rel D { fst := i, snd := x } { fst := j, snd := y }

Next tactic:
delta GlueData.ι
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ (Multicoequalizer.π (GlueData.diagram D.toGlueData) i) x = (Multicoequalizer.π (GlueData.diagram D.toGlueData) j) y →
    Rel D { fst := i, snd := x } { fst := j, snd := y }

Next tactic:
simp_rw [← Multicoequalizer.ι_sigmaπ]
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
⊢ (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
      (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y →
    Rel D { fst := i, snd := x } { fst := j, snd := y }

Next tactic:
intro h
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D { fst := i, snd := x } { fst := j, snd := y }

Next tactic:
rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D (((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := i, snd := x }) { fst := j, snd := y }

Next tactic:
rw [←
      show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    rw [←
      show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ Rel D (((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := i, snd := x })
    (((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) { fst := j, snd := y })

Next tactic:
change InvImage D.Rel (sigmaIsoSigma.{_, u} D.U).hom _ _
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    rw [←
      show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    change InvImage D.Rel (sigmaIsoSigma.{_, u} D.U).hom _ _
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ InvImage (Rel D) (⇑(sigmaIsoSigma D.U).hom) ((sigmaIsoSigma D.U).inv { fst := i, snd := x })
    ((sigmaIsoSigma D.U).inv { fst := j, snd := y })

Next tactic:
rw [← (InvImage.equivalence _ _ D.rel_equiv).eqvGen_iff]
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    rw [←
      show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    change InvImage D.Rel (sigmaIsoSigma.{_, u} D.U).hom _ _
    rw [← (InvImage.equivalence _ _ D.rel_equiv).eqvGen_iff]
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ EqvGen (InvImage (Rel D) ⇑(sigmaIsoSigma D.U).hom) ((sigmaIsoSigma D.U).inv { fst := i, snd := x })
    ((sigmaIsoSigma D.U).inv { fst := j, snd := y })

Next tactic:
refine' EqvGen.mono _ (D.eqvGen_of_π_eq h : _)
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
    𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
  constructor
  · delta GlueData.ι
    simp_rw [← Multicoequalizer.ι_sigmaπ]
    intro h
    rw [←
      show _ = Sigma.mk i x from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    rw [←
      show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
    change InvImage D.Rel (sigmaIsoSigma.{_, u} D.U).hom _ _
    rw [← (InvImage.equivalence _ _ D.rel_equiv).eqvGen_iff]
    refine' EqvGen.mono _ (D.eqvGen_of_π_eq h : _)
    

Proof state:
case mp
D : GlueData
i j : D.J
x : ↑(GlueData.U D.toGlueData i)
y : ↑(GlueData.U D.toGlueData j)
h :
  (Sigma.ι (GlueData.diagram D.toGlueData).right i ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) x =
    (Sigma.ι (GlueData.diagram D.toGlueData).right j ≫ Multicoequalizer.sigmaπ (GlueData.diagram D.toGlueData)) y
⊢ ∀ (a b : (forget TopCat).obj (∐ D.U)),
    Types.CoequalizerRel (⇑(MultispanIndex.fstSigmaMap (GlueData.diagram D.toGlueData)))
        (⇑(MultispanIndex.sndSigmaMap (GlueData.diagram D.toGlueData))) a b →
      InvImage (Rel D) (⇑(sigmaIsoSigma D.U).hom) a b

Next tactic:
rintro _ _ ⟨x⟩