[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ C
c : Cocone F
h : IsVanKampenColimit c
⊢ IsColimit c
[PROOFSTEP]
refine'
  ((h c (𝟙 F) (𝟙 c.pt : _) (by rw [Functor.map_id, Category.comp_id, Category.id_comp])
          (NatTrans.equifibered_of_isIso _)).mpr
      fun j => _).some
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ C
c : Cocone F
h : IsVanKampenColimit c
⊢ 𝟙 F ≫ c.ι = c.ι ≫ (Functor.const J).map (𝟙 c.pt)
[PROOFSTEP]
rw [Functor.map_id, Category.comp_id, Category.id_comp]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ C
c : Cocone F
h : IsVanKampenColimit c
j : J
⊢ IsPullback (NatTrans.app c.ι j) (NatTrans.app (𝟙 F) j) (𝟙 c.pt) (NatTrans.app c.ι j)
[PROOFSTEP]
haveI : IsIso (𝟙 c.pt) := inferInstance
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ C
c : Cocone F
h : IsVanKampenColimit c
j : J
this : IsIso (𝟙 c.pt)
⊢ IsPullback (NatTrans.app c.ι j) (NatTrans.app (𝟙 F) j) (𝟙 c.pt) (NatTrans.app c.ι j)
[PROOFSTEP]
exact IsPullback.of_vert_isIso ⟨by erw [NatTrans.id_app, Category.comp_id, Category.id_comp]⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ C
c : Cocone F
h : IsVanKampenColimit c
j : J
this : IsIso (𝟙 c.pt)
⊢ NatTrans.app c.ι j ≫ 𝟙 c.pt = NatTrans.app (𝟙 F) j ≫ NatTrans.app c.ι j
[PROOFSTEP]
erw [NatTrans.id_app, Category.comp_id, Category.id_comp]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
⊢ IsVanKampenColimit (asEmptyCocone X)
[PROOFSTEP]
intro F' c' α f hf hα
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
F' : Discrete PEmpty ⥤ C
c' : Cocone F'
α : F' ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
[PROOFSTEP]
have : F' = Functor.empty C := by apply Functor.hext <;> rintro ⟨⟨⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
F' : Discrete PEmpty ⥤ C
c' : Cocone F'
α : F' ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
⊢ F' = Functor.empty C
[PROOFSTEP]
apply Functor.hext
[GOAL]
case h_obj
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
F' : Discrete PEmpty ⥤ C
c' : Cocone F'
α : F' ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
⊢ ∀ (X : Discrete PEmpty), F'.obj X = (Functor.empty C).obj X
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
case h_map
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
F' : Discrete PEmpty ⥤ C
c' : Cocone F'
α : F' ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
⊢ ∀ (X Y : Discrete PEmpty) (f : X ⟶ Y), HEq (F'.map f) ((Functor.empty C).map f)
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
F' : Discrete PEmpty ⥤ C
c' : Cocone F'
α : F' ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
this : F' = Functor.empty C
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
[PROOFSTEP]
subst this
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
c' : Cocone (Functor.empty C)
α : Functor.empty C ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
[PROOFSTEP]
haveI := h.isIso_to f
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
c' : Cocone (Functor.empty C)
α : Functor.empty C ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
this : IsIso f
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
[PROOFSTEP]
refine' ⟨by rintro _ ⟨⟨⟩⟩, fun _ => ⟨IsColimit.ofIsoColimit h (Cocones.ext (asIso f).symm <| by rintro ⟨⟨⟩⟩)⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
c' : Cocone (Functor.empty C)
α : Functor.empty C ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
this : IsIso f
⊢ Nonempty (IsColimit c') →
    ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
[PROOFSTEP]
rintro _ ⟨⟨⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
c' : Cocone (Functor.empty C)
α : Functor.empty C ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty)).map f
hα : NatTrans.Equifibered α
this : IsIso f
x✝ : ∀ (j : Discrete PEmpty), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app (asEmptyCocone X).ι j)
⊢ ∀ (j : Discrete PEmpty), NatTrans.app (asEmptyCocone X).ι j ≫ (asIso f).symm.hom = NatTrans.app c'.ι j
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
⊢ IsVanKampenColimit c
[PROOFSTEP]
let X := F.obj ⟨WalkingPair.left⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
⊢ IsVanKampenColimit c
[PROOFSTEP]
let Y := F.obj ⟨WalkingPair.right⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ IsVanKampenColimit c
[PROOFSTEP]
have : F = pair X Y := by
  apply Functor.hext
  · rintro ⟨⟨⟩⟩ <;> rfl
  · rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩ <;> simp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ F = pair X Y
[PROOFSTEP]
apply Functor.hext
[GOAL]
case h_obj
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ ∀ (X_1 : Discrete WalkingPair), F.obj X_1 = (pair X Y).obj X_1
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
case h_obj.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ F.obj { as := WalkingPair.left } = (pair X Y).obj { as := WalkingPair.left }
[PROOFSTEP]
rfl
[GOAL]
case h_obj.mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ F.obj { as := WalkingPair.right } = (pair X Y).obj { as := WalkingPair.right }
[PROOFSTEP]
rfl
[GOAL]
case h_map
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ ∀ (X_1 Y_1 : Discrete WalkingPair) (f : X_1 ⟶ Y_1), HEq (F.map f) ((pair X Y).map f)
[PROOFSTEP]
rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩
[GOAL]
case h_map.mk.left.mk.up.up
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ HEq (F.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
    ((pair X Y).map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
[PROOFSTEP]
simp
[GOAL]
case h_map.mk.right.mk.up.up
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ HEq (F.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    ((pair X Y).map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
[PROOFSTEP]
simp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
this : F = pair X Y
⊢ IsVanKampenColimit c
[PROOFSTEP]
clear_value X Y
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
Y X : C
this : F = pair X Y
⊢ IsVanKampenColimit c
[PROOFSTEP]
subst this
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
Y X : C
c : Cocone (pair X Y)
hc : IsColimit c
⊢ IsVanKampenColimit c
[PROOFSTEP]
exact FinitaryExtensive.van_kampen' c hc
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ NatTrans.Equifibered α
[PROOFSTEP]
rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩
[GOAL]
case mk.left.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
    (NatTrans.app α { as := WalkingPair.left }) (NatTrans.app α { as := { as := WalkingPair.left }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    (NatTrans.app α { as := WalkingPair.right }) (NatTrans.app α { as := { as := WalkingPair.right }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
[PROOFSTEP]
all_goals
  dsimp; simp only [Discrete.functor_map_id]
  exact IsPullback.of_horiz_isIso ⟨by simp only [Category.comp_id, Category.id_comp]⟩
[GOAL]
case mk.left.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
    (NatTrans.app α { as := WalkingPair.left }) (NatTrans.app α { as := { as := WalkingPair.left }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
[PROOFSTEP]
dsimp
[GOAL]
case mk.left.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : WalkingPair.left = WalkingPair.left) } })
    (NatTrans.app α { as := WalkingPair.left }) (NatTrans.app α { as := WalkingPair.left })
    (F'.map { down := { down := (_ : WalkingPair.left = WalkingPair.left) } })
[PROOFSTEP]
simp only [Discrete.functor_map_id]
[GOAL]
case mk.left.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (𝟙 (F.obj { as := WalkingPair.left })) (NatTrans.app α { as := WalkingPair.left })
    (NatTrans.app α { as := WalkingPair.left }) (𝟙 (F'.obj { as := WalkingPair.left }))
[PROOFSTEP]
exact IsPullback.of_horiz_isIso ⟨by simp only [Category.comp_id, Category.id_comp]⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ 𝟙 (F.obj { as := WalkingPair.left }) ≫ NatTrans.app α { as := WalkingPair.left } =
    NatTrans.app α { as := WalkingPair.left } ≫ 𝟙 (F'.obj { as := WalkingPair.left })
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp]
[GOAL]
case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    (NatTrans.app α { as := WalkingPair.right }) (NatTrans.app α { as := { as := WalkingPair.right }.as })
    (F'.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
[PROOFSTEP]
dsimp
[GOAL]
case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (F.map { down := { down := (_ : WalkingPair.right = WalkingPair.right) } })
    (NatTrans.app α { as := WalkingPair.right }) (NatTrans.app α { as := WalkingPair.right })
    (F'.map { down := { down := (_ : WalkingPair.right = WalkingPair.right) } })
[PROOFSTEP]
simp only [Discrete.functor_map_id]
[GOAL]
case mk.right.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ IsPullback (𝟙 (F.obj { as := WalkingPair.right })) (NatTrans.app α { as := WalkingPair.right })
    (NatTrans.app α { as := WalkingPair.right }) (𝟙 (F'.obj { as := WalkingPair.right }))
[PROOFSTEP]
exact IsPullback.of_horiz_isIso ⟨by simp only [Category.comp_id, Category.id_comp]⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F F' : Discrete WalkingPair ⥤ C
α : F ⟶ F'
⊢ 𝟙 (F.obj { as := WalkingPair.right }) ≫ NatTrans.app α { as := WalkingPair.right } =
    NatTrans.app α { as := WalkingPair.right } ≫ 𝟙 (F'.obj { as := WalkingPair.right })
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
⊢ IsVanKampenColimit c ↔
    ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
        αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
          (Nonempty (IsColimit c') ↔
            IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
              IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
[PROOFSTEP]
constructor
[GOAL]
case mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
⊢ IsVanKampenColimit c →
    ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
        αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
          (Nonempty (IsColimit c') ↔
            IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
              IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
[PROOFSTEP]
introv H hαX hαY
[GOAL]
case mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ Nonempty (IsColimit c') ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
rw [H c' (mapPair αX αY) f (by ext ⟨⟨⟩⟩ <;> dsimp <;> assumption) (mapPair_equifibered _)]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ mapPair αX αY ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
[PROOFSTEP]
ext ⟨⟨⟩⟩
[GOAL]
case w.h.mk.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ NatTrans.app (mapPair αX αY ≫ c.ι) { as := WalkingPair.left } =
    NatTrans.app (c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }
[PROOFSTEP]
dsimp
[GOAL]
case w.h.mk.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ NatTrans.app (mapPair αX αY ≫ c.ι) { as := WalkingPair.right } =
    NatTrans.app (c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.right }
[PROOFSTEP]
dsimp
[GOAL]
case w.h.mk.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
[PROOFSTEP]
assumption
[GOAL]
case w.h.mk.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
[PROOFSTEP]
assumption
[GOAL]
case mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ (∀ (j : Discrete WalkingPair),
      IsPullback (NatTrans.app c'.ι j) (NatTrans.app (mapPair αX αY) j) f (NatTrans.app c.ι j)) ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
constructor
[GOAL]
case mp.mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ (∀ (j : Discrete WalkingPair),
      IsPullback (NatTrans.app c'.ι j) (NatTrans.app (mapPair αX αY) j) f (NatTrans.app c.ι j)) →
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
intro H
[GOAL]
case mp.mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H :
  ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app (mapPair αX αY) j) f (NatTrans.app c.ι j)
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
exact ⟨H _, H _⟩
[GOAL]
case mp.mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c) →
    ∀ (j : Discrete WalkingPair),
      IsPullback (NatTrans.app c'.ι j) (NatTrans.app (mapPair αX αY) j) f (NatTrans.app c.ι j)
[PROOFSTEP]
rintro H ⟨⟨⟩⟩
[GOAL]
case mp.mpr.mk.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
⊢ IsPullback (NatTrans.app c'.ι { as := WalkingPair.left }) (NatTrans.app (mapPair αX αY) { as := WalkingPair.left }) f
    (NatTrans.app c.ι { as := WalkingPair.left })
case mp.mpr.mk.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ : IsVanKampenColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hαX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hαY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
⊢ IsPullback (NatTrans.app c'.ι { as := WalkingPair.right }) (NatTrans.app (mapPair αX αY) { as := WalkingPair.right })
    f (NatTrans.app c.ι { as := WalkingPair.right })
[PROOFSTEP]
exacts [H.1, H.2]
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
⊢ (∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
        αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
          (Nonempty (IsColimit c') ↔
            IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
              IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))) →
    IsVanKampenColimit c
[PROOFSTEP]
introv H F' hα h
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
let X' := F'.obj ⟨WalkingPair.left⟩
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
let Y' := F'.obj ⟨WalkingPair.right⟩
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
have : F' = pair X' Y' := by
  apply Functor.hext
  · rintro ⟨⟨⟩⟩ <;> rfl
  · rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩ <;> simp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ F' = pair X' Y'
[PROOFSTEP]
apply Functor.hext
[GOAL]
case h_obj
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ ∀ (X : Discrete WalkingPair), F'.obj X = (pair X' Y').obj X
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
case h_obj.mk.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ F'.obj { as := WalkingPair.left } = (pair X' Y').obj { as := WalkingPair.left }
[PROOFSTEP]
rfl
[GOAL]
case h_obj.mk.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ F'.obj { as := WalkingPair.right } = (pair X' Y').obj { as := WalkingPair.right }
[PROOFSTEP]
rfl
[GOAL]
case h_map
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ ∀ (X Y : Discrete WalkingPair) (f : X ⟶ Y), HEq (F'.map f) ((pair X' Y').map f)
[PROOFSTEP]
rintro ⟨⟨⟩⟩ ⟨j⟩ ⟨⟨rfl : _ = j⟩⟩
[GOAL]
case h_map.mk.left.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ HEq (F'.map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
    ((pair X' Y').map { down := { down := (_ : { as := WalkingPair.left }.as = { as := WalkingPair.left }.as) } })
[PROOFSTEP]
simp
[GOAL]
case h_map.mk.right.mk.up.up
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
⊢ HEq (F'.map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
    ((pair X' Y').map { down := { down := (_ : { as := WalkingPair.right }.as = { as := WalkingPair.right }.as) } })
[PROOFSTEP]
simp
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
X' : C := F'.obj { as := WalkingPair.left }
Y' : C := F'.obj { as := WalkingPair.right }
this : F' = pair X' Y'
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
clear_value X' Y'
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
F' : Discrete WalkingPair ⥤ C
c' : Cocone F'
α : F' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
Y' X' : C
this : F' = pair X' Y'
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
subst this
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
c' : Cocone (pair X' Y')
α : pair X' Y' ⟶ pair X Y
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
h : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
change BinaryCofan X' Y' at c' 
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
⊢ Nonempty (IsColimit c') ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
rw [H c' _ _ _ (NatTrans.congr_app hα ⟨WalkingPair.left⟩) (NatTrans.congr_app hα ⟨WalkingPair.right⟩)]
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
⊢ IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
      IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c) ↔
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
constructor
[GOAL]
case mpr.mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
⊢ IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
      IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c) →
    ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
rintro H ⟨⟨⟩⟩
[GOAL]
case mpr.mp.mk.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
H :
  IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
    IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c)
⊢ IsPullback (NatTrans.app c'.ι { as := WalkingPair.left }) (NatTrans.app α { as := WalkingPair.left }) f
    (NatTrans.app c.ι { as := WalkingPair.left })
case mpr.mp.mk.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
H :
  IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
    IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c)
⊢ IsPullback (NatTrans.app c'.ι { as := WalkingPair.right }) (NatTrans.app α { as := WalkingPair.right }) f
    (NatTrans.app c.ι { as := WalkingPair.right })
[PROOFSTEP]
exacts [H.1, H.2]
[GOAL]
case mpr.mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
⊢ (∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)) →
    IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
      IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
        (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c)
[PROOFSTEP]
intro H
[GOAL]
case mpr.mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
c : BinaryCofan X Y
H✝ :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
Y' X' : C
α : pair X' Y' ⟶ pair X Y
h : NatTrans.Equifibered α
c' : BinaryCofan X' Y'
f : c'.pt ⟶ c.pt
hα : α ≫ c.ι = c'.ι ≫ (Functor.const (Discrete WalkingPair)).map f
H : ∀ (j : Discrete WalkingPair), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
⊢ IsPullback (BinaryCofan.inl c') (NatTrans.app α { as := WalkingPair.left })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inl c) ∧
    IsPullback (BinaryCofan.inr c') (NatTrans.app α { as := WalkingPair.right })
      (NatTrans.app ((Functor.const (Discrete WalkingPair)).map f) { as := WalkingPair.left }) (BinaryCofan.inr c)
[PROOFSTEP]
exact ⟨H _, H _⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
⊢ IsVanKampenColimit c
[PROOFSTEP]
rw [BinaryCofan.isVanKampen_iff]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
⊢ ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
[PROOFSTEP]
introv hX hY
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ Nonempty (IsColimit c') ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
constructor
[GOAL]
case mp
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ Nonempty (IsColimit c') →
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
rintro ⟨h⟩
[GOAL]
case mp.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
let e := h.coconePointUniqueUpToIso (colimits _ _)
[GOAL]
case mp.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
obtain ⟨hl, hr⟩ := h₁ αX αY (e.inv ≫ f) (by simp [hX]) (by simp [hY])
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
⊢ αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ e.inv ≫ f
[PROOFSTEP]
simp [hX]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
⊢ αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ e.inv ≫ f
[PROOFSTEP]
simp [hY]
[GOAL]
case mp.intro.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
constructor
[GOAL]
case mp.intro.intro.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
[PROOFSTEP]
rw [← Category.id_comp αX, ← Iso.hom_inv_id_assoc e f]
[GOAL]
case mp.intro.intro.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)
[PROOFSTEP]
haveI : IsIso (𝟙 X') := inferInstance
[GOAL]
case mp.intro.intro.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)
[PROOFSTEP]
have : c'.inl ≫ e.hom = 𝟙 X' ≫ (cofans X' Y').inl := by
  dsimp
  simp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ BinaryCofan.inl c' ≫ e.hom = 𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')
[PROOFSTEP]
dsimp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ BinaryCofan.inl c' ≫ (IsColimit.coconePointUniqueUpToIso h (colimits X' Y')).hom =
    𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')
[PROOFSTEP]
simp
[GOAL]
case mp.intro.intro.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this✝ : IsIso (𝟙 X')
this : BinaryCofan.inl c' ≫ e.hom = 𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)
[PROOFSTEP]
exact (IsPullback.of_vert_isIso ⟨this⟩).paste_vert hl
[GOAL]
case mp.intro.intro.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
rw [← Category.id_comp αY, ← Iso.hom_inv_id_assoc e f]
[GOAL]
case mp.intro.intro.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inr c') (𝟙 Y' ≫ αY) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inr c)
[PROOFSTEP]
haveI : IsIso (𝟙 Y') := inferInstance
[GOAL]
case mp.intro.intro.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 Y')
⊢ IsPullback (BinaryCofan.inr c') (𝟙 Y' ≫ αY) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inr c)
[PROOFSTEP]
have : c'.inr ≫ e.hom = 𝟙 Y' ≫ (cofans X' Y').inr := by
  dsimp
  simp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 Y')
⊢ BinaryCofan.inr c' ≫ e.hom = 𝟙 Y' ≫ BinaryCofan.inr (cofans X' Y')
[PROOFSTEP]
dsimp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 Y')
⊢ BinaryCofan.inr c' ≫ (IsColimit.coconePointUniqueUpToIso h (colimits X' Y')).hom =
    𝟙 Y' ≫ BinaryCofan.inr (cofans X' Y')
[PROOFSTEP]
simp
[GOAL]
case mp.intro.intro.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
h : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this✝ : IsIso (𝟙 Y')
this : BinaryCofan.inr c' ≫ e.hom = 𝟙 Y' ≫ BinaryCofan.inr (cofans X' Y')
⊢ IsPullback (BinaryCofan.inr c') (𝟙 Y' ≫ αY) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inr c)
[PROOFSTEP]
exact (IsPullback.of_vert_isIso ⟨this⟩).paste_vert hr
[GOAL]
case mpr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c) →
    Nonempty (IsColimit c')
[PROOFSTEP]
rintro ⟨H₁, H₂⟩
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
⊢ Nonempty (IsColimit c')
[PROOFSTEP]
refine' ⟨IsColimit.ofIsoColimit _ <| (isoBinaryCofanMk _).symm⟩
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inl c') (BinaryCofan.inr c'))
[PROOFSTEP]
let e₁ : X' ≅ _ := H₁.isLimit.conePointUniqueUpToIso (limits _ _)
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inl c') (BinaryCofan.inr c'))
[PROOFSTEP]
let e₂ : Y' ≅ _ := H₂.isLimit.conePointUniqueUpToIso (limits _ _)
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inl c') (BinaryCofan.inr c'))
[PROOFSTEP]
have he₁ : c'.inl = e₁.hom ≫ (cones f c.inl).fst := by simp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
⊢ BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
[PROOFSTEP]
simp
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inl c') (BinaryCofan.inr c'))
[PROOFSTEP]
have he₂ : c'.inr = e₂.hom ≫ (cones f c.inr).fst := by simp
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
⊢ BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
[PROOFSTEP]
simp
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
he₂ : BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inl c') (BinaryCofan.inr c'))
[PROOFSTEP]
rw [he₁, he₂]
[GOAL]
case mpr.intro
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
he₂ : BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
⊢ IsColimit
    (BinaryCofan.mk (e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c)))
      (e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))))
[PROOFSTEP]
apply BinaryCofan.isColimitCompRightIso (BinaryCofan.mk _ _)
[GOAL]
case mpr.intro.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
he₂ : BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
⊢ IsColimit
    (BinaryCofan.mk (e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c)))
      ((cones f (BinaryCofan.inr c)).π.1 WalkingCospan.left))
[PROOFSTEP]
apply BinaryCofan.isColimitCompLeftIso (BinaryCofan.mk _ _)
[GOAL]
case mpr.intro.h.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
he₂ : BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
⊢ IsColimit
    (BinaryCofan.mk ((cones f (BinaryCofan.inl c)).π.1 WalkingCospan.left)
      ((cones f (BinaryCofan.inr c)).π.1 WalkingCospan.left))
[PROOFSTEP]
exact h₂ f
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ Mono (BinaryCofan.inr c)
[PROOFSTEP]
refine' PullbackCone.mono_of_isLimitMkIdId _ (IsPullback.isLimit _)
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsPullback (𝟙 ((pair X Y).obj { as := WalkingPair.right })) (𝟙 ((pair X Y).obj { as := WalkingPair.right }))
    (BinaryCofan.inr c) (BinaryCofan.inr c)
[PROOFSTEP]
refine'
  (h (BinaryCofan.mk (initial.to Y) (𝟙 Y)) (mapPair (initial.to X) (𝟙 Y)) c.inr _ (mapPair_equifibered _)).mp ⟨_⟩
    ⟨WalkingPair.right⟩
[GOAL]
case refine'_1
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ mapPair (initial.to X) (𝟙 Y) ≫ c.ι =
    (BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c)
[PROOFSTEP]
ext ⟨⟨⟩⟩
[GOAL]
case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ NatTrans.app (mapPair (initial.to X) (𝟙 Y) ≫ c.ι) { as := WalkingPair.left } =
    NatTrans.app
      ((BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c))
      { as := WalkingPair.left }
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1.w.h.mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ NatTrans.app (mapPair (initial.to X) (𝟙 Y) ≫ c.ι) { as := WalkingPair.right } =
    NatTrans.app
      ((BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c))
      { as := WalkingPair.right }
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ initial.to X ≫ BinaryCofan.inl c = initial.to Y ≫ BinaryCofan.inr c
[PROOFSTEP]
simp
[GOAL]
case refine'_2
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsColimit (BinaryCofan.mk (initial.to Y) (𝟙 Y))
[PROOFSTEP]
exact
  ((BinaryCofan.isColimit_iff_isIso_inr initialIsInitial _).mpr
      (by
        dsimp
        infer_instance)).some
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (BinaryCofan.inr (BinaryCofan.mk (initial.to Y) (𝟙 Y)))
[PROOFSTEP]
dsimp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : C
inst✝ : HasInitial C
X Y : C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (𝟙 Y)
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsPullback (initial.to ((pair X Y).obj { as := WalkingPair.left }))
    (initial.to ((pair X Y).obj { as := WalkingPair.right })) (BinaryCofan.inl c) (BinaryCofan.inr c)
[PROOFSTEP]
refine'
  ((h (BinaryCofan.mk (initial.to Y) (𝟙 Y)) (mapPair (initial.to X) (𝟙 Y)) c.inr _ (mapPair_equifibered _)).mp ⟨_⟩
      ⟨WalkingPair.left⟩).flip
[GOAL]
case refine'_1
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ mapPair (initial.to X) (𝟙 Y) ≫ c.ι =
    (BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c)
[PROOFSTEP]
ext ⟨⟨⟩⟩
[GOAL]
case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ NatTrans.app (mapPair (initial.to X) (𝟙 Y) ≫ c.ι) { as := WalkingPair.left } =
    NatTrans.app
      ((BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c))
      { as := WalkingPair.left }
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1.w.h.mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ NatTrans.app (mapPair (initial.to X) (𝟙 Y) ≫ c.ι) { as := WalkingPair.right } =
    NatTrans.app
      ((BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c))
      { as := WalkingPair.right }
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ initial.to X ≫ BinaryCofan.inl c = initial.to Y ≫ BinaryCofan.inr c
[PROOFSTEP]
simp
[GOAL]
case refine'_2
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsColimit (BinaryCofan.mk (initial.to Y) (𝟙 Y))
[PROOFSTEP]
exact
  ((BinaryCofan.isColimit_iff_isIso_inr initialIsInitial _).mpr
      (by
        dsimp
        infer_instance)).some
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (BinaryCofan.inr (BinaryCofan.mk (initial.to Y) (𝟙 Y)))
[PROOFSTEP]
dsimp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (𝟙 Y)
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
⊢ ∀ (A : C) (f : A ⟶ ⊥_ C), IsIso f
[PROOFSTEP]
intro A f
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsIso f
[PROOFSTEP]
suffices IsColimit (BinaryCofan.mk (𝟙 A) (𝟙 A))
  by
  obtain ⟨l, h₁, h₂⟩ := Limits.BinaryCofan.IsColimit.desc' this (f ≫ initial.to A) (𝟙 A)
  rcases(Category.id_comp _).symm.trans h₂ with rfl
  exact ⟨⟨_, ((Category.id_comp _).symm.trans h₁).symm, initialIsInitial.hom_ext _ _⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
this : IsColimit (BinaryCofan.mk (𝟙 A) (𝟙 A))
⊢ IsIso f
[PROOFSTEP]
obtain ⟨l, h₁, h₂⟩ := Limits.BinaryCofan.IsColimit.desc' this (f ≫ initial.to A) (𝟙 A)
[GOAL]
case mk.intro
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
this : IsColimit (BinaryCofan.mk (𝟙 A) (𝟙 A))
l : (BinaryCofan.mk (𝟙 A) (𝟙 A)).pt ⟶ A
h₁ : BinaryCofan.inl (BinaryCofan.mk (𝟙 A) (𝟙 A)) ≫ l = f ≫ initial.to A
h₂ : BinaryCofan.inr (BinaryCofan.mk (𝟙 A) (𝟙 A)) ≫ l = 𝟙 A
⊢ IsIso f
[PROOFSTEP]
rcases(Category.id_comp _).symm.trans h₂ with rfl
[GOAL]
case mk.intro
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
this : IsColimit (BinaryCofan.mk (𝟙 A) (𝟙 A))
h₁ : BinaryCofan.inl (BinaryCofan.mk (𝟙 A) (𝟙 A)) ≫ 𝟙 A = f ≫ initial.to A
h₂ : BinaryCofan.inr (BinaryCofan.mk (𝟙 A) (𝟙 A)) ≫ 𝟙 A = 𝟙 A
⊢ IsIso f
[PROOFSTEP]
exact ⟨⟨_, ((Category.id_comp _).symm.trans h₁).symm, initialIsInitial.hom_ext _ _⟩⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsColimit (BinaryCofan.mk (𝟙 A) (𝟙 A))
[PROOFSTEP]
refine' (H (BinaryCofan.mk (𝟙 _) (𝟙 _)) (mapPair f f) f (by ext ⟨⟨⟩⟩ <;> dsimp <;> simp) (mapPair_equifibered _) _).some
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ mapPair f f ≫ (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι =
    (BinaryCofan.mk (𝟙 A) (𝟙 A)).ι ≫ (Functor.const (Discrete WalkingPair)).map f
[PROOFSTEP]
ext ⟨⟨⟩⟩
[GOAL]
case w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ NatTrans.app (mapPair f f ≫ (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι) { as := WalkingPair.left } =
    NatTrans.app ((BinaryCofan.mk (𝟙 A) (𝟙 A)).ι ≫ (Functor.const (Discrete WalkingPair)).map f)
      { as := WalkingPair.left }
[PROOFSTEP]
dsimp
[GOAL]
case w.h.mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ NatTrans.app (mapPair f f ≫ (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι) { as := WalkingPair.right } =
    NatTrans.app ((BinaryCofan.mk (𝟙 A) (𝟙 A)).ι ≫ (Functor.const (Discrete WalkingPair)).map f)
      { as := WalkingPair.right }
[PROOFSTEP]
dsimp
[GOAL]
case w.h.mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ f ≫ 𝟙 (⊥_ C) = 𝟙 A ≫ f
[PROOFSTEP]
simp
[GOAL]
case w.h.mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ f ≫ 𝟙 (⊥_ C) = 𝟙 A ≫ f
[PROOFSTEP]
simp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ ∀ (j : Discrete WalkingPair),
    IsPullback (NatTrans.app (BinaryCofan.mk (𝟙 A) (𝟙 A)).ι j) (NatTrans.app (mapPair f f) j) f
      (NatTrans.app (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι j)
[PROOFSTEP]
rintro ⟨⟨⟩⟩
[GOAL]
case mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsPullback (NatTrans.app (BinaryCofan.mk (𝟙 A) (𝟙 A)).ι { as := WalkingPair.left })
    (NatTrans.app (mapPair f f) { as := WalkingPair.left }) f
    (NatTrans.app (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι { as := WalkingPair.left })
[PROOFSTEP]
dsimp
[GOAL]
case mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsPullback (NatTrans.app (BinaryCofan.mk (𝟙 A) (𝟙 A)).ι { as := WalkingPair.right })
    (NatTrans.app (mapPair f f) { as := WalkingPair.right }) f
    (NatTrans.app (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))).ι { as := WalkingPair.right })
[PROOFSTEP]
dsimp
[GOAL]
case mk.left
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsPullback (𝟙 A) f f (𝟙 (⊥_ C))
[PROOFSTEP]
exact IsPullback.of_horiz_isIso ⟨(Category.id_comp _).trans (Category.comp_id _).symm⟩
[GOAL]
case mk.right
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))
A : C
f : A ⟶ ⊥_ C
⊢ IsPullback (𝟙 A) f f (𝟙 (⊥_ C))
[PROOFSTEP]
exact IsPullback.of_horiz_isIso ⟨(Category.id_comp _).trans (Category.comp_id _).symm⟩
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : FinitaryExtensive C
⊢ IsIso (BinaryCofan.inr (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C))))
[PROOFSTEP]
dsimp
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : FinitaryExtensive C
⊢ IsIso (𝟙 (⊥_ C))
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X Y : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
⊢ FinitaryExtensive C ↔ IsVanKampenColimit c₀
[PROOFSTEP]
refine' ⟨fun H => H.2 c₀ hc₀, fun H => _⟩
[GOAL]
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X Y : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H : IsVanKampenColimit c₀
⊢ FinitaryExtensive C
[PROOFSTEP]
constructor
[GOAL]
case van_kampen'
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X Y : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H : IsVanKampenColimit c₀
⊢ ∀ {X Y : C} (c : BinaryCofan X Y), IsColimit c → IsVanKampenColimit c
[PROOFSTEP]
simp_rw [BinaryCofan.isVanKampen_iff] at H ⊢
[GOAL]
case van_kampen'
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X Y : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
⊢ ∀ {X Y : C} (c : BinaryCofan X Y),
    IsColimit c →
      ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
        αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f →
          αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f →
            (Nonempty (IsColimit c') ↔
              IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧
                IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c))
[PROOFSTEP]
intro X Y c hc X' Y' c' αX αY f hX hY
[GOAL]
case van_kampen'
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
⊢ Nonempty (IsColimit c') ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
obtain ⟨d, hd, hd'⟩ := Limits.BinaryCofan.IsColimit.desc' hc (HT.from _ ≫ c₀.inl) (HT.from _ ≫ c₀.inr)
[GOAL]
case van_kampen'.mk.intro
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
d : c.pt ⟶ ((Functor.const (Discrete WalkingPair)).obj c₀.pt).obj { as := WalkingPair.left }
hd : BinaryCofan.inl c ≫ d = IsTerminal.from HT X ≫ BinaryCofan.inl c₀
hd' : BinaryCofan.inr c ≫ d = IsTerminal.from HT Y ≫ BinaryCofan.inr c₀
⊢ Nonempty (IsColimit c') ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
rw [H c' (αX ≫ HT.from _) (αY ≫ HT.from _) (f ≫ d) (by rw [← reassoc_of% hX, hd, Category.assoc])
    (by rw [← reassoc_of% hY, hd', Category.assoc])]
[GOAL]
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
d : c.pt ⟶ ((Functor.const (Discrete WalkingPair)).obj c₀.pt).obj { as := WalkingPair.left }
hd : BinaryCofan.inl c ≫ d = IsTerminal.from HT X ≫ BinaryCofan.inl c₀
hd' : BinaryCofan.inr c ≫ d = IsTerminal.from HT Y ≫ BinaryCofan.inr c₀
⊢ (αX ≫ IsTerminal.from HT X) ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f ≫ d
[PROOFSTEP]
rw [← reassoc_of% hX, hd, Category.assoc]
[GOAL]
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
d : c.pt ⟶ ((Functor.const (Discrete WalkingPair)).obj c₀.pt).obj { as := WalkingPair.left }
hd : BinaryCofan.inl c ≫ d = IsTerminal.from HT X ≫ BinaryCofan.inl c₀
hd' : BinaryCofan.inr c ≫ d = IsTerminal.from HT Y ≫ BinaryCofan.inr c₀
⊢ (αY ≫ IsTerminal.from HT Y) ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f ≫ d
[PROOFSTEP]
rw [← reassoc_of% hY, hd', Category.assoc]
[GOAL]
case van_kampen'.mk.intro
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
d : c.pt ⟶ ((Functor.const (Discrete WalkingPair)).obj c₀.pt).obj { as := WalkingPair.left }
hd : BinaryCofan.inl c ≫ d = IsTerminal.from HT X ≫ BinaryCofan.inl c₀
hd' : BinaryCofan.inr c ≫ d = IsTerminal.from HT Y ≫ BinaryCofan.inr c₀
⊢ IsPullback (BinaryCofan.inl c') (αX ≫ IsTerminal.from HT X) (f ≫ d) (BinaryCofan.inl c₀) ∧
      IsPullback (BinaryCofan.inr c') (αY ≫ IsTerminal.from HT Y) (f ≫ d) (BinaryCofan.inr c₀) ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
obtain ⟨hl, hr⟩ := (H c (HT.from _) (HT.from _) d hd.symm hd'.symm).mp ⟨hc⟩
[GOAL]
case van_kampen'.mk.intro.intro
J : Type v'
inst✝³ : Category.{u', v'} J
C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteCoproducts C
T : C
HT : IsTerminal T
c₀ : BinaryCofan T T
hc₀ : IsColimit c₀
H :
  ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ T) (αY : Y' ⟶ T) (f : c'.pt ⟶ c₀.pt),
    αX ≫ BinaryCofan.inl c₀ = BinaryCofan.inl c' ≫ f →
      αY ≫ BinaryCofan.inr c₀ = BinaryCofan.inr c' ≫ f →
        (Nonempty (IsColimit c') ↔
          IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c₀) ∧
            IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c₀))
X Y : C
c : BinaryCofan X Y
hc : IsColimit c
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
d : c.pt ⟶ ((Functor.const (Discrete WalkingPair)).obj c₀.pt).obj { as := WalkingPair.left }
hd : BinaryCofan.inl c ≫ d = IsTerminal.from HT X ≫ BinaryCofan.inl c₀
hd' : BinaryCofan.inr c ≫ d = IsTerminal.from HT Y ≫ BinaryCofan.inr c₀
hl : IsPullback (BinaryCofan.inl c) (IsTerminal.from HT X) d (BinaryCofan.inl c₀)
hr : IsPullback (BinaryCofan.inr c) (IsTerminal.from HT Y) d (BinaryCofan.inr c₀)
⊢ IsPullback (BinaryCofan.inl c') (αX ≫ IsTerminal.from HT X) (f ≫ d) (BinaryCofan.inl c₀) ∧
      IsPullback (BinaryCofan.inr c') (αY ≫ IsTerminal.from HT Y) (f ≫ d) (BinaryCofan.inr c₀) ↔
    IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c) ∧ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
[PROOFSTEP]
rw [hl.paste_vert_iff hX.symm, hr.paste_vert_iff hY.symm]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ FinitaryExtensive (Type u)
[PROOFSTEP]
classical
rw [finitaryExtensive_iff_of_isTerminal (Type u) PUnit Types.isTerminalPunit _ (Types.binaryCoproductColimit _ _)]
apply
  BinaryCofan.isVanKampen_mk _ _ (fun X Y => Types.binaryCoproductColimit X Y) _ fun f g =>
    (Limits.Types.pullbackLimitCone f g).2
· intros _ _ _ _ f hαX hαY
  constructor
  · refine' ⟨⟨hαX.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
    intro s
    have : ∀ x, ∃! y, s.fst x = Sum.inl y := by
      intro x
      cases' h : s.fst x with val val
      · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inl.injEq, exists_unique_eq']
      · apply_fun f at h 
        cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαY val : _).symm
    delta ExistsUnique at this 
    choose l hl hl' using this
    exact
      ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _, fun {l'} h₁ _ =>
        funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
  · refine' ⟨⟨hαY.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
    intro s
    have : ∀ x, ∃! y, s.fst x = Sum.inr y := by
      intro x
      cases' h : s.fst x with val val
      · apply_fun f at h 
        cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαX val : _).symm
      · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inr.injEq, exists_unique_eq']
    delta ExistsUnique at this 
    choose l hl hl' using this
    exact
      ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _, fun {l'} h₁ _ =>
        funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
· intro Z f
  dsimp [Limits.Types.binaryCoproductCocone]
  delta Types.PullbackObj
  have : ∀ x, f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit :=
    by
    intro x
    rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
    exacts [Or.inl rfl, Or.inr rfl]
  let eX : { p : Z × PUnit // f p.fst = Sum.inl p.snd } ≃ { x : Z // f x = Sum.inl PUnit.unit } :=
    ⟨fun p => ⟨p.1.1, by convert p.2⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext; rfl, fun _ => by ext; rfl⟩
  let eY : { p : Z × PUnit // f p.fst = Sum.inr p.snd } ≃ { x : Z // f x = Sum.inr PUnit.unit } :=
    ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext;
      rfl, fun _ => by ext; rfl⟩
  fapply BinaryCofan.isColimitMk
  · exact fun s x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩
  · intro s
    ext ⟨⟨x, ⟨⟩⟩, _⟩
    dsimp
    split_ifs <;> rfl
  · intro s
    ext ⟨⟨x, ⟨⟩⟩, hx⟩
    dsimp
    split_ifs with h
    · cases h.symm.trans hx
    · rfl
  · intro s m e₁ e₂
    ext x
    split_ifs
    · rw [← e₁]
      rfl
    · rw [← e₂]
      rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ FinitaryExtensive (Type u)
[PROOFSTEP]
rw [finitaryExtensive_iff_of_isTerminal (Type u) PUnit Types.isTerminalPunit _ (Types.binaryCoproductColimit _ _)]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ IsVanKampenColimit (Types.binaryCoproductCocone PUnit PUnit)
[PROOFSTEP]
apply
  BinaryCofan.isVanKampen_mk _ _ (fun X Y => Types.binaryCoproductColimit X Y) _ fun f g =>
    (Limits.Types.pullbackLimitCone f g).2
[GOAL]
case h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ ∀ {X' Y' : Type u} (αX : X' ⟶ PUnit) (αY : Y' ⟶ PUnit)
    (f : (Types.binaryCoproductCocone X' Y').pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt),
    αX ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
        BinaryCofan.inl (Types.binaryCoproductCocone X' Y') ≫ f →
      αY ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
          BinaryCofan.inr (Types.binaryCoproductCocone X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (Types.binaryCoproductCocone X' Y')) αX f
            (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit)) ∧
          IsPullback (BinaryCofan.inr (Types.binaryCoproductCocone X' Y')) αY f
            (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
[PROOFSTEP]
intros _ _ _ _ f hαX hαY
[GOAL]
case h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
⊢ IsPullback (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝ f
      (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit)) ∧
    IsPullback (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝ f
      (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
[PROOFSTEP]
constructor
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
⊢ IsPullback (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝ f
    (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
[PROOFSTEP]
refine' ⟨⟨hαX.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
⊢ (s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) →
    { l //
      l ≫
            PullbackCone.fst
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                (_ :
                  BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.fst s ∧
        l ≫
              PullbackCone.snd
                (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                  (_ :
                    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
            PullbackCone.snd s ∧
          ∀
            {m :
              s.pt ⟶
                (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                    (_ :
                      BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).pt},
            m ≫
                  PullbackCone.fst
                    (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                      (_ :
                        BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.fst s →
              m ≫
                    PullbackCone.snd
                      (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                        (_ :
                          BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                            αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
              (_ :
                BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                (_ :
                  BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                  (_ :
                    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                    (_ :
                      BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                      (_ :
                        BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
have : ∀ x, ∃! y, s.fst x = Sum.inl y := by
  intro x
  cases' h : s.fst x with val val
  · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inl.injEq, exists_unique_eq']
  · apply_fun f at h 
    cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαY val : _).symm
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
⊢ ∀ (x : s.pt), ∃! y, PullbackCone.fst s x = Sum.inl y
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
⊢ ∃! y, PullbackCone.fst s x = Sum.inl y
[PROOFSTEP]
cases' h : s.fst x with val val
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : X'✝
h : PullbackCone.fst s x = Sum.inl val
⊢ ∃! y, Sum.inl val = Sum.inl y
[PROOFSTEP]
simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inl.injEq, exists_unique_eq']
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : Y'✝
h : PullbackCone.fst s x = Sum.inr val
⊢ ∃! y, Sum.inr val = Sum.inl y
[PROOFSTEP]
apply_fun f at h 
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : Y'✝
h : f (PullbackCone.fst s x) = f (Sum.inr val)
⊢ ∃! y, Sum.inr val = Sum.inl y
[PROOFSTEP]
cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαY val : _).symm
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
this : ∀ (x : s.pt), ∃! y, PullbackCone.fst s x = Sum.inl y
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
              (_ :
                BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                (_ :
                  BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                  (_ :
                    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                    (_ :
                      BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                      (_ :
                        BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
delta ExistsUnique at this 
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
this :
  ∀ (x : s.pt),
    ∃ x_1,
      (fun y => PullbackCone.fst s x = Sum.inl y) x_1 ∧
        ∀ (y : X'✝), (fun y => PullbackCone.fst s x = Sum.inl y) y → y = x_1
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
              (_ :
                BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                (_ :
                  BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                  (_ :
                    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                    (_ :
                      BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                      (_ :
                        BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
choose l hl hl' using this
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))
l : s.pt → X'✝
hl : ∀ (x : s.pt), (fun y => PullbackCone.fst s x = Sum.inl y) (l x)
hl' : ∀ (x : s.pt) (y : X'✝), (fun y => PullbackCone.fst s x = Sum.inl y) y → y = l x
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
              (_ :
                BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                (_ :
                  BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                  (_ :
                    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                    (_ :
                      BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝)) αX✝
                      (_ :
                        BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
exact
  ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _, fun {l'} h₁ _ =>
    funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
⊢ IsPullback (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝ f
    (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
[PROOFSTEP]
refine' ⟨⟨hαY.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
⊢ (s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) →
    { l //
      l ≫
            PullbackCone.fst
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                (_ :
                  BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.fst s ∧
        l ≫
              PullbackCone.snd
                (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                  (_ :
                    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
            PullbackCone.snd s ∧
          ∀
            {m :
              s.pt ⟶
                (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                    (_ :
                      BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).pt},
            m ≫
                  PullbackCone.fst
                    (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                      (_ :
                        BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.fst s →
              m ≫
                    PullbackCone.snd
                      (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                        (_ :
                          BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                            αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
              (_ :
                BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                (_ :
                  BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                  (_ :
                    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                    (_ :
                      BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                      (_ :
                        BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
have : ∀ x, ∃! y, s.fst x = Sum.inr y := by
  intro x
  cases' h : s.fst x with val val
  · apply_fun f at h 
    cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαX val : _).symm
  · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inr.injEq, exists_unique_eq']
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
⊢ ∀ (x : s.pt), ∃! y, PullbackCone.fst s x = Sum.inr y
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
⊢ ∃! y, PullbackCone.fst s x = Sum.inr y
[PROOFSTEP]
cases' h : s.fst x with val val
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : X'✝
h : PullbackCone.fst s x = Sum.inl val
⊢ ∃! y, Sum.inl val = Sum.inr y
[PROOFSTEP]
apply_fun f at h 
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : X'✝
h : f (PullbackCone.fst s x) = f (Sum.inl val)
⊢ ∃! y, Sum.inl val = Sum.inr y
[PROOFSTEP]
cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαX val : _).symm
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
x : s.pt
val : Y'✝
h : PullbackCone.fst s x = Sum.inr val
⊢ ∃! y, Sum.inr val = Sum.inr y
[PROOFSTEP]
simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inr.injEq, exists_unique_eq']
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
this : ∀ (x : s.pt), ∃! y, PullbackCone.fst s x = Sum.inr y
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
              (_ :
                BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                (_ :
                  BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                  (_ :
                    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                    (_ :
                      BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                      (_ :
                        BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
delta ExistsUnique at this 
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
this :
  ∀ (x : s.pt),
    ∃ x_1,
      (fun y => PullbackCone.fst s x = Sum.inr y) x_1 ∧
        ∀ (y : Y'✝), (fun y => PullbackCone.fst s x = Sum.inr y) y → y = x_1
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
              (_ :
                BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                (_ :
                  BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                  (_ :
                    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                    (_ :
                      BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                      (_ :
                        BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
choose l hl hl' using this
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X'✝ Y'✝ : Type u
αX✝ : X'✝ ⟶ PUnit
αY✝ : Y'✝ ⟶ PUnit
f : (Types.binaryCoproductCocone X'✝ Y'✝).pt ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
hαX :
  αX✝ ≫ BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inl (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
hαY :
  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit) =
    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f
s : PullbackCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))
l : s.pt → Y'✝
hl : ∀ (x : s.pt), (fun y => PullbackCone.fst s x = Sum.inr y) (l x)
hl' : ∀ (x : s.pt) (y : Y'✝), (fun y => PullbackCone.fst s x = Sum.inr y) y → y = l x
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
              (_ :
                BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                  αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                (_ :
                  BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                    αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                  (_ :
                    BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                      αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                    (_ :
                      BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                        αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝)) αY✝
                      (_ :
                        BinaryCofan.inr (Types.binaryCoproductCocone X'✝ Y'✝) ≫ f =
                          αY✝ ≫ BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
exact
  ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _, fun {l'} h₁ _ =>
    funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ {Z : Type u} →
    (f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt) →
      IsColimit
        (BinaryCofan.mk
          (PullbackCone.fst
            (Types.pullbackLimitCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).cone)
          (PullbackCone.fst
            (Types.pullbackLimitCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).cone))
[PROOFSTEP]
intro Z f
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
⊢ IsColimit
    (BinaryCofan.mk
      (PullbackCone.fst (Types.pullbackLimitCone f (BinaryCofan.inl (Types.binaryCoproductCocone PUnit PUnit))).cone)
      (PullbackCone.fst (Types.pullbackLimitCone f (BinaryCofan.inr (Types.binaryCoproductCocone PUnit PUnit))).cone))
[PROOFSTEP]
dsimp [Limits.Types.binaryCoproductCocone]
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
⊢ IsColimit (BinaryCofan.mk (fun p => (↑p).fst) fun p => (↑p).fst)
[PROOFSTEP]
delta Types.PullbackObj
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
⊢ IsColimit (BinaryCofan.mk (fun p => (↑p).fst) fun p => (↑p).fst)
[PROOFSTEP]
have : ∀ x, f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit :=
  by
  intro x
  rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
  exacts [Or.inl rfl, Or.inr rfl]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
⊢ ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
x : Z
⊢ f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
[PROOFSTEP]
rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
[GOAL]
case inl.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
x : Z
⊢ Sum.inl PUnit.unit = Sum.inl PUnit.unit ∨ Sum.inl PUnit.unit = Sum.inr PUnit.unit
case inr.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
x : Z
⊢ Sum.inr PUnit.unit = Sum.inl PUnit.unit ∨ Sum.inr PUnit.unit = Sum.inr PUnit.unit
[PROOFSTEP]
exacts [Or.inl rfl, Or.inr rfl]
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
⊢ IsColimit (BinaryCofan.mk (fun p => (↑p).fst) fun p => (↑p).fst)
[PROOFSTEP]
let eX : { p : Z × PUnit // f p.fst = Sum.inl p.snd } ≃ { x : Z // f x = Sum.inl PUnit.unit } :=
  ⟨fun p => ⟨p.1.1, by convert p.2⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext; rfl, fun _ => by ext; rfl⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
p : { p // f p.fst = Sum.inl p.snd }
⊢ f (↑p).fst = Sum.inl PUnit.unit
[PROOFSTEP]
convert p.2
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
x✝ : { p // f p.fst = Sum.inl p.snd }
⊢ (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
      ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a.h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
x✝ : { p // f p.fst = Sum.inl p.snd }
⊢ (↑((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
          ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x✝))).fst =
    (↑x✝).fst
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
x✝ : { x // f x = Sum.inl PUnit.unit }
⊢ (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
      ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
x✝ : { x // f x = Sum.inl PUnit.unit }
⊢ ↑((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
        ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x✝)) =
    ↑x✝
[PROOFSTEP]
rfl
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
⊢ IsColimit (BinaryCofan.mk (fun p => (↑p).fst) fun p => (↑p).fst)
[PROOFSTEP]
let eY : { p : Z × PUnit // f p.fst = Sum.inr p.snd } ≃ { x : Z // f x = Sum.inr PUnit.unit } :=
  ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext;
    rfl, fun _ => by ext; rfl⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { p // f p.fst = Sum.inr p.snd }
⊢ (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
      ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a.h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { p // f p.fst = Sum.inr p.snd }
⊢ (↑((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
          ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x✝))).fst =
    (↑x✝).fst
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { x // f x = Sum.inr PUnit.unit }
⊢ (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
      ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { x // f x = Sum.inr PUnit.unit }
⊢ ↑((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
        ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x✝)) =
    ↑x✝
[PROOFSTEP]
rfl
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ IsColimit (BinaryCofan.mk (fun p => (↑p).fst) fun p => (↑p).fst)
[PROOFSTEP]
fapply BinaryCofan.isColimitMk
[GOAL]
case h₂.desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ (s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }) → Z ⟶ s.pt
[PROOFSTEP]
exact fun s x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩
[GOAL]
case h₂.fac_left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀ (s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }),
    ((fun p => (↑p).fst) ≫ fun x =>
        if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
        else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })) =
      BinaryCofan.inl s
[PROOFSTEP]
intro s
[GOAL]
case h₂.fac_left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
⊢ ((fun p => (↑p).fst) ≫ fun x =>
      if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
      else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })) =
    BinaryCofan.inl s
[PROOFSTEP]
ext ⟨⟨x, ⟨⟩⟩, _⟩
[GOAL]
case h₂.fac_left.h.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
property✝ : f (x, PUnit.unit).fst = Sum.inl (x, PUnit.unit).snd
⊢ ((fun p => (↑p).fst) ≫ fun x =>
        if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
        else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) }))
      { val := (x, PUnit.unit), property := property✝ } =
    BinaryCofan.inl s { val := (x, PUnit.unit), property := property✝ }
[PROOFSTEP]
dsimp
[GOAL]
case h₂.fac_left.h.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
property✝ : f (x, PUnit.unit).fst = Sum.inl (x, PUnit.unit).snd
⊢ (if h : f x = Sum.inl PUnit.unit then
      BinaryCofan.inl s { val := ({ val := x, property := h }.1, PUnit.unit), property := h }
    else
      BinaryCofan.inr s
        { val := ({ val := x, property := (_ : f x = Sum.inr PUnit.unit) }.1, PUnit.unit),
          property := (_ : f x = Sum.inr PUnit.unit) }) =
    BinaryCofan.inl s { val := (x, PUnit.unit), property := property✝ }
[PROOFSTEP]
split_ifs
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
property✝ : f (x, PUnit.unit).fst = Sum.inl (x, PUnit.unit).snd
h✝ : f x = Sum.inl PUnit.unit
⊢ BinaryCofan.inl s { val := (x, PUnit.unit), property := (_ : f x = Sum.inl PUnit.unit) } =
    BinaryCofan.inl s { val := (x, PUnit.unit), property := property✝ }
[PROOFSTEP]
rfl
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
property✝ : f (x, PUnit.unit).fst = Sum.inl (x, PUnit.unit).snd
h✝ : ¬f x = Sum.inl PUnit.unit
⊢ BinaryCofan.inl s { val := (x, PUnit.unit), property := (_ : f x = Sum.inl PUnit.unit) } =
    BinaryCofan.inl s { val := (x, PUnit.unit), property := property✝ }
[PROOFSTEP]
rfl
[GOAL]
case h₂.fac_right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀ (s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }),
    ((fun p => (↑p).fst) ≫ fun x =>
        if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
        else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })) =
      BinaryCofan.inr s
[PROOFSTEP]
intro s
[GOAL]
case h₂.fac_right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
⊢ ((fun p => (↑p).fst) ≫ fun x =>
      if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
      else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })) =
    BinaryCofan.inr s
[PROOFSTEP]
ext ⟨⟨x, ⟨⟩⟩, hx⟩
[GOAL]
case h₂.fac_right.h.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
hx : f (x, PUnit.unit).fst = Sum.inr (x, PUnit.unit).snd
⊢ ((fun p => (↑p).fst) ≫ fun x =>
        if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
        else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) }))
      { val := (x, PUnit.unit), property := hx } =
    BinaryCofan.inr s { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
dsimp
[GOAL]
case h₂.fac_right.h.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
hx : f (x, PUnit.unit).fst = Sum.inr (x, PUnit.unit).snd
⊢ (if h : f x = Sum.inl PUnit.unit then
      BinaryCofan.inl s { val := ({ val := x, property := h }.1, PUnit.unit), property := h }
    else
      BinaryCofan.inr s
        { val := ({ val := x, property := (_ : f x = Sum.inr PUnit.unit) }.1, PUnit.unit),
          property := (_ : f x = Sum.inr PUnit.unit) }) =
    BinaryCofan.inr s { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
hx : f (x, PUnit.unit).fst = Sum.inr (x, PUnit.unit).snd
h : f x = Sum.inl PUnit.unit
⊢ BinaryCofan.inl s { val := (x, PUnit.unit), property := (_ : f x = Sum.inl PUnit.unit) } =
    BinaryCofan.inr s { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
cases h.symm.trans hx
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
x : Z
hx : f (x, PUnit.unit).fst = Sum.inr (x, PUnit.unit).snd
h : ¬f x = Sum.inl PUnit.unit
⊢ BinaryCofan.inr s { val := (x, PUnit.unit), property := (_ : f x = Sum.inr PUnit.unit) } =
    BinaryCofan.inr s { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
rfl
[GOAL]
case h₂.uniq
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀ (s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }) (m : Z ⟶ s.pt),
    (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s →
      (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s →
        m = fun x =>
          if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
          else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
intro s m e₁ e₂
[GOAL]
case h₂.uniq
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
⊢ m = fun x =>
    if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
    else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
ext x
[GOAL]
case h₂.uniq.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
x : Z
⊢ m x =
    if h : f x = Sum.inl PUnit.unit then BinaryCofan.inl s (↑eX.symm { val := x, property := h })
    else BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
split_ifs
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
x : Z
h✝ : f x = Sum.inl PUnit.unit
⊢ m x = BinaryCofan.inl s (↑eX.symm { val := x, property := h✝ })
[PROOFSTEP]
rw [← e₁]
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
x : Z
h✝ : f x = Sum.inl PUnit.unit
⊢ m x = ((fun p => (↑p).fst) ≫ m) (↑eX.symm { val := x, property := h✝ })
[PROOFSTEP]
rfl
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
x : Z
h✝ : ¬f x = Sum.inl PUnit.unit
⊢ m x = BinaryCofan.inr s (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
rw [← e₂]
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit PUnit).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.fst = Sum.inl p.snd } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.fst = Sum.inr p.snd } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.fst = Sum.inl p.snd } { p // f p.fst = Sum.inr p.snd }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).fst) ≫ m = BinaryCofan.inr s
x : Z
h✝ : ¬f x = Sum.inl PUnit.unit
⊢ m x = ((fun p => (↑p).fst) ≫ m) (↑eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
⊢ IsColimit
    (BinaryCofan.mk (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
      (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
[PROOFSTEP]
have : ∀ x, f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit :=
  by
  intro x
  rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
  exacts [Or.inl rfl, Or.inr rfl]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
⊢ ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
x : (forget TopCat).obj Z
⊢ ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
[PROOFSTEP]
rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
[GOAL]
case inl.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
x : (forget TopCat).obj Z
⊢ Sum.inl PUnit.unit = Sum.inl PUnit.unit ∨ Sum.inl PUnit.unit = Sum.inr PUnit.unit
case inr.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
x : (forget TopCat).obj Z
⊢ Sum.inr PUnit.unit = Sum.inl PUnit.unit ∨ Sum.inr PUnit.unit = Sum.inr PUnit.unit
[PROOFSTEP]
exacts [Or.inl rfl, Or.inr rfl]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
⊢ IsColimit
    (BinaryCofan.mk (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
      (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
[PROOFSTEP]
letI eX : { p : Z × PUnit // f p.fst = Sum.inl p.snd } ≃ { x : Z // f x = Sum.inl PUnit.unit } :=
  ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inl <| Subsingleton.elim _ _)⟩, fun x => ⟨⟨_, PUnit.unit⟩, x.2⟩, fun _ =>
    by ext; rfl, fun _ => by ext; rfl⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
x✝ : { p // ↑f p.fst = Sum.inl p.snd }
⊢ (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
      ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a.h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
x✝ : { p // ↑f p.fst = Sum.inl p.snd }
⊢ (↑((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
          ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x✝))).fst =
    (↑x✝).fst
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
x✝ : { x // ↑f x = Sum.inl PUnit.unit }
⊢ (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
      ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
x✝ : { x // ↑f x = Sum.inl PUnit.unit }
⊢ ↑((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
        ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x✝)) =
    ↑x✝
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
⊢ IsColimit
    (BinaryCofan.mk (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
      (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
[PROOFSTEP]
letI eY : { p : Z × PUnit // f p.fst = Sum.inr p.snd } ≃ { x : Z // f x = Sum.inr PUnit.unit } :=
  ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩, fun x => ⟨⟨_, PUnit.unit⟩, x.2⟩, fun _ =>
    by ext; rfl, fun _ => by ext; rfl⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { p // ↑f p.fst = Sum.inr p.snd }
⊢ (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
      ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a.h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { p // ↑f p.fst = Sum.inr p.snd }
⊢ (↑((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
          ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x✝))).fst =
    (↑x✝).fst
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { x // ↑f x = Sum.inr PUnit.unit }
⊢ (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
      ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x✝) =
    x✝
[PROOFSTEP]
ext
[GOAL]
case a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
x✝ : { x // ↑f x = Sum.inr PUnit.unit }
⊢ ↑((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
        ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x✝)) =
    ↑x✝
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ IsColimit
    (BinaryCofan.mk (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
      (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
[PROOFSTEP]
fapply BinaryCofan.isColimitMk
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })) →
    Z ⟶ s.pt
case fac_left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })),
    TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ ?desc s =
      BinaryCofan.inl s
case fac_right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })),
    TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ ?desc s =
      BinaryCofan.inr s
case uniq
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd }))
    (m : Z ⟶ s.pt),
    TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
        BinaryCofan.inl s →
      TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
          BinaryCofan.inr s →
        m = ?desc s
[PROOFSTEP]
classical
  -- Porting note: Added
· refine' fun s =>
    ⟨fun x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩, _⟩
  rw [continuous_iff_continuousAt]
  intro x
  by_cases f x = Sum.inl PUnit.unit
  · revert h x
    apply (IsOpen.continuousOn_iff _).mp
    · rw [continuousOn_iff_continuous_restrict]
      convert_to Continuous fun x : {x | f x = Sum.inl PUnit.unit} => s.inl ⟨(x.1, PUnit.unit), x.2⟩
      · ext ⟨x, hx⟩
        exact dif_pos hx
      have := (BinaryCofan.inl s).2
      continuity
    · convert f.2.1 _ openEmbedding_inl.open_range
      rename_i x
      exact ⟨fun h => ⟨_, h.symm⟩, fun ⟨e, h⟩ => h.symm.trans (congr_arg Sum.inl <| Subsingleton.elim _ _)⟩
  · revert h x
    apply (IsOpen.continuousOn_iff _).mp
    · rw [continuousOn_iff_continuous_restrict]
      convert_to
        Continuous fun x : {x | f x ≠ Sum.inl PUnit.unit} => s.inr ⟨(x.1, PUnit.unit), (this _).resolve_left x.2⟩
      · ext ⟨x, hx⟩
        exact dif_neg hx
      have := (BinaryCofan.inr s).2
      continuity
    · convert f.2.1 _ openEmbedding_inr.open_range
      rename_i x
      change f x ≠ Sum.inl PUnit.unit ↔ f x ∈ Set.range Sum.inr
      trans f x = Sum.inr PUnit.unit
      · rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> simp only [iff_self_iff, eq_self_iff_true, not_true, Ne.def, not_false_iff]
      · exact ⟨fun h => ⟨_, h.symm⟩, fun ⟨e, h⟩ => h.symm.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩
· intro s
  ext ⟨⟨x, ⟨⟩⟩, (hx : f x = Sum.inl PUnit.unit)⟩
  change dite _ _ _ = _
  split_ifs with h
  · rfl
  ·
    cases
      (h hx)
        -- Porting note : in Lean3 it is `rfl`
· intro s
  ext ⟨⟨x, ⟨⟩⟩, hx⟩
  change dite _ _ _ = _
  split_ifs with h
  · cases h.symm.trans hx
  · rfl
· intro s m e₁ e₂
  ext x
  change m x = dite _ _ _
  split_ifs
  · rw [← e₁]
    rfl
  · rw [← e₂]
    rfl
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })) →
    Z ⟶ s.pt
[PROOFSTEP]
refine' fun s =>
  ⟨fun x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩) fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩, _⟩
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ Continuous fun x =>
    if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
    else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
rw [continuous_iff_continuousAt]
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ ∀ (x : ↑Z),
    ContinuousAt
      (fun x =>
        if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
        else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      x
[PROOFSTEP]
intro x
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ContinuousAt
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    x
[PROOFSTEP]
by_cases f x = Sum.inl PUnit.unit
[GOAL]
case desc
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ContinuousAt
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    x
[PROOFSTEP]
by_cases f x = Sum.inl PUnit.unit
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
h : ↑f x = Sum.inl PUnit.unit
⊢ ContinuousAt
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    x
[PROOFSTEP]
revert h x
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ ∀ (x : ↑Z),
    ↑f x = Sum.inl PUnit.unit →
      ContinuousAt
        (fun x =>
          if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
          else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
        x
[PROOFSTEP]
apply (IsOpen.continuousOn_iff _).mp
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ ContinuousOn
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    fun a => ↑f a = Sum.inl PUnit.unit
[PROOFSTEP]
rw [continuousOn_iff_continuous_restrict]
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ Continuous
    (Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit) fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
[PROOFSTEP]
convert_to Continuous fun x : {x | f x = Sum.inl PUnit.unit} => s.inl ⟨(x.1, PUnit.unit), x.2⟩
[GOAL]
case h.e'_5.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
e_1✝ : (↑fun a => ↑f a = Sum.inl PUnit.unit) = ↑{x | ↑f x = Sum.inl PUnit.unit}
e_2✝ : ↑s.pt = (forget TopCat).obj (((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := WalkingPair.left })
⊢ (Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit) fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
    fun x => ↑(BinaryCofan.inl s) { val := (↑x, PUnit.unit), property := (_ : ↑x ∈ {x | ↑f x = Sum.inl PUnit.unit}) }
[PROOFSTEP]
ext ⟨x, hx⟩
[GOAL]
case h.e'_5.h.h.mk
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
e_1✝ : (↑fun a => ↑f a = Sum.inl PUnit.unit) = ↑{x | ↑f x = Sum.inl PUnit.unit}
e_2✝ : ↑s.pt = (forget TopCat).obj (((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := WalkingPair.left })
x : ↑Z
hx : x ∈ fun a => ↑f a = Sum.inl PUnit.unit
⊢ Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit)
      (fun x =>
        if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
        else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      { val := x, property := hx } =
    ↑(BinaryCofan.inl s)
      { val := (↑{ val := x, property := hx }, PUnit.unit),
        property := (_ : ↑{ val := x, property := hx } ∈ {x | ↑f x = Sum.inl PUnit.unit}) }
[PROOFSTEP]
exact dif_pos hx
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ Continuous fun x =>
    ↑(BinaryCofan.inl s) { val := (↑x, PUnit.unit), property := (_ : ↑x ∈ {x | ↑f x = Sum.inl PUnit.unit}) }
[PROOFSTEP]
have := (BinaryCofan.inl s).2
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this✝ : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
this : Continuous (BinaryCofan.inl s).toFun
⊢ Continuous fun x =>
    ↑(BinaryCofan.inl s) { val := (↑x, PUnit.unit), property := (_ : ↑x ∈ {x | ↑f x = Sum.inl PUnit.unit}) }
[PROOFSTEP]
continuity
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ IsOpen fun a => ↑f a = Sum.inl PUnit.unit
[PROOFSTEP]
convert f.2.1 _ openEmbedding_inl.open_range
[GOAL]
case h.e'_3.h.a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x✝ : ↑Z
⊢ ↑f x✝ = Sum.inl PUnit.unit ↔ (f.toFun ⁻¹' Set.range Sum.inl) x✝
[PROOFSTEP]
rename_i x
[GOAL]
case h.e'_3.h.a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ↑f x = Sum.inl PUnit.unit ↔ (f.toFun ⁻¹' Set.range Sum.inl) x
[PROOFSTEP]
exact ⟨fun h => ⟨_, h.symm⟩, fun ⟨e, h⟩ => h.symm.trans (congr_arg Sum.inl <| Subsingleton.elim _ _)⟩
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
h : ¬↑f x = Sum.inl PUnit.unit
⊢ ContinuousAt
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    x
[PROOFSTEP]
revert h x
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ ∀ (x : ↑Z),
    ¬↑f x = Sum.inl PUnit.unit →
      ContinuousAt
        (fun x =>
          if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
          else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
        x
[PROOFSTEP]
apply (IsOpen.continuousOn_iff _).mp
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ ContinuousOn
    (fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
    fun a => ↑f a = Sum.inl PUnit.unit → False
[PROOFSTEP]
rw [continuousOn_iff_continuous_restrict]
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ Continuous
    (Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit → False) fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
[PROOFSTEP]
convert_to Continuous fun x : {x | f x ≠ Sum.inl PUnit.unit} => s.inr ⟨(x.1, PUnit.unit), (this _).resolve_left x.2⟩
[GOAL]
case h.e'_5.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
e_1✝ : (↑fun a => ↑f a = Sum.inl PUnit.unit → False) = ↑{x | ↑f x ≠ Sum.inl PUnit.unit}
e_2✝ : ↑s.pt = (forget TopCat).obj (((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := WalkingPair.right })
⊢ (Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit → False) fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
    fun x =>
    ↑(BinaryCofan.inr s) { val := (↑x, PUnit.unit), property := (_ : ↑f (↑x, PUnit.unit).fst = Sum.inr PUnit.unit) }
[PROOFSTEP]
ext ⟨x, hx⟩
[GOAL]
case h.e'_5.h.h.mk
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
e_1✝ : (↑fun a => ↑f a = Sum.inl PUnit.unit → False) = ↑{x | ↑f x ≠ Sum.inl PUnit.unit}
e_2✝ : ↑s.pt = (forget TopCat).obj (((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := WalkingPair.right })
x : ↑Z
hx : x ∈ fun a => ↑f a = Sum.inl PUnit.unit → False
⊢ Set.restrict (fun a => ↑f a = Sum.inl PUnit.unit → False)
      (fun x =>
        if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
        else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      { val := x, property := hx } =
    ↑(BinaryCofan.inr s)
      { val := (↑{ val := x, property := hx }, PUnit.unit),
        property := (_ : ↑f (↑{ val := x, property := hx }, PUnit.unit).fst = Sum.inr PUnit.unit) }
[PROOFSTEP]
exact dif_neg hx
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ Continuous fun x =>
    ↑(BinaryCofan.inr s) { val := (↑x, PUnit.unit), property := (_ : ↑f (↑x, PUnit.unit).fst = Sum.inr PUnit.unit) }
[PROOFSTEP]
have := (BinaryCofan.inr s).2
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this✝ : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
this : Continuous (BinaryCofan.inr s).toFun
⊢ Continuous fun x =>
    ↑(BinaryCofan.inr s) { val := (↑x, PUnit.unit), property := (_ : ↑f (↑x, PUnit.unit).fst = Sum.inr PUnit.unit) }
[PROOFSTEP]
continuity
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ IsOpen fun a => ↑f a = Sum.inl PUnit.unit → False
[PROOFSTEP]
convert f.2.1 _ openEmbedding_inr.open_range
[GOAL]
case h.e'_3.h.a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x✝ : ↑Z
⊢ ↑f x✝ = Sum.inl PUnit.unit → False ↔ (f.toFun ⁻¹' Set.range Sum.inr) x✝
[PROOFSTEP]
rename_i x
[GOAL]
case h.e'_3.h.a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ↑f x = Sum.inl PUnit.unit → False ↔ (f.toFun ⁻¹' Set.range Sum.inr) x
[PROOFSTEP]
change f x ≠ Sum.inl PUnit.unit ↔ f x ∈ Set.range Sum.inr
[GOAL]
case h.e'_3.h.a
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ↑f x ≠ Sum.inl PUnit.unit ↔ ↑f x ∈ Set.range Sum.inr
[PROOFSTEP]
trans f x = Sum.inr PUnit.unit
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ↑f x ≠ Sum.inl PUnit.unit ↔ ↑f x = Sum.inr PUnit.unit
[PROOFSTEP]
rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
[GOAL]
case inl.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ Sum.inl PUnit.unit ≠ Sum.inl PUnit.unit ↔ Sum.inl PUnit.unit = Sum.inr PUnit.unit
[PROOFSTEP]
simp only [iff_self_iff, eq_self_iff_true, not_true, Ne.def, not_false_iff]
[GOAL]
case inr.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ Sum.inr PUnit.unit ≠ Sum.inl PUnit.unit ↔ Sum.inr PUnit.unit = Sum.inr PUnit.unit
[PROOFSTEP]
simp only [iff_self_iff, eq_self_iff_true, not_true, Ne.def, not_false_iff]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
⊢ ↑f x = Sum.inr PUnit.unit ↔ ↑f x ∈ Set.range Sum.inr
[PROOFSTEP]
exact ⟨fun h => ⟨_, h.symm⟩, fun ⟨e, h⟩ => h.symm.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩
[GOAL]
case fac_left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })),
    (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
        ContinuousMap.mk fun x =>
          if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
          else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
      BinaryCofan.inl s
[PROOFSTEP]
intro s
[GOAL]
case fac_left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ (TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
      ContinuousMap.mk fun x =>
        if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
        else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
    BinaryCofan.inl s
[PROOFSTEP]
ext ⟨⟨x, ⟨⟩⟩, (hx : f x = Sum.inl PUnit.unit)⟩
[GOAL]
case fac_left.w.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx : ↑f x = Sum.inl PUnit.unit
⊢ ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
          ContinuousMap.mk fun x =>
            if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
            else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      { val := (x, PUnit.unit), property := hx } =
    ↑(BinaryCofan.inl s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
change dite _ _ _ = _
[GOAL]
case fac_left.w.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx : ↑f x = Sum.inl PUnit.unit
⊢ (if h :
        ↑f
            (↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
              { val := (x, PUnit.unit), property := hx }) =
          Sum.inl PUnit.unit then
      (fun h =>
          ↑(BinaryCofan.inl s)
            (↑eX.symm
              {
                val :=
                  ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                    { val := (x, PUnit.unit), property := hx },
                property := h }))
        h
    else
      (fun h =>
          ↑(BinaryCofan.inr s)
            (↑eY.symm
              {
                val :=
                  ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                    { val := (x, PUnit.unit), property := hx },
                property :=
                  (_ :
                    ↑f
                        (↑(TopCat.pullbackFst f
                              (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                          { val := (x, PUnit.unit), property := hx }) =
                      Sum.inr PUnit.unit) }))
        h) =
    ↑(BinaryCofan.inl s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx : ↑f x = Sum.inl PUnit.unit
h :
  ↑f
      (↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
        { val := (x, PUnit.unit), property := hx }) =
    Sum.inl PUnit.unit
⊢ (fun h =>
        ↑(BinaryCofan.inl s)
          (↑eX.symm
            {
              val :=
                ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                  { val := (x, PUnit.unit), property := hx },
              property := h }))
      h =
    ↑(BinaryCofan.inl s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
rfl
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx : ↑f x = Sum.inl PUnit.unit
h :
  ¬↑f
        (↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
          { val := (x, PUnit.unit), property := hx }) =
      Sum.inl PUnit.unit
⊢ (fun h =>
        ↑(BinaryCofan.inr s)
          (↑eY.symm
            {
              val :=
                ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                  { val := (x, PUnit.unit), property := hx },
              property :=
                (_ :
                  ↑f
                      (↑(TopCat.pullbackFst f
                            (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                        { val := (x, PUnit.unit), property := hx }) =
                    Sum.inr PUnit.unit) }))
      h =
    ↑(BinaryCofan.inl s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
cases
  (h hx)
    -- Porting note : in Lean3 it is `rfl`
[GOAL]
case fac_right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })),
    (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
        ContinuousMap.mk fun x =>
          if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
          else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
      BinaryCofan.inr s
[PROOFSTEP]
intro s
[GOAL]
case fac_right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
⊢ (TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
      ContinuousMap.mk fun x =>
        if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
        else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) =
    BinaryCofan.inr s
[PROOFSTEP]
ext ⟨⟨x, ⟨⟩⟩, hx⟩
[GOAL]
case fac_right.w.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx :
  ↑f (x, PUnit.unit).fst =
    ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) (x, PUnit.unit).snd
⊢ ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫
          ContinuousMap.mk fun x =>
            if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
            else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      { val := (x, PUnit.unit), property := hx } =
    ↑(BinaryCofan.inr s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
change dite _ _ _ = _
[GOAL]
case fac_right.w.mk.mk.unit
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx :
  ↑f (x, PUnit.unit).fst =
    ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) (x, PUnit.unit).snd
⊢ (if h :
        ↑f
            (↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
              { val := (x, PUnit.unit), property := hx }) =
          Sum.inl PUnit.unit then
      (fun h =>
          ↑(BinaryCofan.inl s)
            (↑eX.symm
              {
                val :=
                  ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                    { val := (x, PUnit.unit), property := hx },
                property := h }))
        h
    else
      (fun h =>
          ↑(BinaryCofan.inr s)
            (↑eY.symm
              {
                val :=
                  ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                    { val := (x, PUnit.unit), property := hx },
                property :=
                  (_ :
                    ↑f
                        (↑(TopCat.pullbackFst f
                              (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                          { val := (x, PUnit.unit), property := hx }) =
                      Sum.inr PUnit.unit) }))
        h) =
    ↑(BinaryCofan.inr s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx :
  ↑f (x, PUnit.unit).fst =
    ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) (x, PUnit.unit).snd
h :
  ↑f
      (↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
        { val := (x, PUnit.unit), property := hx }) =
    Sum.inl PUnit.unit
⊢ (fun h =>
        ↑(BinaryCofan.inl s)
          (↑eX.symm
            {
              val :=
                ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                  { val := (x, PUnit.unit), property := hx },
              property := h }))
      h =
    ↑(BinaryCofan.inr s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
cases h.symm.trans hx
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
x : ↑Z
hx :
  ↑f (x, PUnit.unit).fst =
    ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) (x, PUnit.unit).snd
h :
  ¬↑f
        (↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
          { val := (x, PUnit.unit), property := hx }) =
      Sum.inl PUnit.unit
⊢ (fun h =>
        ↑(BinaryCofan.inr s)
          (↑eY.symm
            {
              val :=
                ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                  { val := (x, PUnit.unit), property := hx },
              property :=
                (_ :
                  ↑f
                      (↑(TopCat.pullbackFst f
                            (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))
                        { val := (x, PUnit.unit), property := hx }) =
                    Sum.inr PUnit.unit) }))
      h =
    ↑(BinaryCofan.inr s) { val := (x, PUnit.unit), property := hx }
[PROOFSTEP]
rfl
[GOAL]
case uniq
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
⊢ ∀
    (s :
      BinaryCofan
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
        (TopCat.of
          { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd }))
    (m : Z ⟶ s.pt),
    TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
        BinaryCofan.inl s →
      TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
          BinaryCofan.inr s →
        m =
          ContinuousMap.mk fun x =>
            if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
            else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
intro s m e₁ e₂
[GOAL]
case uniq
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
⊢ m =
    ContinuousMap.mk fun x =>
      if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
      else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })
[PROOFSTEP]
ext x
[GOAL]
case uniq.w
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
⊢ ↑m x =
    ↑(ContinuousMap.mk fun x =>
          if h : ↑f x = Sum.inl PUnit.unit then ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })
          else ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      x
[PROOFSTEP]
change m x = dite _ _ _
[GOAL]
case uniq.w
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
⊢ ↑m x =
    if h : ↑f x = Sum.inl PUnit.unit then (fun h => ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })) h
    else (fun h => ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) h
[PROOFSTEP]
split_ifs
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
h✝ : ↑f x = Sum.inl PUnit.unit
⊢ ↑m x = (fun h => ↑(BinaryCofan.inl s) (↑eX.symm { val := x, property := h })) h✝
[PROOFSTEP]
rw [← e₁]
[GOAL]
case pos
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
h✝ : ↑f x = Sum.inl PUnit.unit
⊢ ↑m x =
    (fun h =>
        ↑(TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m)
          (↑eX.symm { val := x, property := h }))
      h✝
[PROOFSTEP]
rfl
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
h✝ : ¬↑f x = Sum.inl PUnit.unit
⊢ ↑m x = (fun h => ↑(BinaryCofan.inr s) (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) })) h✝
[PROOFSTEP]
rw [← e₂]
[GOAL]
case neg
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ TopCat.of (PUnit ⊕ PUnit)
this : ∀ (x : (forget TopCat).obj Z), ↑f x = Sum.inl PUnit.unit ∨ ↑f x = Sum.inr PUnit.unit
eX : { p // ↑f p.fst = Sum.inl p.snd } ≃ { x // ↑f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inl p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // ↑f p.fst = Sum.inr p.snd } ≃ { x // ↑f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // ↑f p.fst = Sum.inr p.snd }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // ↑f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).fst, property := (_ : ↑f (↑p).fst = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : ↑f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s :
  BinaryCofan
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
    (TopCat.of { p // ↑f p.fst = ↑(BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) p.snd })
m : Z ⟶ s.pt
e₁ :
  TopCat.pullbackFst f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inl s
e₂ :
  TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m =
    BinaryCofan.inr s
x : (forget TopCat).obj Z
h✝ : ¬↑f x = Sum.inl PUnit.unit
⊢ ↑m x =
    (fun h =>
        ↑(TopCat.pullbackFst f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ≫ m)
          (↑eY.symm { val := x, property := (_ : ↑f x = Sum.inr PUnit.unit) }))
      h✝
[PROOFSTEP]
rfl
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ FinitaryExtensive TopCat
[PROOFSTEP]
rw [finitaryExtensive_iff_of_isTerminal TopCat.{u} _ TopCat.isTerminalPUnit _ (TopCat.binaryCofanIsColimit _ _)]
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ IsVanKampenColimit (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))
[PROOFSTEP]
apply
  BinaryCofan.isVanKampen_mk _ _ (fun X Y => TopCat.binaryCofanIsColimit X Y) _ fun f g =>
    TopCat.pullbackConeIsLimit f g
[GOAL]
case h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ ∀ {X' Y' : TopCat} (αX : X' ⟶ TopCat.of PUnit) (αY : Y' ⟶ TopCat.of PUnit)
    (f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt),
    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f →
      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
          BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX f
            (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ∧
          IsPullback (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY f
            (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
[PROOFSTEP]
intro X' Y' αX αY f hαX hαY
[GOAL]
case h₁
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
⊢ IsPullback (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX f
      (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))) ∧
    IsPullback (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY f
      (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
[PROOFSTEP]
constructor
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
⊢ IsPullback (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX f
    (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
[PROOFSTEP]
refine' ⟨⟨hαX.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
⊢ (s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) →
    { l //
      l ≫
            PullbackCone.fst
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                (_ :
                  BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.fst s ∧
        l ≫
              PullbackCone.snd
                (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                  (_ :
                    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                      αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
            PullbackCone.snd s ∧
          ∀
            {m :
              s.pt ⟶
                (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                    (_ :
                      BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                        αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
            m ≫
                  PullbackCone.fst
                    (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                      (_ :
                        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                          αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.fst s →
              m ≫
                    PullbackCone.snd
                      (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                        (_ :
                          BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                            αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
              (_ :
                BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                (_ :
                  BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                  (_ :
                    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                      αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                    (_ :
                      BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                        αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                      (_ :
                        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                          αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
have : ∀ x, ∃! y, s.fst x = Sum.inl y := by
  intro x
  cases' h : s.fst x with val val
  · exact ⟨val, rfl, fun y h => Sum.inl_injective h.symm⟩
  · apply_fun f at h 
    cases ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans (ConcreteCategory.congr_hom hαY val : _).symm
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
⊢ ∀ (x : (forget TopCat).obj s.pt), ∃! y, ↑(PullbackCone.fst s) x = Sum.inl y
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
⊢ ∃! y, ↑(PullbackCone.fst s) x = Sum.inl y
[PROOFSTEP]
cases' h : s.fst x with val val
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑X'
h : ↑(PullbackCone.fst s) x = Sum.inl val
⊢ ∃! y, Sum.inl val = Sum.inl y
[PROOFSTEP]
exact ⟨val, rfl, fun y h => Sum.inl_injective h.symm⟩
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑Y'
h : ↑(PullbackCone.fst s) x = Sum.inr val
⊢ ∃! y, Sum.inr val = Sum.inl y
[PROOFSTEP]
apply_fun f at h 
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑Y'
h : ↑f (↑(PullbackCone.fst s) x) = ↑f (Sum.inr val)
⊢ ∃! y, Sum.inr val = Sum.inl y
[PROOFSTEP]
cases ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans (ConcreteCategory.congr_hom hαY val : _).symm
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
this : ∀ (x : (forget TopCat).obj s.pt), ∃! y, ↑(PullbackCone.fst s) x = Sum.inl y
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
              (_ :
                BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                (_ :
                  BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                  (_ :
                    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                      αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                    (_ :
                      BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                        αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                      (_ :
                        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                          αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
delta ExistsUnique at this 
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
this :
  ∀ (x : (forget TopCat).obj s.pt),
    ∃ x_1,
      (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) x_1 ∧
        ∀ (y : ↑X'), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) y → y = x_1
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
              (_ :
                BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                (_ :
                  BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                  (_ :
                    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                      αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                    (_ :
                      BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                        αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                      (_ :
                        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                          αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
choose l hl hl' using this
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑X'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑X'), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) y → y = l x
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
              (_ :
                BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                (_ :
                  BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                    αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                  (_ :
                    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                      αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                    (_ :
                      BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                        αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inl (TopCat.binaryCofan X' Y')) αX
                      (_ :
                        BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f =
                          αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
refine'
  ⟨⟨l, _⟩, ContinuousMap.ext fun a => (hl a).symm, TopCat.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ =>
    ContinuousMap.ext fun x => hl' x (l' x) (ConcreteCategory.congr_hom h₁ x).symm⟩
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑X'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑X'), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) y → y = l x
⊢ Continuous l
[PROOFSTEP]
apply (embedding_inl (α := X') (β := Y')).toInducing.continuous_iff.mpr
[GOAL]
case h₁.left
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑X'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑X'), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) y → y = l x
⊢ Continuous (Sum.inl ∘ l)
[PROOFSTEP]
convert s.fst.2 using 1
[GOAL]
case h.e'_5.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑X'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑X'), (fun y => ↑(PullbackCone.fst s) x = Sum.inl y) y → y = l x
e_2✝ :
  (↑X' ⊕ ↑Y') =
    ↑(((Functor.const (Discrete WalkingPair)).obj (TopCat.binaryCofan X' Y').pt).obj { as := WalkingPair.left })
⊢ Sum.inl ∘ l = (PullbackCone.fst s).toFun
[PROOFSTEP]
exact (funext hl).symm
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
⊢ IsPullback (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY f
    (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
[PROOFSTEP]
refine' ⟨⟨hαY.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
⊢ (s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) →
    { l //
      l ≫
            PullbackCone.fst
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.fst s ∧
        l ≫
              PullbackCone.snd
                (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
            PullbackCone.snd s ∧
          ∀
            {m :
              s.pt ⟶
                (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
            m ≫
                  PullbackCone.fst
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.fst s →
              m ≫
                    PullbackCone.snd
                      (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                        (_ :
                          BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                            αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
              (_ :
                BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
have : ∀ x, ∃! y, s.fst x = Sum.inr y := by
  intro x
  cases' h : s.fst x with val val
  · apply_fun f at h 
    cases ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans (ConcreteCategory.congr_hom hαX val : _).symm
  · exact ⟨val, rfl, fun y h => Sum.inr_injective h.symm⟩
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
⊢ ∀ (x : (forget TopCat).obj s.pt), ∃! y, ↑(PullbackCone.fst s) x = Sum.inr y
[PROOFSTEP]
intro x
[GOAL]
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
⊢ ∃! y, ↑(PullbackCone.fst s) x = Sum.inr y
[PROOFSTEP]
cases' h : s.fst x with val val
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑X'
h : ↑(PullbackCone.fst s) x = Sum.inl val
⊢ ∃! y, Sum.inl val = Sum.inr y
[PROOFSTEP]
apply_fun f at h 
[GOAL]
case inl
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑X'
h : ↑f (↑(PullbackCone.fst s) x) = ↑f (Sum.inl val)
⊢ ∃! y, Sum.inl val = Sum.inr y
[PROOFSTEP]
cases ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans (ConcreteCategory.congr_hom hαX val : _).symm
[GOAL]
case inr
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
x : (forget TopCat).obj s.pt
val : ↑Y'
h : ↑(PullbackCone.fst s) x = Sum.inr val
⊢ ∃! y, Sum.inr val = Sum.inr y
[PROOFSTEP]
exact ⟨val, rfl, fun y h => Sum.inr_injective h.symm⟩
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
this : ∀ (x : (forget TopCat).obj s.pt), ∃! y, ↑(PullbackCone.fst s) x = Sum.inr y
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
              (_ :
                BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
delta ExistsUnique at this 
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
this :
  ∀ (x : (forget TopCat).obj s.pt),
    ∃ x_1,
      (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) x_1 ∧
        ∀ (y : ↑Y'), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) y → y = x_1
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
              (_ :
                BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
choose l hl hl' using this
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑Y'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑Y'), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) y → y = l x
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
              (_ :
                BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
refine'
  ⟨⟨l, _⟩, ContinuousMap.ext fun a => (hl a).symm, TopCat.isTerminalPUnit.hom_ext _ _, fun {l'} h₁ _ =>
    ContinuousMap.ext fun x => hl' x (l' x) (ConcreteCategory.congr_hom h₁ x).symm⟩
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑Y'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑Y'), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) y → y = l x
⊢ Continuous l
[PROOFSTEP]
apply (embedding_inr (α := X') (β := Y')).toInducing.continuous_iff.mpr
[GOAL]
case h₁.right
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑Y'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑Y'), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) y → y = l x
⊢ Continuous (Sum.inr ∘ l)
[PROOFSTEP]
convert s.fst.2 using 1
[GOAL]
case h.e'_5.h
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit
αY : Y' ⟶ TopCat.of PUnit
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))
l : (forget TopCat).obj s.pt → ↑Y'
hl : ∀ (x : (forget TopCat).obj s.pt), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) (l x)
hl' : ∀ (x : (forget TopCat).obj s.pt) (y : ↑Y'), (fun y => ↑(PullbackCone.fst s) x = Sum.inr y) y → y = l x
e_2✝ :
  (↑X' ⊕ ↑Y') =
    ↑(((Functor.const (Discrete WalkingPair)).obj (TopCat.binaryCofan X' Y').pt).obj { as := WalkingPair.right })
⊢ Sum.inr ∘ l = (PullbackCone.fst s).toFun
[PROOFSTEP]
exact (funext hl).symm
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
⊢ {Z : TopCat} →
    (f : Z ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt) →
      IsColimit
        (BinaryCofan.mk
          (PullbackCone.fst
            (TopCat.pullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
          (PullbackCone.fst
            (TopCat.pullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))))
[PROOFSTEP]
intro Z f
[GOAL]
case h₂
J : Type v'
inst✝¹ : Category.{u', v'} J
C : Type u
inst✝ : Category.{v, u} C
X Y : C
Z : TopCat
f : Z ⟶ (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)).pt
⊢ IsColimit
    (BinaryCofan.mk
      (PullbackCone.fst
        (TopCat.pullbackCone f (BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit)))))
      (PullbackCone.fst
        (TopCat.pullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit) (TopCat.of PUnit))))))
[PROOFSTEP]
exact finitaryExtensiveTopCatAux Z f
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
⊢ IsVanKampenColimit c'
[PROOFSTEP]
intro F' c'' α f h hα
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c'') ↔ ∀ (j : J), IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
have : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι := by
  ext j
  exact e.inv.2 j
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
[PROOFSTEP]
ext j
[GOAL]
case w.h
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
j : J
⊢ NatTrans.app (c'.ι ≫ (Functor.const J).map e.inv.Hom) j = NatTrans.app c.ι j
[PROOFSTEP]
exact e.inv.2 j
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
⊢ Nonempty (IsColimit c'') ↔ ∀ (j : J), IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
rw [H c'' α (f ≫ e.inv.1) (by rw [Functor.map_comp, ← reassoc_of% h, this]) hα]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
⊢ α ≫ c.ι = c''.ι ≫ (Functor.const J).map (f ≫ e.inv.Hom)
[PROOFSTEP]
rw [Functor.map_comp, ← reassoc_of% h, this]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
⊢ (∀ (j : J), IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) (f ≫ e.inv.Hom) (NatTrans.app c.ι j)) ↔
    ∀ (j : J), IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
apply forall_congr'
[GOAL]
case h
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
⊢ ∀ (a : J),
    IsPullback (NatTrans.app c''.ι a) (NatTrans.app α a) (f ≫ e.inv.Hom) (NatTrans.app c.ι a) ↔
      IsPullback (NatTrans.app c''.ι a) (NatTrans.app α a) f (NatTrans.app c'.ι a)
[PROOFSTEP]
intro j
[GOAL]
case h
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
⊢ IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) (f ≫ e.inv.Hom) (NatTrans.app c.ι j) ↔
    IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
conv_lhs => rw [← Category.comp_id (α.app j)]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
| IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) (f ≫ e.inv.Hom) (NatTrans.app c.ι j)
[PROOFSTEP]
rw [← Category.comp_id (α.app j)]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
| IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) (f ≫ e.inv.Hom) (NatTrans.app c.ι j)
[PROOFSTEP]
rw [← Category.comp_id (α.app j)]
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
| IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) (f ≫ e.inv.Hom) (NatTrans.app c.ι j)
[PROOFSTEP]
rw [← Category.comp_id (α.app j)]
[GOAL]
case h
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
⊢ IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j ≫ 𝟙 (F.obj j)) (f ≫ e.inv.Hom) (NatTrans.app c.ι j) ↔
    IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
haveI : IsIso e.inv.Hom := Functor.map_isIso (Cocones.forget _) e.inv
[GOAL]
case h
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this✝ : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
this : IsIso e.inv.Hom
⊢ IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j ≫ 𝟙 (F.obj j)) (f ≫ e.inv.Hom) (NatTrans.app c.ι j) ↔
    IsPullback (NatTrans.app c''.ι j) (NatTrans.app α j) f (NatTrans.app c'.ι j)
[PROOFSTEP]
exact (IsPullback.of_vert_isIso ⟨by simp⟩).paste_vert_iff (NatTrans.congr_app h j).symm
[GOAL]
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
D : Type u''
inst✝ : Category.{v'', u''} D
F : J ⥤ C
c c' : Cocone F
H : IsVanKampenColimit c
e : c ≅ c'
F' : J ⥤ C
c'' : Cocone F'
α : F' ⟶ F
f : c''.pt ⟶ c'.pt
h : α ≫ c'.ι = c''.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this✝ : c'.ι ≫ (Functor.const J).map e.inv.Hom = c.ι
j : J
this : IsIso e.inv.Hom
⊢ NatTrans.app c'.ι j ≫ e.inv.Hom = 𝟙 (F.obj j) ≫ NatTrans.app c.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
⊢ IsVanKampenColimit c
[PROOFSTEP]
intro F' c' α f h hα
[GOAL]
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔ ∀ (j : J), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
refine'
  (Iff.trans _
        (H (G.mapCocone c') (whiskerRight α G) (G.map f) (by ext j; simpa using G.congr_map (NatTrans.congr_app h j))
          (hα.whiskerRight G))).trans
    (forall_congr' fun j => _)
[GOAL]
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ whiskerRight α G ≫ (G.mapCocone c).ι = (G.mapCocone c').ι ≫ (Functor.const J).map (G.map f)
[PROOFSTEP]
ext j
[GOAL]
case w.h
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
j : J
⊢ NatTrans.app (whiskerRight α G ≫ (G.mapCocone c).ι) j =
    NatTrans.app ((G.mapCocone c').ι ≫ (Functor.const J).map (G.map f)) j
[PROOFSTEP]
simpa using G.congr_map (NatTrans.congr_app h j)
[GOAL]
case refine'_1
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔ Nonempty (IsColimit (G.mapCocone c'))
[PROOFSTEP]
exact ⟨fun h => ⟨isColimitOfPreserves G h.some⟩, fun h => ⟨isColimitOfReflects G h.some⟩⟩
[GOAL]
case refine'_2
J : Type v'
inst✝⁷ : Category.{u', v'} J
C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D✝ : Type u''
inst✝⁵ : Category.{v'', u''} D✝
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝³ : PreservesLimitsOfShape WalkingCospan G
inst✝² : ReflectsLimitsOfShape WalkingCospan G
inst✝¹ : PreservesColimitsOfShape J G
inst✝ : ReflectsColimitsOfShape J G
H : IsVanKampenColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
j : J
⊢ IsPullback (NatTrans.app (G.mapCocone c').ι j) (NatTrans.app (whiskerRight α G) j) (G.map f)
      (NatTrans.app (G.mapCocone c).ι j) ↔
    IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
exact IsPullback.map_iff G (NatTrans.congr_app h.symm j)
[GOAL]
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
⊢ IsVanKampenColimit c
[PROOFSTEP]
intro F' c' α f e hα
[GOAL]
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
⊢ Nonempty (IsColimit c') ↔ ∀ (j : J), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
have := fun x =>
  hc x (((evaluation C D).obj x).mapCocone c') (whiskerRight α _) (((evaluation C D).obj x).map f)
    (by
      ext y
      dsimp
      exact NatTrans.congr_app (NatTrans.congr_app e y) x)
    (hα.whiskerRight _)
[GOAL]
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
x : C
⊢ whiskerRight α ((evaluation C D).obj x) ≫ (((evaluation C D).obj x).mapCocone c).ι =
    (((evaluation C D).obj x).mapCocone c').ι ≫ (Functor.const J).map (((evaluation C D).obj x).map f)
[PROOFSTEP]
ext y
[GOAL]
case w.h
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
x : C
y : J
⊢ NatTrans.app (whiskerRight α ((evaluation C D).obj x) ≫ (((evaluation C D).obj x).mapCocone c).ι) y =
    NatTrans.app ((((evaluation C D).obj x).mapCocone c').ι ≫ (Functor.const J).map (((evaluation C D).obj x).map f)) y
[PROOFSTEP]
dsimp
[GOAL]
case w.h
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
x : C
y : J
⊢ NatTrans.app (NatTrans.app α y) x ≫ NatTrans.app (NatTrans.app c.ι y) x =
    NatTrans.app (NatTrans.app c'.ι y) x ≫ NatTrans.app f x
[PROOFSTEP]
exact NatTrans.congr_app (NatTrans.congr_app e y) x
[GOAL]
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
⊢ Nonempty (IsColimit c') ↔ ∀ (j : J), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
constructor
[GOAL]
case mp
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
⊢ Nonempty (IsColimit c') → ∀ (j : J), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
rintro ⟨hc'⟩ j
[GOAL]
case mp.intro
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
hc' : IsColimit c'
j : J
⊢ IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)
[PROOFSTEP]
refine' ⟨⟨(NatTrans.congr_app e j).symm⟩, ⟨evaluationJointlyReflectsLimits _ _⟩⟩
[GOAL]
case mp.intro
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
hc' : IsColimit c'
j : J
⊢ (k : C) →
    IsLimit
      (((evaluation C D).obj k).mapCone
        (PullbackCone.mk (NatTrans.app c'.ι j) (NatTrans.app α j)
          (_ : NatTrans.app c'.ι j ≫ f = NatTrans.app α j ≫ NatTrans.app c.ι j)))
[PROOFSTEP]
refine' fun x => (isLimitMapConePullbackConeEquiv _ _).symm _
[GOAL]
case mp.intro
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
hc' : IsColimit c'
j : J
x : C
⊢ IsLimit
    (PullbackCone.mk (((evaluation C D).obj x).map (NatTrans.app c'.ι j))
      (((evaluation C D).obj x).map (NatTrans.app α j))
      (_ :
        ((evaluation C D).obj x).map (NatTrans.app c'.ι j) ≫ ((evaluation C D).obj x).map f =
          ((evaluation C D).obj x).map (NatTrans.app α j) ≫ ((evaluation C D).obj x).map (NatTrans.app c.ι j)))
[PROOFSTEP]
exact ((this x).mp ⟨PreservesColimit.preserves hc'⟩ _).isLimit
[GOAL]
case mpr
J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
D : Type u''
inst✝² : Category.{v'', u''} D
inst✝¹ : HasPullbacks D
inst✝ : HasColimitsOfShape J D
F : J ⥤ C ⥤ D
c : Cocone F
hc : ∀ (x : C), IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)
F' : J ⥤ C ⥤ D
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
e : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
this :
  ∀ (x : C),
    Nonempty (IsColimit (((evaluation C D).obj x).mapCocone c')) ↔
      ∀ (j : J),
        IsPullback (NatTrans.app (((evaluation C D).obj x).mapCocone c').ι j)
          (NatTrans.app (whiskerRight α ((evaluation C D).obj x)) j) (((evaluation C D).obj x).map f)
          (NatTrans.app (((evaluation C D).obj x).mapCocone c).ι j)
⊢ (∀ (j : J), IsPullback (NatTrans.app c'.ι j) (NatTrans.app α j) f (NatTrans.app c.ι j)) → Nonempty (IsColimit c')
[PROOFSTEP]
exact fun H =>
  ⟨evaluationJointlyReflectsColimits _ fun x => ((this x).mpr fun j => (H j).map ((evaluation C D).obj x)).some⟩
[GOAL]
J : Type v'
inst✝⁸ : Category.{u', v'} J
C : Type u
inst✝⁷ : Category.{v, u} C
X Y : C
D : Type u''
inst✝⁶ : Category.{v'', u''} D
F : C ⥤ D
inst✝⁵ : FinitaryExtensive D
inst✝⁴ : HasFiniteCoproducts C
inst✝³ : HasPullbacks C
inst✝² : PreservesLimitsOfShape WalkingCospan F
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) F
inst✝ : ReflectsIsomorphisms F
⊢ FinitaryExtensive C
[PROOFSTEP]
haveI : ReflectsLimitsOfShape WalkingCospan F := reflectsLimitsOfShapeOfReflectsIsomorphisms
[GOAL]
J : Type v'
inst✝⁸ : Category.{u', v'} J
C : Type u
inst✝⁷ : Category.{v, u} C
X Y : C
D : Type u''
inst✝⁶ : Category.{v'', u''} D
F : C ⥤ D
inst✝⁵ : FinitaryExtensive D
inst✝⁴ : HasFiniteCoproducts C
inst✝³ : HasPullbacks C
inst✝² : PreservesLimitsOfShape WalkingCospan F
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) F
inst✝ : ReflectsIsomorphisms F
this : ReflectsLimitsOfShape WalkingCospan F
⊢ FinitaryExtensive C
[PROOFSTEP]
haveI : ReflectsColimitsOfShape (Discrete WalkingPair) F := reflectsColimitsOfShapeOfReflectsIsomorphisms
[GOAL]
J : Type v'
inst✝⁸ : Category.{u', v'} J
C : Type u
inst✝⁷ : Category.{v, u} C
X Y : C
D : Type u''
inst✝⁶ : Category.{v'', u''} D
F : C ⥤ D
inst✝⁵ : FinitaryExtensive D
inst✝⁴ : HasFiniteCoproducts C
inst✝³ : HasPullbacks C
inst✝² : PreservesLimitsOfShape WalkingCospan F
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) F
inst✝ : ReflectsIsomorphisms F
this✝ : ReflectsLimitsOfShape WalkingCospan F
this : ReflectsColimitsOfShape (Discrete WalkingPair) F
⊢ FinitaryExtensive C
[PROOFSTEP]
exact finitaryExtensive_of_preserves_and_reflects F
