Theorem: CategoryTheory.is_coprod_iff_isPushout
File: Mathlib/CategoryTheory/Adhesive.lean

tactic: constructor
state_before: J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
⊢ Nonempty (IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)) ↔ IsPushout f (BinaryCofan.inl c) iY fE

tactic: rintro ⟨h⟩
state_before: case mp
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
⊢ Nonempty (IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)) → IsPushout f (BinaryCofan.inl c) iY fE

tactic: refine' ⟨H, ⟨Limits.PushoutCocone.isColimitAux' _ _⟩⟩
state_before: case mp.intro
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
⊢ IsPushout f (BinaryCofan.inl c) iY fE

tactic: intro s
state_before: case mp.intro
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
⊢ (s : PushoutCocone f (BinaryCofan.inl c)) →
    { l //
      PushoutCocone.inl (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ l = PushoutCocone.inl s ∧
        PushoutCocone.inr (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ l = PushoutCocone.inr s ∧
          ∀ {m : (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)).pt ⟶ s.pt},
            PushoutCocone.inl (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ m = PushoutCocone.inl s →
              PushoutCocone.inr (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ m =
                  PushoutCocone.inr s →
                m = l }

tactic: dsimp only [PushoutCocone.inr, PushoutCocone.mk]
state_before: case mp.intro
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ m = PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk iY fE (_ : f ≫ iY = BinaryCofan.inl c ≫ fE)) ≫ m = PushoutCocone.inr s →
              m = l }

tactic: refine' ⟨h.desc (BinaryCofan.mk (c.inr ≫ s.inr) s.inl), h.fac _ ⟨WalkingPair.right⟩, _, _⟩
state_before: case mp.intro
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ { l //
    PushoutCocone.inl
            { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
          l =
        PushoutCocone.inl s ∧
      fE ≫ l = s.ι.app WalkingSpan.right ∧
        ∀ {m : YE ⟶ s.pt},
          PushoutCocone.inl
                  { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
                m =
              PushoutCocone.inl s →
            fE ≫ m = s.ι.app WalkingSpan.right → m = l }

tactic: apply BinaryCofan.IsColimit.hom_ext hc
state_before: case mp.intro.refine'_1
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ fE ≫ IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    s.ι.app WalkingSpan.right

tactic: rw [← H.w_assoc]
state_before: case mp.intro.refine'_1.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ BinaryCofan.inl c ≫
      fE ≫ IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    BinaryCofan.inl c ≫ s.ι.app WalkingSpan.right

tactic: erw [h.fac _ ⟨WalkingPair.right⟩]
state_before: case mp.intro.refine'_1.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ f ≫ iY ≫ IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    BinaryCofan.inl c ≫ s.ι.app WalkingSpan.right

tactic: exact s.condition
state_before: case mp.intro.refine'_1.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ f ≫
      (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)).ι.app
        { as := WalkingPair.right } =
    BinaryCofan.inl c ≫ s.ι.app WalkingSpan.right

tactic: rw [← Category.assoc]
state_before: case mp.intro.refine'_1.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ BinaryCofan.inr c ≫
      fE ≫ IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    BinaryCofan.inr c ≫ s.ι.app WalkingSpan.right

tactic: exact h.fac _ ⟨WalkingPair.left⟩
state_before: case mp.intro.refine'_1.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ (BinaryCofan.inr c ≫ fE) ≫
      IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    BinaryCofan.inr c ≫ s.ι.app WalkingSpan.right

tactic: intro m e₁ e₂
state_before: case mp.intro.refine'_2
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
⊢ ∀ {m : YE ⟶ s.pt},
    PushoutCocone.inl
            { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
          m =
        PushoutCocone.inl s →
      fE ≫ m = s.ι.app WalkingSpan.right →
        m = IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s))

tactic: apply BinaryCofan.IsColimit.hom_ext h
state_before: case mp.intro.refine'_2
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ m = IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s))

tactic: dsimp only [BinaryCofan.mk, id]
state_before: case mp.intro.refine'_2.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ BinaryCofan.inl (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY) ≫ m =
    BinaryCofan.inl (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY) ≫
      IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s))

tactic: rw [Category.assoc, e₂, eq_comm]
state_before: case mp.intro.refine'_2.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ BinaryCofan.inl
        { pt := YE,
          ι :=
            NatTrans.mk fun x =>
              WalkingPair.rec (motive := fun t =>
                x.as = t →
                  ((pair ((pair X E).obj { as := WalkingPair.right }) Y).obj { as := x.as } ⟶
                    ((Functor.const (Discrete WalkingPair)).obj YE).obj { as := x.as }))
                (fun h => (_ : WalkingPair.left = x.as) ▸ BinaryCofan.inr c ≫ fE)
                (fun h => (_ : WalkingPair.right = x.as) ▸ iY) x.as (_ : x.as = x.as) } ≫
      m =
    BinaryCofan.inl
        { pt := YE,
          ι :=
            NatTrans.mk fun x =>
              WalkingPair.rec (motive := fun t =>
                x.as = t →
                  ((pair ((pair X E).obj { as := WalkingPair.right }) Y).obj { as := x.as } ⟶
                    ((Functor.const (Discrete WalkingPair)).obj YE).obj { as := x.as }))
                (fun h => (_ : WalkingPair.left = x.as) ▸ BinaryCofan.inr c ≫ fE)
                (fun h => (_ : WalkingPair.right = x.as) ▸ iY) x.as (_ : x.as = x.as) } ≫
      IsColimit.desc h
        { pt := s.pt,
          ι :=
            NatTrans.mk fun x =>
              WalkingPair.rec (motive := fun t =>
                x.as = t →
                  ((pair ((pair X E).obj { as := WalkingPair.right }) Y).obj { as := x.as } ⟶
                    ((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := x.as }))
                (fun h => (_ : WalkingPair.left = x.as) ▸ BinaryCofan.inr c ≫ PushoutCocone.inr s)
                (fun h => (_ : WalkingPair.right = x.as) ▸ PushoutCocone.inl s) x.as (_ : x.as = x.as) }

tactic: exact h.fac _ ⟨WalkingPair.left⟩
state_before: case mp.intro.refine'_2.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ BinaryCofan.inl
        { pt := YE,
          ι :=
            NatTrans.mk fun x =>
              WalkingPair.rec (motive := fun t =>
                x.as = t →
                  ((pair ((pair X E).obj { as := WalkingPair.right }) Y).obj { as := x.as } ⟶
                    ((Functor.const (Discrete WalkingPair)).obj YE).obj { as := x.as }))
                (fun h => (_ : WalkingPair.left = x.as) ▸ BinaryCofan.inr c ≫ fE)
                (fun h => (_ : WalkingPair.right = x.as) ▸ iY) x.as (_ : x.as = x.as) } ≫
      IsColimit.desc h
        { pt := s.pt,
          ι :=
            NatTrans.mk fun x =>
              WalkingPair.rec (motive := fun t =>
                x.as = t →
                  ((pair ((pair X E).obj { as := WalkingPair.right }) Y).obj { as := x.as } ⟶
                    ((Functor.const (Discrete WalkingPair)).obj s.pt).obj { as := x.as }))
                (fun h => (_ : WalkingPair.left = x.as) ▸ BinaryCofan.inr c ≫ PushoutCocone.inr s)
                (fun h => (_ : WalkingPair.right = x.as) ▸ PushoutCocone.inl s) x.as (_ : x.as = x.as) } =
    BinaryCofan.inr c ≫ s.ι.app WalkingSpan.right

tactic: refine' e₁.trans (Eq.symm _)
state_before: case mp.intro.refine'_2.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY) ≫ m =
    BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY) ≫
      IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s))

tactic: exact h.fac _ _
state_before: case mp.intro.refine'_2.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h✝ : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
h : IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)
s : PushoutCocone f (BinaryCofan.inl c)
m : YE ⟶ s.pt
e₁ :
  PushoutCocone.inl
        { pt := YE, ι := NatTrans.mk fun j => Option.rec (f ≫ iY) (fun val => WalkingPair.rec iY fE val) j } ≫
      m =
    PushoutCocone.inl s
e₂ : fE ≫ m = s.ι.app WalkingSpan.right
⊢ BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY) ≫
      IsColimit.desc h (BinaryCofan.mk (BinaryCofan.inr c ≫ PushoutCocone.inr s) (PushoutCocone.inl s)) =
    PushoutCocone.inl s

tactic: refine' fun H => ⟨_⟩
state_before: case mpr
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H : CommSq f (BinaryCofan.inl c) iY fE
⊢ IsPushout f (BinaryCofan.inl c) iY fE → Nonempty (IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY))

tactic: fapply Limits.BinaryCofan.isColimitMk
state_before: case mpr
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
⊢ IsColimit (BinaryCofan.mk (BinaryCofan.inr c ≫ fE) iY)

tactic: exact fun s => H.isColimit.desc (PushoutCocone.mk s.inr _ <|
  (hc.fac (BinaryCofan.mk (f ≫ s.inr) s.inl) ⟨WalkingPair.left⟩).symm)
state_before: case mpr.desc
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
⊢ (s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y) → YE ⟶ s.pt

tactic: intro s
state_before: case mpr.fac_left
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
⊢ ∀ (s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y),
    (BinaryCofan.inr c ≫ fE) ≫
        IsColimit.desc (IsPushout.isColimit H)
          (PushoutCocone.mk (BinaryCofan.inr s)
            (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
            (_ :
              (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                c.ι.app { as := WalkingPair.left } ≫
                  IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))) =
      BinaryCofan.inl s

tactic: erw [Category.assoc, H.isColimit.fac _ WalkingSpan.right, hc.fac]
state_before: case mpr.fac_left
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
⊢ (BinaryCofan.inr c ≫ fE) ≫
      IsColimit.desc (IsPushout.isColimit H)
        (PushoutCocone.mk (BinaryCofan.inr s)
          (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
          (_ :
            (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
              c.ι.app { as := WalkingPair.left } ≫
                IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))) =
    BinaryCofan.inl s

tactic: rfl
state_before: case mpr.fac_left
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
⊢ (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.right } = BinaryCofan.inl s

tactic: intro s
state_before: case mpr.fac_right
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
⊢ ∀ (s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y),
    iY ≫
        IsColimit.desc (IsPushout.isColimit H)
          (PushoutCocone.mk (BinaryCofan.inr s)
            (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
            (_ :
              (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                c.ι.app { as := WalkingPair.left } ≫
                  IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))) =
      BinaryCofan.inr s

tactic: exact H.isColimit.fac _ WalkingSpan.left
state_before: case mpr.fac_right
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
⊢ iY ≫
      IsColimit.desc (IsPushout.isColimit H)
        (PushoutCocone.mk (BinaryCofan.inr s)
          (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
          (_ :
            (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
              c.ι.app { as := WalkingPair.left } ≫
                IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))) =
    BinaryCofan.inr s

tactic: intro s m e₁ e₂
state_before: case mpr.uniq
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
⊢ ∀ (s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y) (m : YE ⟶ s.pt),
    (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s →
      iY ≫ m = BinaryCofan.inr s →
        m =
          IsColimit.desc (IsPushout.isColimit H)
            (PushoutCocone.mk (BinaryCofan.inr s)
              (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
              (_ :
                (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                  c.ι.app { as := WalkingPair.left } ≫
                    IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s))))

tactic: apply PushoutCocone.IsColimit.hom_ext H.isColimit
state_before: case mpr.uniq
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ m =
    IsColimit.desc (IsPushout.isColimit H)
      (PushoutCocone.mk (BinaryCofan.inr s)
        (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
        (_ :
          (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
            c.ι.app { as := WalkingPair.left } ≫
              IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s))))

tactic: symm
state_before: case mpr.uniq.h₀
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ PushoutCocone.inl (IsPushout.cocone H) ≫ m =
    PushoutCocone.inl (IsPushout.cocone H) ≫
      IsColimit.desc (IsPushout.isColimit H)
        (PushoutCocone.mk (BinaryCofan.inr s)
          (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
          (_ :
            (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
              c.ι.app { as := WalkingPair.left } ≫
                IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s))))

tactic: exact (H.isColimit.fac _ WalkingSpan.left).trans e₂.symm
state_before: case mpr.uniq.h₀
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ PushoutCocone.inl (IsPushout.cocone H) ≫
      IsColimit.desc (IsPushout.isColimit H)
        (PushoutCocone.mk (BinaryCofan.inr s)
          (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
          (_ :
            (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
              c.ι.app { as := WalkingPair.left } ≫
                IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))) =
    PushoutCocone.inl (IsPushout.cocone H) ≫ m

tactic: erw [H.isColimit.fac _ WalkingSpan.right]
state_before: case mpr.uniq.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ PushoutCocone.inr (IsPushout.cocone H) ≫ m =
    PushoutCocone.inr (IsPushout.cocone H) ≫
      IsColimit.desc (IsPushout.isColimit H)
        (PushoutCocone.mk (BinaryCofan.inr s)
          (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
          (_ :
            (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
              c.ι.app { as := WalkingPair.left } ≫
                IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s))))

tactic: apply BinaryCofan.IsColimit.hom_ext hc
state_before: case mpr.uniq.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ PushoutCocone.inr (IsPushout.cocone H) ≫ m =
    (PushoutCocone.mk (BinaryCofan.inr s)
            (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
            (_ :
              (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                c.ι.app { as := WalkingPair.left } ≫
                  IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))).ι.app
      WalkingSpan.right

tactic: erw [hc.fac, ← H.w_assoc, e₂]
state_before: case mpr.uniq.h₁.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ BinaryCofan.inl c ≫ PushoutCocone.inr (IsPushout.cocone H) ≫ m =
    BinaryCofan.inl c ≫
      (PushoutCocone.mk (BinaryCofan.inr s)
              (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
              (_ :
                (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                  c.ι.app { as := WalkingPair.left } ≫
                    IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))).ι.app
        WalkingSpan.right

tactic: rfl
state_before: case mpr.uniq.h₁.h₁
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ f ≫ BinaryCofan.inr s = (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left }

tactic: refine' ((Category.assoc _ _ _).symm.trans e₁).trans _
state_before: case mpr.uniq.h₁.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ BinaryCofan.inr c ≫ PushoutCocone.inr (IsPushout.cocone H) ≫ m =
    BinaryCofan.inr c ≫
      (PushoutCocone.mk (BinaryCofan.inr s)
              (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
              (_ :
                (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                  c.ι.app { as := WalkingPair.left } ≫
                    IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))).ι.app
        WalkingSpan.right

tactic: symm
state_before: case mpr.uniq.h₁.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ BinaryCofan.inl s =
    BinaryCofan.inr c ≫
      (PushoutCocone.mk (BinaryCofan.inr s)
              (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
              (_ :
                (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                  c.ι.app { as := WalkingPair.left } ≫
                    IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))).ι.app
        WalkingSpan.right

tactic: exact hc.fac _ _
state_before: case mpr.uniq.h₁.h₂
J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X✝ Y✝ Z : C
f✝ : W ⟶ X✝
g : W ⟶ Y✝
h : X✝ ⟶ Z
i : Y✝ ⟶ Z
X E Y YE : C
c : BinaryCofan X E
hc : IsColimit c
f : X ⟶ Y
iY : Y ⟶ YE
fE : c.pt ⟶ YE
H✝ : CommSq f (BinaryCofan.inl c) iY fE
H : IsPushout f (BinaryCofan.inl c) iY fE
s : BinaryCofan ((pair X E).obj { as := WalkingPair.right }) Y
m : YE ⟶ s.pt
e₁ : (BinaryCofan.inr c ≫ fE) ≫ m = BinaryCofan.inl s
e₂ : iY ≫ m = BinaryCofan.inr s
⊢ BinaryCofan.inr c ≫
      (PushoutCocone.mk (BinaryCofan.inr s)
              (IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))
              (_ :
                (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)).ι.app { as := WalkingPair.left } =
                  c.ι.app { as := WalkingPair.left } ≫
                    IsColimit.desc hc (BinaryCofan.mk (f ≫ BinaryCofan.inr s) (BinaryCofan.inl s)))).ι.app
        WalkingSpan.right =
    BinaryCofan.inl s