[GOAL]
X Y : WalkingCospan
⊢ Subsingleton (X ⟶ Y)
[PROOFSTEP]
constructor
[GOAL]
case allEq
X Y : WalkingCospan
⊢ ∀ (a b : X ⟶ Y), a = b
[PROOFSTEP]
intros
[GOAL]
case allEq
X Y : WalkingCospan
a✝ b✝ : X ⟶ Y
⊢ a✝ = b✝
[PROOFSTEP]
simp
[GOAL]
X Y : WalkingSpan
⊢ Subsingleton (X ⟶ Y)
[PROOFSTEP]
constructor
[GOAL]
case allEq
X Y : WalkingSpan
⊢ ∀ (a b : X ⟶ Y), a = b
[PROOFSTEP]
intros a b
[GOAL]
case allEq
X Y : WalkingSpan
a b : X ⟶ Y
⊢ a = b
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
⊢ s ≅ t
[PROOFSTEP]
apply Cones.ext i _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
⊢ ∀ (j : WalkingCospan), NatTrans.app s.π j = i.hom ≫ NatTrans.app t.π j
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
have h₁ := s.π.naturality WalkingCospan.Hom.inl
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : ((Functor.const WalkingCospan).obj s.pt).map inl ≫ NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
dsimp at h₁
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : 𝟙 s.pt ≫ NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
simp only [Category.id_comp] at h₁
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
have h₂ := t.π.naturality WalkingCospan.Hom.inl
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
h₂ : ((Functor.const WalkingCospan).obj t.pt).map inl ≫ NatTrans.app t.π one = NatTrans.app t.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
dsimp at h₂
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
h₂ : 𝟙 t.pt ≫ NatTrans.app t.π one = NatTrans.app t.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
simp only [Category.id_comp] at h₂
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
h₁ : NatTrans.app s.π one = NatTrans.app s.π left ≫ F.map inl
h₂ : NatTrans.app t.π one = NatTrans.app t.π left ≫ F.map inl
⊢ NatTrans.app s.π none = i.hom ≫ NatTrans.app t.π none
[PROOFSTEP]
simp_rw [h₂, ← Category.assoc, ← w₁, ← h₁]
[GOAL]
case some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
⊢ NatTrans.app s.π (some WalkingPair.left) = i.hom ≫ NatTrans.app t.π (some WalkingPair.left)
[PROOFSTEP]
exact w₁
[GOAL]
case some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
s t : Cone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.π left = i.hom ≫ NatTrans.app t.π left
w₂ : NatTrans.app s.π right = i.hom ≫ NatTrans.app t.π right
⊢ NatTrans.app s.π (some WalkingPair.right) = i.hom ≫ NatTrans.app t.π (some WalkingPair.right)
[PROOFSTEP]
exact w₂
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
⊢ s ≅ t
[PROOFSTEP]
apply Cocones.ext i _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
⊢ ∀ (j : WalkingSpan), NatTrans.app s.ι j ≫ i.hom = NatTrans.app t.ι j
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
have h₁ := s.ι.naturality WalkingSpan.Hom.fst
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero ≫ ((Functor.const WalkingSpan).obj s.pt).map fst
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
dsimp at h₁
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero ≫ 𝟙 s.pt
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
simp only [Category.comp_id] at h₁
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
have h₂ := t.ι.naturality WalkingSpan.Hom.fst
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero
h₂ : F.map fst ≫ NatTrans.app t.ι left = NatTrans.app t.ι zero ≫ ((Functor.const WalkingSpan).obj t.pt).map fst
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
dsimp at h₂
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero
h₂ : F.map fst ≫ NatTrans.app t.ι left = NatTrans.app t.ι zero ≫ 𝟙 t.pt
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
simp only [Category.comp_id] at h₂
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
h₁ : F.map fst ≫ NatTrans.app s.ι left = NatTrans.app s.ι zero
h₂ : F.map fst ≫ NatTrans.app t.ι left = NatTrans.app t.ι zero
⊢ NatTrans.app s.ι none ≫ i.hom = NatTrans.app t.ι none
[PROOFSTEP]
simp_rw [← h₁, Category.assoc, w₁, h₂]
[GOAL]
case some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
⊢ NatTrans.app s.ι (some WalkingPair.left) ≫ i.hom = NatTrans.app t.ι (some WalkingPair.left)
[PROOFSTEP]
exact w₁
[GOAL]
case some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
s t : Cocone F
i : s.pt ≅ t.pt
w₁ : NatTrans.app s.ι WalkingCospan.left ≫ i.hom = NatTrans.app t.ι WalkingCospan.left
w₂ : NatTrans.app s.ι WalkingCospan.right ≫ i.hom = NatTrans.app t.ι WalkingCospan.right
⊢ NatTrans.app s.ι (some WalkingPair.right) ≫ i.hom = NatTrans.app t.ι (some WalkingPair.right)
[PROOFSTEP]
exact w₂
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
j : WalkingCospan
⊢ F.obj j = (cospan (F.map inl) (F.map inr)).obj j
[PROOFSTEP]
rcases j with (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.obj none = (cospan (F.map inl) (F.map inr)).obj none
[PROOFSTEP]
rfl
[GOAL]
case some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.obj (some WalkingPair.left) = (cospan (F.map inl) (F.map inr)).obj (some WalkingPair.left)
[PROOFSTEP]
rfl
[GOAL]
case some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.obj (some WalkingPair.right) = (cospan (F.map inl) (F.map inr)).obj (some WalkingPair.right)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ ∀ {X Y : WalkingCospan} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) Y).hom =
      ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) X).hom ≫
        (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : none ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : none ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : none ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.left ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.right ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom ≫
      (cospan (F.map inl) (F.map inr)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (WidePullbackShape.Hom.id none) ≫
      ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom ≫
      (cospan (F.map inl) (F.map inr)).map (WidePullbackShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.none.term
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (term WalkingPair.left) ≫ ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom ≫
      (cospan (F.map inl) (F.map inr)).map (term WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (WidePullbackShape.Hom.id (some WalkingPair.left)) ≫
      ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.left)).hom ≫
      (cospan (F.map inl) (F.map inr)).map (WidePullbackShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.none.term
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (term WalkingPair.right) ≫
      ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom ≫
      (cospan (F.map inl) (F.map inr)).map (term WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (WidePullbackShape.Hom.id (some WalkingPair.right)) ≫
      ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (cospan (F.map inl) (F.map inr)).obj j)) (some WalkingPair.right)).hom ≫
      (cospan (F.map inl) (F.map inr)).map (WidePullbackShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (𝟙 none) ≫ 𝟙 (F.obj none) = 𝟙 (F.obj none) ≫ (cospan (F.map inl) (F.map inr)).map (𝟙 none)
[PROOFSTEP]
simp
[GOAL]
case some.left.none.term
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (term WalkingPair.left) ≫ 𝟙 (F.obj none) = 𝟙 (F.obj (some WalkingPair.left)) ≫ F.map inl
[PROOFSTEP]
simp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (𝟙 (some WalkingPair.left)) ≫ 𝟙 (F.obj (some WalkingPair.left)) =
    𝟙 (F.obj (some WalkingPair.left)) ≫ (cospan (F.map inl) (F.map inr)).map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp
[GOAL]
case some.right.none.term
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (term WalkingPair.right) ≫ 𝟙 (F.obj none) = 𝟙 (F.obj (some WalkingPair.right)) ≫ F.map inr
[PROOFSTEP]
simp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingCospan ⥤ C
⊢ F.map (𝟙 (some WalkingPair.right)) ≫ 𝟙 (F.obj (some WalkingPair.right)) =
    𝟙 (F.obj (some WalkingPair.right)) ≫ (cospan (F.map inl) (F.map inr)).map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
j : WalkingSpan
⊢ F.obj j = (span (F.map fst) (F.map snd)).obj j
[PROOFSTEP]
rcases j with (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.obj none = (span (F.map fst) (F.map snd)).obj none
[PROOFSTEP]
rfl
[GOAL]
case some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.obj (some WalkingPair.left) = (span (F.map fst) (F.map snd)).obj (some WalkingPair.left)
[PROOFSTEP]
rfl
[GOAL]
case some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.obj (some WalkingPair.right) = (span (F.map fst) (F.map snd)).obj (some WalkingPair.right)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ ∀ {X Y : WalkingSpan} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) Y).hom =
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) X).hom ≫
        (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : none ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : none ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : none ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.left ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.right ⟶ none
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom ≫
      (span (F.map fst) (F.map snd)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (WidePushoutShape.Hom.id none) ≫
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map (WidePushoutShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.left.init
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (init WalkingPair.left) ≫
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map (init WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.right.init
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (init WalkingPair.right) ≫
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) none).hom ≫
      (span (F.map fst) (F.map snd)).map (init WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.left)).hom ≫
      (span (F.map fst) (F.map snd)).map (WidePushoutShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom =
    ((fun j => eqToIso (_ : F.obj j = (span (F.map fst) (F.map snd)).obj j)) (some WalkingPair.right)).hom ≫
      (span (F.map fst) (F.map snd)).map (WidePushoutShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (𝟙 none) ≫ 𝟙 (F.obj none) = 𝟙 (F.obj none) ≫ (span (F.map fst) (F.map snd)).map (𝟙 none)
[PROOFSTEP]
simp
[GOAL]
case none.some.left.init
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (init WalkingPair.left) ≫ 𝟙 (F.obj (some WalkingPair.left)) = 𝟙 (F.obj none) ≫ F.map fst
[PROOFSTEP]
simp
[GOAL]
case none.some.right.init
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (init WalkingPair.right) ≫ 𝟙 (F.obj (some WalkingPair.right)) = 𝟙 (F.obj none) ≫ F.map snd
[PROOFSTEP]
simp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (𝟙 (some WalkingPair.left)) ≫ 𝟙 (F.obj (some WalkingPair.left)) =
    𝟙 (F.obj (some WalkingPair.left)) ≫ (span (F.map fst) (F.map snd)).map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ F.map (𝟙 (some WalkingPair.right)) ≫ 𝟙 (F.obj (some WalkingPair.right)) =
    𝟙 (F.obj (some WalkingPair.right)) ≫ (span (F.map fst) (F.map snd)).map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (X_1 : WalkingCospan) → (cospan f g ⋙ F).obj X_1 ≅ (cospan (F.map f) (F.map g)).obj X_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).obj none ≅ (cospan (F.map f) (F.map g)).obj none
[PROOFSTEP]
exact Iso.refl _
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).obj (some WalkingPair.left) ≅ (cospan (F.map f) (F.map g)).obj (some WalkingPair.left)
[PROOFSTEP]
exact Iso.refl _
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).obj (some WalkingPair.right) ≅ (cospan (F.map f) (F.map g)).obj (some WalkingPair.right)
[PROOFSTEP]
exact Iso.refl _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ {X_1 Y_1 : WalkingCospan} (f_1 : X_1 ⟶ Y_1),
    (cospan f g ⋙ F).map f_1 ≫
        (Option.casesOn Y_1 (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
      (Option.casesOn X_1 (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
        (cospan (F.map f) (F.map g)).map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ none
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ some WalkingPair.left
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ some WalkingPair.right
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ none
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ none
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (cospan f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).map (WidePullbackShape.Hom.id none) ≫
      (Option.casesOn none (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f) (F.map g)).map (WidePullbackShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).map (term WalkingPair.left) ≫
      (Option.casesOn none (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f) (F.map g)).map (term WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).map (WidePullbackShape.Hom.id (some WalkingPair.left)) ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f) (F.map g)).map (WidePullbackShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).map (term WalkingPair.right) ≫
      (Option.casesOn none (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f) (F.map g)).map (term WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g ⋙ F).map (WidePullbackShape.Hom.id (some WalkingPair.right)) ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (cospan (F.map f) (F.map g)).map (WidePullbackShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ F.map ((cospan f g).map (𝟙 none)) ≫ 𝟙 (F.obj Z) = 𝟙 (F.obj Z) ≫ (cospan (F.map f) (F.map g)).map (𝟙 none)
[PROOFSTEP]
simp
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ F.map f ≫ 𝟙 (F.obj Z) = 𝟙 (F.obj X) ≫ F.map f
[PROOFSTEP]
simp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ F.map ((cospan f g).map (𝟙 (some WalkingPair.left))) ≫ 𝟙 (F.obj X) =
    𝟙 (F.obj X) ≫ (cospan (F.map f) (F.map g)).map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ F.map g ≫ 𝟙 (F.obj Z) = 𝟙 (F.obj Y) ≫ F.map g
[PROOFSTEP]
simp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ F.map ((cospan f g).map (𝟙 (some WalkingPair.right))) ≫ 𝟙 (F.obj Y) =
    𝟙 (F.obj Y) ≫ (cospan (F.map f) (F.map g)).map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (X_1 : WalkingSpan) → (span f g ⋙ F).obj X_1 ≅ (span (F.map f) (F.map g)).obj X_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).obj none ≅ (span (F.map f) (F.map g)).obj none
[PROOFSTEP]
exact Iso.refl _
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).obj (some WalkingPair.left) ≅ (span (F.map f) (F.map g)).obj (some WalkingPair.left)
[PROOFSTEP]
exact Iso.refl _
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).obj (some WalkingPair.right) ≅ (span (F.map f) (F.map g)).obj (some WalkingPair.right)
[PROOFSTEP]
exact Iso.refl _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ ∀ {X_1 Y_1 : WalkingSpan} (f_1 : X_1 ⟶ Y_1),
    (span f g ⋙ F).map f_1 ≫
        (Option.casesOn Y_1 (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
              (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
      (Option.casesOn X_1 (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
              (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
        (span (F.map f) (F.map g)).map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ none
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ some WalkingPair.left
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ some WalkingPair.right
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.left ⟶ none
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.right ⟶ none
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (span f✝ g ⋙ F).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝ g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝ g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f✝) (F.map g)).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).map (WidePushoutShape.Hom.id none) ≫
      (Option.casesOn none (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f) (F.map g)).map (WidePushoutShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).map (init WalkingPair.left) ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f) (F.map g)).map (init WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).map (init WalkingPair.right) ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f) (F.map g)).map (init WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f) (F.map g)).map (WidePushoutShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (span f g ⋙ F).map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f g ⋙ F).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.left)))
            (Iso.refl ((span f g ⋙ F).obj (some WalkingPair.right)))).hom ≫
      (span (F.map f) (F.map g)).map (WidePushoutShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ F.map ((span f g).map (𝟙 none)) ≫ 𝟙 (F.obj X) = 𝟙 (F.obj X) ≫ (span (F.map f) (F.map g)).map (𝟙 none)
[PROOFSTEP]
simp
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ F.map f ≫ 𝟙 (F.obj Y) = 𝟙 (F.obj X) ≫ F.map f
[PROOFSTEP]
simp
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ F.map g ≫ 𝟙 (F.obj Z) = 𝟙 (F.obj X) ≫ F.map g
[PROOFSTEP]
simp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ F.map ((span f g).map (𝟙 (some WalkingPair.left))) ≫ 𝟙 (F.obj Y) =
    𝟙 (F.obj Y) ≫ (span (F.map f) (F.map g)).map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ F.map ((span f g).map (𝟙 (some WalkingPair.right))) ≫ 𝟙 (F.obj Z) =
    𝟙 (F.obj Z) ≫ (span (F.map f) (F.map g)).map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (X_1 : WalkingCospan) → (cospan f g).obj X_1 ≅ (cospan f' g').obj X_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).obj none ≅ (cospan f' g').obj none
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).obj (some WalkingPair.left) ≅ (cospan f' g').obj (some WalkingPair.left)
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).obj (some WalkingPair.right) ≅ (cospan f' g').obj (some WalkingPair.right)
[PROOFSTEP]
exacts [iZ, iX, iY]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ ∀ {X_1 Y_1 : WalkingCospan} (f_1 : X_1 ⟶ Y_1),
    (cospan f g).map f_1 ≫ (Option.casesOn Y_1 iZ fun val => WalkingPair.casesOn val iX iY).hom =
      (Option.casesOn X_1 iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ none
⊢ (cospan f✝ g).map f ≫ (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ some WalkingPair.left
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ some WalkingPair.right
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ none
⊢ (cospan f✝ g).map f ≫ (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ none
⊢ (cospan f✝ g).map f ≫ (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (cospan f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫ (cospan f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (WidePullbackShape.Hom.id none) ≫
      (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom ≫
      (cospan f' g').map (WidePullbackShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (term WalkingPair.left) ≫ (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫
      (cospan f' g').map (term WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (WidePullbackShape.Hom.id (some WalkingPair.left)) ≫
      (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.left) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫
      (cospan f' g').map (WidePullbackShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (term WalkingPair.right) ≫ (Option.casesOn none iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫
      (cospan f' g').map (term WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (WidePullbackShape.Hom.id (some WalkingPair.right)) ≫
      (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom =
    (Option.casesOn (some WalkingPair.right) iZ fun val => WalkingPair.casesOn val iX iY).hom ≫
      (cospan f' g').map (WidePullbackShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (𝟙 none) ≫ iZ.hom = iZ.hom ≫ (cospan f' g').map (𝟙 none)
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ f ≫ iZ.hom = iX.hom ≫ f'
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (𝟙 (some WalkingPair.left)) ≫ iX.hom = iX.hom ≫ (cospan f' g').map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ g ≫ iZ.hom = iY.hom ≫ g'
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospan f g).map (𝟙 (some WalkingPair.right)) ≫ iY.hom = iY.hom ≫ (cospan f' g').map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp [wf, wg]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).app WalkingCospan.left = iX
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).app WalkingCospan.right = iY
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).app WalkingCospan.one = iZ
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).hom WalkingCospan.left = iX.hom
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).hom WalkingCospan.right = iY.hom
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).hom WalkingCospan.one = iZ.hom
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).inv WalkingCospan.left = iX.inv
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).inv WalkingCospan.right = iY.inv
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (cospanExt iX iY iZ wf wg).inv WalkingCospan.one = iZ.inv
[PROOFSTEP]
dsimp [cospanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (X_1 : WalkingSpan) → (span f g).obj X_1 ≅ (span f' g').obj X_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).obj none ≅ (span f' g').obj none
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).obj (some WalkingPair.left) ≅ (span f' g').obj (some WalkingPair.left)
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).obj (some WalkingPair.right) ≅ (span f' g').obj (some WalkingPair.right)
[PROOFSTEP]
exacts [iX, iY, iZ]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ ∀ {X_1 Y_1 : WalkingSpan} (f_1 : X_1 ⟶ Y_1),
    (span f g).map f_1 ≫ (Option.casesOn Y_1 iX fun val => WalkingPair.casesOn val iY iZ).hom =
      (Option.casesOn X_1 iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ none
⊢ (span f✝ g).map f ≫ (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : none ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ none
⊢ (span f✝ g).map f ≫ (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ none
⊢ (span f✝ g).map f ≫ (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f✝ : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f✝ ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫ (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (WidePushoutShape.Hom.id none) ≫
      (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫
      (span f' g').map (WidePushoutShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (init WalkingPair.left) ≫
      (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map (init WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (init WalkingPair.right) ≫
      (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn none iX fun val => WalkingPair.casesOn val iY iZ).hom ≫ (span f' g').map (init WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.left) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫
      (span f' g').map (WidePushoutShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom =
    (Option.casesOn (some WalkingPair.right) iX fun val => WalkingPair.casesOn val iY iZ).hom ≫
      (span f' g').map (WidePushoutShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (𝟙 none) ≫ iX.hom = iX.hom ≫ (span f' g').map (𝟙 none)
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ f ≫ iY.hom = iX.hom ≫ f'
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ g ≫ iZ.hom = iX.hom ≫ g'
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (𝟙 (some WalkingPair.left)) ≫ iY.hom = iY.hom ≫ (span f' g').map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp [wf, wg]
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (span f g).map (𝟙 (some WalkingPair.right)) ≫ iZ.hom = iZ.hom ≫ (span f' g').map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp [wf, wg]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.left = iY
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.right = iZ
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.zero = iX
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).hom WalkingSpan.left = iY.hom
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).hom WalkingSpan.right = iZ.hom
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).hom WalkingSpan.zero = iX.hom
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).inv WalkingSpan.left = iY.inv
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).inv WalkingSpan.right = iZ.inv
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ NatTrans.app (spanExt iX iY iZ wf wg).inv WalkingSpan.zero = iX.inv
[PROOFSTEP]
dsimp [spanExt]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
⊢ NatTrans.app t.π WalkingCospan.one = fst t ≫ f
[PROOFSTEP]
have w := t.π.naturality WalkingCospan.Hom.inl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w :
  ((Functor.const WalkingCospan).obj t.pt).map inl ≫ NatTrans.app t.π WalkingCospan.one =
    NatTrans.app t.π WalkingCospan.left ≫ (cospan f g).map inl
⊢ NatTrans.app t.π WalkingCospan.one = fst t ≫ f
[PROOFSTEP]
dsimp at w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
w : 𝟙 t.pt ≫ NatTrans.app t.π WalkingCospan.one = fst t ≫ f
⊢ NatTrans.app t.π WalkingCospan.one = fst t ≫ f
[PROOFSTEP]
simpa using w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
lift : (s : PullbackCone f g) → s.pt ⟶ t.pt
fac_left : ∀ (s : PullbackCone f g), lift s ≫ fst t = fst s
fac_right : ∀ (s : PullbackCone f g), lift s ≫ snd t = snd s
uniq :
  ∀ (s : PullbackCone f g) (m : s.pt ⟶ t.pt),
    (∀ (j : WalkingCospan), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift s
s : Cone (cospan f g)
j : WalkingCospan
⊢ lift s ≫ NatTrans.app t.π none = NatTrans.app s.π none
[PROOFSTEP]
rw [← s.w inl, ← t.w inl, ← Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
lift : (s : PullbackCone f g) → s.pt ⟶ t.pt
fac_left : ∀ (s : PullbackCone f g), lift s ≫ fst t = fst s
fac_right : ∀ (s : PullbackCone f g), lift s ≫ snd t = snd s
uniq :
  ∀ (s : PullbackCone f g) (m : s.pt ⟶ t.pt),
    (∀ (j : WalkingCospan), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift s
s : Cone (cospan f g)
j : WalkingCospan
⊢ (lift s ≫ NatTrans.app t.π WalkingCospan.left) ≫ (cospan f g).map inl =
    NatTrans.app s.π WalkingCospan.left ≫ (cospan f g).map inl
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
lift : (s : PullbackCone f g) → s.pt ⟶ t.pt
fac_left : ∀ (s : PullbackCone f g), lift s ≫ fst t = fst s
fac_right : ∀ (s : PullbackCone f g), lift s ≫ snd t = snd s
uniq :
  ∀ (s : PullbackCone f g) (m : s.pt ⟶ t.pt),
    (∀ (j : WalkingCospan), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift s
s : Cone (cospan f g)
j : WalkingCospan
⊢ lift s ≫ NatTrans.app t.π WalkingCospan.left = NatTrans.app s.π WalkingCospan.left
[PROOFSTEP]
exact fac_left s
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ∀ ⦃X_1 Y_1 : WalkingCospan⦄ (f_1 : X_1 ⟶ Y_1),
    ((Functor.const WalkingCospan).obj W).map f_1 ≫
        (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) Y_1 =
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) X_1 ≫ (cospan f g).map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) j
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : none ⟶ none
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none ≫ (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : none ⟶ some WalkingPair.left
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none ≫ (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : none ⟶ some WalkingPair.right
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none ≫ (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.left ⟶ none
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.left ⟶ some WalkingPair.left
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.left ⟶ some WalkingPair.right
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.right ⟶ none
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.right ⟶ some WalkingPair.left
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
j : some WalkingPair.right ⟶ some WalkingPair.right
⊢ ((Functor.const WalkingCospan).obj W).map j ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) ≫
      (cospan f g).map j
[PROOFSTEP]
cases j
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ((Functor.const WalkingCospan).obj W).map (WidePullbackShape.Hom.id none) ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none ≫
      (cospan f g).map (WidePullbackShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ((Functor.const WalkingCospan).obj W).map (term WalkingPair.left) ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) ≫
      (cospan f g).map (term WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ((Functor.const WalkingCospan).obj W).map (WidePullbackShape.Hom.id (some WalkingPair.left)) ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.left) ≫
      (cospan f g).map (WidePullbackShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ((Functor.const WalkingCospan).obj W).map (term WalkingPair.right) ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) none =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) ≫
      (cospan f g).map (term WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ((Functor.const WalkingCospan).obj W).map (WidePullbackShape.Hom.id (some WalkingPair.right)) ≫
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) =
    (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) (some WalkingPair.right) ≫
      (cospan f g).map (WidePullbackShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ 𝟙 W ≫ fst ≫ f = (fst ≫ f) ≫ (cospan f g).map (𝟙 none)
[PROOFSTEP]
simp [eq]
[GOAL]
case some.left.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ 𝟙 W ≫ fst ≫ f = fst ≫ f
[PROOFSTEP]
simp [eq]
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ 𝟙 W ≫ fst = fst ≫ (cospan f g).map (𝟙 (some WalkingPair.left))
[PROOFSTEP]
simp [eq]
[GOAL]
case some.right.none.term
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ 𝟙 W ≫ fst ≫ f = snd ≫ g
[PROOFSTEP]
simp [eq]
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ 𝟙 W ≫ snd = snd ≫ (cospan f g).map (𝟙 (some WalkingPair.right))
[PROOFSTEP]
simp [eq]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
W : C
k l : W ⟶ t.pt
h₀ : k ≫ fst t = l ≫ fst t
h₁ : k ≫ snd t = l ≫ snd t
⊢ k ≫ NatTrans.app t.π none = l ≫ NatTrans.app t.π none
[PROOFSTEP]
rw [← t.w inl]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
W : C
k l : W ⟶ t.pt
h₀ : k ≫ fst t = l ≫ fst t
h₁ : k ≫ snd t = l ≫ snd t
⊢ k ≫ NatTrans.app t.π WalkingCospan.left ≫ (cospan f g).map inl =
    l ≫ NatTrans.app t.π WalkingCospan.left ≫ (cospan f g).map inl
[PROOFSTEP]
dsimp [h₀]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
W : C
k l : W ⟶ t.pt
h₀ : k ≫ fst t = l ≫ fst t
h₁ : k ≫ snd t = l ≫ snd t
⊢ k ≫ fst t ≫ f = l ≫ fst t ≫ f
[PROOFSTEP]
simp only [← Category.assoc, congrArg (· ≫ f) h₀]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
⊢ Mono (snd t)
[PROOFSTEP]
refine ⟨fun {W} h k i => IsLimit.hom_ext ht ?_ i⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
⊢ h ≫ fst t = k ≫ fst t
[PROOFSTEP]
rw [← cancel_mono f, Category.assoc, Category.assoc, condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
⊢ h ≫ snd t ≫ g = k ≫ snd t ≫ g
[PROOFSTEP]
have := congrArg (· ≫ g) i
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
this : (fun x => x ≫ g) (h ≫ snd t) = (fun x => x ≫ g) (k ≫ snd t)
⊢ h ≫ snd t ≫ g = k ≫ snd t ≫ g
[PROOFSTEP]
dsimp at this
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
this : (h ≫ snd t) ≫ g = (k ≫ snd t) ≫ g
⊢ h ≫ snd t ≫ g = k ≫ snd t ≫ g
[PROOFSTEP]
rwa [Category.assoc, Category.assoc] at this
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
⊢ Mono (fst t)
[PROOFSTEP]
refine ⟨fun {W} h k i => IsLimit.hom_ext ht i ?_⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
⊢ h ≫ snd t = k ≫ snd t
[PROOFSTEP]
rw [← cancel_mono g, Category.assoc, Category.assoc, ← condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
⊢ h ≫ fst t ≫ f = k ≫ fst t ≫ f
[PROOFSTEP]
have := congrArg (· ≫ f) i
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
this : (fun x => x ≫ f) (h ≫ fst t) = (fun x => x ≫ f) (k ≫ fst t)
⊢ h ≫ fst t ≫ f = k ≫ fst t ≫ f
[PROOFSTEP]
dsimp at this
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
this : (h ≫ fst t) ≫ f = (k ≫ fst t) ≫ f
⊢ h ≫ fst t ≫ f = k ≫ fst t ≫ f
[PROOFSTEP]
rwa [Category.assoc, Category.assoc] at this
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ lift ht h k w ≫ fst t = h ∧ lift ht h k w ≫ snd t = k
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
t : IsLimit (mk k h (_ : k ≫ g = h ≫ f))
s : PullbackCone f g
⊢ { l //
    l ≫ fst (mk h k comm) = fst s ∧
      l ≫ snd (mk h k comm) = snd s ∧
        ∀ {m : s.pt ⟶ (mk h k comm).pt}, m ≫ fst (mk h k comm) = fst s → m ≫ snd (mk h k comm) = snd s → m = l }
[PROOFSTEP]
refine'
  ⟨(IsLimit.lift' t _ _ s.condition.symm).1, (IsLimit.lift' t _ _ _).2.2, (IsLimit.lift' t _ _ _).2.1, fun m₁ m₂ =>
    t.hom_ext _⟩
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
t : IsLimit (mk k h (_ : k ≫ g = h ≫ f))
s : PullbackCone f g
m✝ : s.pt ⟶ (mk h k comm).pt
m₁ : m✝ ≫ fst (mk h k comm) = fst s
m₂ : m✝ ≫ snd (mk h k comm) = snd s
⊢ ∀ (j : WalkingCospan),
    m✝ ≫ NatTrans.app (mk k h (_ : k ≫ g = h ≫ f)).π j =
      ↑(IsLimit.lift' t (snd s) (fst s) (_ : snd s ≫ g = fst s ≫ f)) ≫ NatTrans.app (mk k h (_ : k ≫ g = h ≫ f)).π j
[PROOFSTEP]
apply (mk k h _).equalizer_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
t : IsLimit (mk k h (_ : k ≫ g = h ≫ f))
s : PullbackCone f g
m✝ : s.pt ⟶ (mk h k comm).pt
m₁ : m✝ ≫ fst (mk h k comm) = fst s
m₂ : m✝ ≫ snd (mk h k comm) = snd s
⊢ m✝ ≫ fst (mk k h (_ : k ≫ g = h ≫ f)) =
    ↑(IsLimit.lift' t (snd s) (fst s) (_ : snd s ≫ g = fst s ≫ f)) ≫ fst (mk k h (_ : k ≫ g = h ≫ f))
[PROOFSTEP]
rwa [(IsLimit.lift' t _ _ _).2.1]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
t : IsLimit (mk k h (_ : k ≫ g = h ≫ f))
s : PullbackCone f g
m✝ : s.pt ⟶ (mk h k comm).pt
m₁ : m✝ ≫ fst (mk h k comm) = fst s
m₂ : m✝ ≫ snd (mk h k comm) = snd s
⊢ m✝ ≫ snd (mk k h (_ : k ≫ g = h ≫ f)) =
    ↑(IsLimit.lift' t (snd s) (fst s) (_ : snd s ≫ g = fst s ≫ f)) ≫ snd (mk k h (_ : k ≫ g = h ≫ f))
[PROOFSTEP]
rwa [(IsLimit.lift' t _ _ _).2.2]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : X ⟶ Y
inst✝ : Mono f
s : PullbackCone f f
⊢ (fun s => fst s) s ≫ 𝟙 X = snd s
[PROOFSTEP]
rw [← cancel_mono f, Category.comp_id, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : X ⟶ Y
inst✝ : Mono f
s : PullbackCone f f
m : s.pt ⟶ X
m₁ : m ≫ 𝟙 X = fst s
x✝ : m ≫ 𝟙 X = snd s
⊢ m = (fun s => fst s) s
[PROOFSTEP]
simpa using m₁
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g✝ : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
Z : C
g h : Z ⟶ X
eq : g ≫ f = h ≫ f
⊢ g = h
[PROOFSTEP]
rcases PullbackCone.IsLimit.lift' t _ _ eq with ⟨_, rfl, rfl⟩
[GOAL]
case mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
Z : C
val✝ : Z ⟶ (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)).pt
eq :
  (val✝ ≫ fst (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))) ≫ f = (val✝ ≫ snd (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))) ≫ f
⊢ val✝ ≫ fst (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)) = val✝ ≫ snd (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
⊢ (fst s ≫ x) ≫ h = (snd s ≫ y) ≫ h
[PROOFSTEP]
simp only [Category.assoc, hxh, hyh, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
⊢ fst t ≫ x ≫ h = snd t ≫ y ≫ h
[PROOFSTEP]
rw [← Category.assoc, ← Category.assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
⊢ (fst t ≫ x) ≫ h = (snd t ≫ y) ≫ h
[PROOFSTEP]
apply congrArg (· ≫ h) t.condition
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
⊢ fst t ≫ f = snd t ≫ g
[PROOFSTEP]
rw [← hxh, ← hyh, this]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = fst t
hr' : m✝ ≫ snd (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = snd t
⊢ m✝ = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g))
[PROOFSTEP]
apply PullbackCone.IsLimit.hom_ext hs
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = fst t
hr' : m✝ ≫ snd (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = snd t
⊢ m✝ ≫ fst s = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ fst s
[PROOFSTEP]
simp only [PullbackCone.mk_fst, PullbackCone.mk_snd] at hr hr' ⊢
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = fst t
hr' : m✝ ≫ snd (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)) = snd t
⊢ m✝ ≫ snd s = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ snd s
[PROOFSTEP]
simp only [PullbackCone.mk_fst, PullbackCone.mk_snd] at hr hr' ⊢
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ m✝ ≫ fst s = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ fst s
[PROOFSTEP]
simp only [hr, hr']
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ m✝ ≫ snd s = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ snd s
[PROOFSTEP]
simp only [hr, hr']
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ fst t = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ fst s
[PROOFSTEP]
symm
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ snd t = Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ snd s
[PROOFSTEP]
symm
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ fst s = fst t
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ Z
inst✝ : Mono h
x : X ⟶ W
y : Y ⟶ W
hxh : x ≫ h = f
hyh : y ≫ h = g
s : PullbackCone f g
hs : IsLimit s
t : PullbackCone x y
this : fst t ≫ x ≫ h = snd t ≫ y ≫ h
m✝ : t.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ x = snd s ≫ y)).pt
hr : m✝ ≫ fst s = fst t
hr' : m✝ ≫ snd s = snd t
⊢ Limits.IsLimit.lift hs (mk (fst t) (snd t) (_ : fst t ≫ f = snd t ≫ g)) ≫ snd s = snd t
[PROOFSTEP]
exacts [hs.fac _ WalkingCospan.left, hs.fac _ WalkingCospan.right]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s : PullbackCone f g
H : IsLimit s
⊢ fst s ≫ f ≫ i = snd s ≫ g ≫ i
[PROOFSTEP]
rw [← Category.assoc, ← Category.assoc, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s : PullbackCone f g
H : IsLimit s
⊢ IsLimit (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i))
[PROOFSTEP]
apply PullbackCone.isLimitAux'
[GOAL]
case create
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s : PullbackCone f g
H : IsLimit s
⊢ (s_1 : PullbackCone (f ≫ i) (g ≫ i)) →
    { l //
      l ≫ fst (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i)) = fst s_1 ∧
        l ≫ snd (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i)) = snd s_1 ∧
          ∀ {m : s_1.pt ⟶ (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i)).pt},
            m ≫ fst (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i)) = fst s_1 →
              m ≫ snd (mk (fst s) (snd s) (_ : fst s ≫ f ≫ i = snd s ≫ g ≫ i)) = snd s_1 → m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s✝ : PullbackCone f g
H : IsLimit s✝
s : PullbackCone (f ≫ i) (g ≫ i)
⊢ { l //
    l ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s ∧
      l ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s ∧
        ∀ {m : s.pt ⟶ (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)).pt},
          m ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s →
            m ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s → m = l }
[PROOFSTEP]
rcases PullbackCone.IsLimit.lift' H s.fst s.snd ((cancel_mono i).mp (by simpa using s.condition)) with ⟨l, h₁, h₂⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s✝ : PullbackCone f g
H : IsLimit s✝
s : PullbackCone (f ≫ i) (g ≫ i)
⊢ (fst s ≫ f) ≫ i = (snd s ≫ g) ≫ i
[PROOFSTEP]
simpa using s.condition
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s✝ : PullbackCone f g
H : IsLimit s✝
s : PullbackCone (f ≫ i) (g ≫ i)
l : s.pt ⟶ s✝.pt
h₁ : l ≫ fst s✝ = fst s
h₂ : l ≫ snd s✝ = snd s
⊢ { l //
    l ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s ∧
      l ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s ∧
        ∀ {m : s.pt ⟶ (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)).pt},
          m ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s →
            m ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s → m = l }
[PROOFSTEP]
refine' ⟨l, h₁, h₂, _⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s✝ : PullbackCone f g
H : IsLimit s✝
s : PullbackCone (f ≫ i) (g ≫ i)
l : s.pt ⟶ s✝.pt
h₁ : l ≫ fst s✝ = fst s
h₂ : l ≫ snd s✝ = snd s
⊢ ∀ {m : s.pt ⟶ (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)).pt},
    m ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s →
      m ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s → m = l
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝ : Mono i
s✝ : PullbackCone f g
H : IsLimit s✝
s : PullbackCone (f ≫ i) (g ≫ i)
l : s.pt ⟶ s✝.pt
h₁ : l ≫ fst s✝ = fst s
h₂ : l ≫ snd s✝ = snd s
m : s.pt ⟶ (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)).pt
hm₁ : m ≫ fst (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = fst s
hm₂ : m ≫ snd (mk (fst s✝) (snd s✝) (_ : fst s✝ ≫ f ≫ i = snd s✝ ≫ g ≫ i)) = snd s
⊢ m = l
[PROOFSTEP]
exact (PullbackCone.IsLimit.hom_ext H (hm₁.trans h₁.symm) (hm₂.trans h₂.symm) : _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
⊢ NatTrans.app t.ι WalkingSpan.zero = f ≫ inl t
[PROOFSTEP]
have w := t.ι.naturality WalkingSpan.Hom.fst
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
w :
  (span f g).map fst ≫ NatTrans.app t.ι WalkingSpan.left =
    NatTrans.app t.ι WalkingSpan.zero ≫ ((Functor.const WalkingSpan).obj t.pt).map fst
⊢ NatTrans.app t.ι WalkingSpan.zero = f ≫ inl t
[PROOFSTEP]
dsimp at w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
w : f ≫ inl t = NatTrans.app t.ι WalkingSpan.zero ≫ 𝟙 t.pt
⊢ NatTrans.app t.ι WalkingSpan.zero = f ≫ inl t
[PROOFSTEP]
simpa using w.symm
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
desc : (s : PushoutCocone f g) → t.pt ⟶ s.pt
fac_left : ∀ (s : PushoutCocone f g), inl t ≫ desc s = inl s
fac_right : ∀ (s : PushoutCocone f g), inr t ≫ desc s = inr s
uniq :
  ∀ (s : PushoutCocone f g) (m : t.pt ⟶ s.pt),
    (∀ (j : WalkingSpan), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc s
s : Cocone (span f g)
j : WalkingSpan
⊢ NatTrans.app t.ι none ≫ desc s = NatTrans.app s.ι none
[PROOFSTEP]
simp [← s.w fst, ← t.w fst, fac_left s]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ ⦃X_1 Y_1 : WalkingSpan⦄ (f_1 : X_1 ⟶ Y_1),
    (span f g).map f_1 ≫ (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) Y_1 =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) X_1 ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩)
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : none ⟶ none),
    (span f g).map f_1 ≫ (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : none ⟶ some WalkingPair.left),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : none ⟶ some WalkingPair.right),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.left ⟶ none),
    (span f g).map f_1 ≫ (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.left ⟶ some WalkingPair.left),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.left ⟶ some WalkingPair.right),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.right ⟶ none),
    (span f g).map f_1 ≫ (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.right ⟶ some WalkingPair.left),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ ∀ (f_1 : some WalkingPair.right ⟶ some WalkingPair.right),
    (span f g).map f_1 ≫
        (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
        ((Functor.const WalkingSpan).obj W).map f_1
[PROOFSTEP]
intro f
[GOAL]
case none.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : none ⟶ none
⊢ (span f✝ g).map f ≫ (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : none ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : none ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.left ⟶ none
⊢ (span f✝ g).map f ≫ (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.left.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.right ⟶ none
⊢ (span f✝ g).map f ≫ (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case some.right.some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f✝ ≫ inl = g ≫ inr
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (span f✝ g).map f ≫
      (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
    (fun j => Option.casesOn j (f✝ ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
      ((Functor.const WalkingSpan).obj W).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (WidePushoutShape.Hom.id none) ≫
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none =
    (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map (WidePushoutShape.Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (init WalkingPair.left) ≫
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
    (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map (init WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (init WalkingPair.right) ≫
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
    (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) none ≫
      ((Functor.const WalkingSpan).obj W).map (init WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) =
    (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.left) ≫
      ((Functor.const WalkingSpan).obj W).map (WidePushoutShape.Hom.id (some WalkingPair.left))
[PROOFSTEP]
dsimp
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) =
    (fun j => Option.casesOn j (f ≫ inl) fun j' => WalkingPair.casesOn j' inl inr) (some WalkingPair.right) ≫
      ((Functor.const WalkingSpan).obj W).map (WidePushoutShape.Hom.id (some WalkingPair.right))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (𝟙 none) ≫ f ≫ inl = (f ≫ inl) ≫ 𝟙 W
[PROOFSTEP]
aesop
[GOAL]
case none.some.left.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ f ≫ inl = (f ≫ inl) ≫ 𝟙 W
[PROOFSTEP]
aesop
[GOAL]
case none.some.right.init
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ g ≫ inr = (f ≫ inl) ≫ 𝟙 W
[PROOFSTEP]
aesop
[GOAL]
case some.left.some.left.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (𝟙 (some WalkingPair.left)) ≫ inl = inl ≫ 𝟙 W
[PROOFSTEP]
aesop
[GOAL]
case some.right.some.right.id
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
inl : Y ⟶ W
inr : Z ⟶ W
eq : f ≫ inl = g ≫ inr
⊢ (span f g).map (𝟙 (some WalkingPair.right)) ≫ inr = inr ≫ 𝟙 W
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
W : C
k l : t.pt ⟶ W
h₀ : inl t ≫ k = inl t ≫ l
h₁ : inr t ≫ k = inr t ≫ l
⊢ NatTrans.app t.ι none ≫ k = NatTrans.app t.ι none ≫ l
[PROOFSTEP]
rw [← t.w fst, Category.assoc, Category.assoc, h₀]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
ht : IsColimit t
W : C
h : Y ⟶ W
k : Z ⟶ W
w : f ≫ h = g ≫ k
⊢ inl t ≫ desc ht h k w = h ∧ inr t ≫ desc ht h k w = k
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
ht : IsColimit t
inst✝ : Epi f
W : C
h k : t.pt ⟶ W
i : inr t ≫ h = inr t ≫ k
⊢ inl t ≫ h = inl t ≫ k
[PROOFSTEP]
simp [← cancel_epi f, t.condition_assoc, i]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
ht : IsColimit t
inst✝ : Epi g
W : C
h k : t.pt ⟶ W
i : inl t ≫ h = inl t ≫ k
⊢ inr t ≫ h = inr t ≫ k
[PROOFSTEP]
simp [← cancel_epi g, ← t.condition_assoc, i]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
h : Y ⟶ W
k : Z ⟶ W
comm : f ≫ h = g ≫ k
t : IsColimit (mk k h (_ : g ≫ k = f ≫ h))
s : PushoutCocone f g
⊢ { l //
    inl (mk h k comm) ≫ l = inl s ∧
      inr (mk h k comm) ≫ l = inr s ∧
        ∀ {m : (mk h k comm).pt ⟶ s.pt}, inl (mk h k comm) ≫ m = inl s → inr (mk h k comm) ≫ m = inr s → m = l }
[PROOFSTEP]
refine'
  ⟨(IsColimit.desc' t _ _ s.condition.symm).1, (IsColimit.desc' t _ _ _).2.2, (IsColimit.desc' t _ _ _).2.1,
    fun m₁ m₂ => t.hom_ext _⟩
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
h : Y ⟶ W
k : Z ⟶ W
comm : f ≫ h = g ≫ k
t : IsColimit (mk k h (_ : g ≫ k = f ≫ h))
s : PushoutCocone f g
m✝ : (mk h k comm).pt ⟶ s.pt
m₁ : inl (mk h k comm) ≫ m✝ = inl s
m₂ : inr (mk h k comm) ≫ m✝ = inr s
⊢ ∀ (j : WalkingSpan),
    NatTrans.app (mk k h (_ : g ≫ k = f ≫ h)).ι j ≫ m✝ =
      NatTrans.app (mk k h (_ : g ≫ k = f ≫ h)).ι j ≫ ↑(IsColimit.desc' t (inr s) (inl s) (_ : g ≫ inr s = f ≫ inl s))
[PROOFSTEP]
apply (mk k h _).coequalizer_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
h : Y ⟶ W
k : Z ⟶ W
comm : f ≫ h = g ≫ k
t : IsColimit (mk k h (_ : g ≫ k = f ≫ h))
s : PushoutCocone f g
m✝ : (mk h k comm).pt ⟶ s.pt
m₁ : inl (mk h k comm) ≫ m✝ = inl s
m₂ : inr (mk h k comm) ≫ m✝ = inr s
⊢ inl (mk k h (_ : g ≫ k = f ≫ h)) ≫ m✝ =
    inl (mk k h (_ : g ≫ k = f ≫ h)) ≫ ↑(IsColimit.desc' t (inr s) (inl s) (_ : g ≫ inr s = f ≫ inl s))
[PROOFSTEP]
rwa [(IsColimit.desc' t _ _ _).2.1]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
W : C
h : Y ⟶ W
k : Z ⟶ W
comm : f ≫ h = g ≫ k
t : IsColimit (mk k h (_ : g ≫ k = f ≫ h))
s : PushoutCocone f g
m✝ : (mk h k comm).pt ⟶ s.pt
m₁ : inl (mk h k comm) ≫ m✝ = inl s
m₂ : inr (mk h k comm) ≫ m✝ = inr s
⊢ inr (mk k h (_ : g ≫ k = f ≫ h)) ≫ m✝ =
    inr (mk k h (_ : g ≫ k = f ≫ h)) ≫ ↑(IsColimit.desc' t (inr s) (inl s) (_ : g ≫ inr s = f ≫ inl s))
[PROOFSTEP]
rwa [(IsColimit.desc' t _ _ _).2.2]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : X ⟶ Y
inst✝ : Epi f
s : PushoutCocone f f
⊢ 𝟙 Y ≫ (fun s => inl s) s = inr s
[PROOFSTEP]
rw [← cancel_epi f, Category.id_comp, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : X ⟶ Y
inst✝ : Epi f
s : PushoutCocone f f
m : Y ⟶ s.pt
m₁ : 𝟙 Y ≫ m = inl s
x✝ : 𝟙 Y ≫ m = inr s
⊢ m = (fun s => inl s) s
[PROOFSTEP]
simpa using m₁
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z✝ : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z✝
f : X ⟶ Y
t : IsColimit (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y))
Z : C
g h : Y ⟶ Z
eq : f ≫ g = f ≫ h
⊢ g = h
[PROOFSTEP]
rcases PushoutCocone.IsColimit.desc' t _ _ eq with ⟨_, rfl, rfl⟩
[GOAL]
case mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z✝ : C
f✝ : X ⟶ Y
g : X ⟶ Z✝
f : X ⟶ Y
t : IsColimit (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y))
Z : C
val✝ : (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)).pt ⟶ Z
eq : f ≫ inl (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝ = f ≫ inr (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝
⊢ inl (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝ = inr (mk (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)) ≫ val✝
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
⊢ h ≫ x ≫ inl s = f ≫ inl s
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
⊢ (h ≫ x) ≫ inl s = f ≫ inl s
[PROOFSTEP]
apply congrArg (· ≫ inl s) hhx
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
reassoc₁ : h ≫ x ≫ inl s = f ≫ inl s
⊢ h ≫ y ≫ inr s = g ≫ inr s
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
reassoc₁ : h ≫ x ≫ inl s = f ≫ inl s
⊢ (h ≫ y) ≫ inr s = g ≫ inr s
[PROOFSTEP]
apply congrArg (· ≫ inr s) hhy
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
reassoc₁ : h ≫ x ≫ inl s = f ≫ inl s
reassoc₂ : h ≫ y ≫ inr s = g ≫ inr s
⊢ h ≫ x ≫ inl s = h ≫ y ≫ inr s
[PROOFSTEP]
rw [reassoc₁, reassoc₂, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
⊢ f ≫ inl t = g ≫ inr t
[PROOFSTEP]
rw [← hhx, ← hhy, Category.assoc, Category.assoc, t.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inl t
hr' : inr (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inr t
⊢ m✝ = Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
apply PushoutCocone.IsColimit.hom_ext hs
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inl t
hr' : inr (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inr t
⊢ inl s ≫ m✝ = inl s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
simp only [PushoutCocone.mk_inl, PushoutCocone.mk_inr] at hr hr' ⊢
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inl s ≫ m✝ = inl s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
simp only [hr, hr']
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inl t = inl s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
symm
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inl s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t)) = inl t
[PROOFSTEP]
exact hs.fac _ WalkingSpan.left
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inl t
hr' : inr (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)) ≫ m✝ = inr t
⊢ inr s ≫ m✝ = inr s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
simp only [PushoutCocone.mk_inl, PushoutCocone.mk_inr] at hr hr' ⊢
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inr s ≫ m✝ = inr s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
simp only [hr, hr']
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inr t = inr s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t))
[PROOFSTEP]
symm
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : X ⟶ W
inst✝ : Epi h
x : W ⟶ Y
y : W ⟶ Z
hhx : h ≫ x = f
hhy : h ≫ y = g
s : PushoutCocone f g
hs : IsColimit s
t : PushoutCocone x y
m✝ : (mk (inl s) (inr s) (_ : x ≫ inl s = y ≫ inr s)).pt ⟶ t.pt
hr : inl s ≫ m✝ = inl t
hr' : inr s ≫ m✝ = inr t
⊢ inr s ≫ Limits.IsColimit.desc hs (mk (inl t) (inr t) (_ : f ≫ inl t = g ≫ inr t)) = inr t
[PROOFSTEP]
exact hs.fac _ WalkingSpan.right
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s : PushoutCocone f g
H : IsColimit s
⊢ (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s
[PROOFSTEP]
rw [Category.assoc, Category.assoc, s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s : PushoutCocone f g
H : IsColimit s
⊢ IsColimit (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s))
[PROOFSTEP]
apply PushoutCocone.isColimitAux'
[GOAL]
case create
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s : PushoutCocone f g
H : IsColimit s
⊢ (s_1 : PushoutCocone (h ≫ f) (h ≫ g)) →
    { l //
      inl (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s)) ≫ l = inl s_1 ∧
        inr (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s)) ≫ l = inr s_1 ∧
          ∀ {m : (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s)).pt ⟶ s_1.pt},
            inl (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s)) ≫ m = inl s_1 →
              inr (mk (inl s) (inr s) (_ : (h ≫ f) ≫ inl s = (h ≫ g) ≫ inr s)) ≫ m = inr s_1 → m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s✝ : PushoutCocone f g
H : IsColimit s✝
s : PushoutCocone (h ≫ f) (h ≫ g)
⊢ { l //
    inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ l = inl s ∧
      inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ l = inr s ∧
        ∀ {m : (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)).pt ⟶ s.pt},
          inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inl s →
            inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inr s → m = l }
[PROOFSTEP]
rcases PushoutCocone.IsColimit.desc' H s.inl s.inr ((cancel_epi h).mp (by simpa using s.condition)) with ⟨l, h₁, h₂⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s✝ : PushoutCocone f g
H : IsColimit s✝
s : PushoutCocone (h ≫ f) (h ≫ g)
⊢ h ≫ f ≫ inl s = h ≫ g ≫ inr s
[PROOFSTEP]
simpa using s.condition
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s✝ : PushoutCocone f g
H : IsColimit s✝
s : PushoutCocone (h ≫ f) (h ≫ g)
l : s✝.pt ⟶ s.pt
h₁ : inl s✝ ≫ l = inl s
h₂ : inr s✝ ≫ l = inr s
⊢ { l //
    inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ l = inl s ∧
      inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ l = inr s ∧
        ∀ {m : (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)).pt ⟶ s.pt},
          inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inl s →
            inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inr s → m = l }
[PROOFSTEP]
refine' ⟨l, h₁, h₂, _⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s✝ : PushoutCocone f g
H : IsColimit s✝
s : PushoutCocone (h ≫ f) (h ≫ g)
l : s✝.pt ⟶ s.pt
h₁ : inl s✝ ≫ l = inl s
h₂ : inr s✝ ≫ l = inr s
⊢ ∀ {m : (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)).pt ⟶ s.pt},
    inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inl s →
      inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inr s → m = l
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case create.mk.intro
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g✝ : X ⟶ Z
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝ : Epi h
s✝ : PushoutCocone f g
H : IsColimit s✝
s : PushoutCocone (h ≫ f) (h ≫ g)
l : s✝.pt ⟶ s.pt
h₁ : inl s✝ ≫ l = inl s
h₂ : inr s✝ ≫ l = inr s
m : (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)).pt ⟶ s.pt
hm₁ : inl (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inl s
hm₂ : inr (mk (inl s✝) (inr s✝) (_ : (h ≫ f) ≫ inl s✝ = (h ≫ g) ≫ inr s✝)) ≫ m = inr s
⊢ m = l
[PROOFSTEP]
exact (PushoutCocone.IsColimit.hom_ext H (hm₁.trans h₁.symm) (hm₂.trans h₂.symm) : _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ ∀ (j : WalkingCospan),
    NatTrans.app ((Cones.postcompose (diagramIsoCospan F).hom).obj t).π j =
      (Iso.refl ((Cones.postcompose (diagramIsoCospan F).hom).obj t).pt).hom ≫
        NatTrans.app
          (mk (NatTrans.app t.π WalkingCospan.left) (NatTrans.app t.π WalkingCospan.right)
              (_ :
                NatTrans.app t.π WalkingCospan.left ≫ F.map inl = NatTrans.app t.π WalkingCospan.right ≫ F.map inr)).π
          j
[PROOFSTEP]
rintro (_ | (_ | _))
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app ((Cones.postcompose (diagramIsoCospan F).hom).obj t).π none =
    (Iso.refl ((Cones.postcompose (diagramIsoCospan F).hom).obj t).pt).hom ≫
      NatTrans.app
        (mk (NatTrans.app t.π WalkingCospan.left) (NatTrans.app t.π WalkingCospan.right)
            (_ : NatTrans.app t.π WalkingCospan.left ≫ F.map inl = NatTrans.app t.π WalkingCospan.right ≫ F.map inr)).π
        none
[PROOFSTEP]
dsimp
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app t.π none ≫ 𝟙 (F.obj none) = 𝟙 t.pt ≫ NatTrans.app t.π WalkingCospan.left ≫ F.map inl
[PROOFSTEP]
simp
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app ((Cones.postcompose (diagramIsoCospan F).hom).obj t).π (some WalkingPair.left) =
    (Iso.refl ((Cones.postcompose (diagramIsoCospan F).hom).obj t).pt).hom ≫
      NatTrans.app
        (mk (NatTrans.app t.π WalkingCospan.left) (NatTrans.app t.π WalkingCospan.right)
            (_ : NatTrans.app t.π WalkingCospan.left ≫ F.map inl = NatTrans.app t.π WalkingCospan.right ≫ F.map inr)).π
        (some WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app t.π (some WalkingPair.left) ≫ 𝟙 (F.obj (some WalkingPair.left)) =
    𝟙 t.pt ≫ NatTrans.app t.π WalkingCospan.left
[PROOFSTEP]
simp
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app ((Cones.postcompose (diagramIsoCospan F).hom).obj t).π (some WalkingPair.right) =
    (Iso.refl ((Cones.postcompose (diagramIsoCospan F).hom).obj t).pt).hom ≫
      NatTrans.app
        (mk (NatTrans.app t.π WalkingCospan.left) (NatTrans.app t.π WalkingCospan.right)
            (_ : NatTrans.app t.π WalkingCospan.left ≫ F.map inl = NatTrans.app t.π WalkingCospan.right ≫ F.map inr)).π
        (some WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingCospan ⥤ C
t : Cone F
⊢ NatTrans.app t.π (some WalkingPair.right) ≫ 𝟙 (F.obj (some WalkingPair.right)) =
    𝟙 t.pt ≫ NatTrans.app t.π WalkingCospan.right
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ ∀ (j : WalkingSpan),
    NatTrans.app ((Cocones.precompose (diagramIsoSpan F).inv).obj t).ι j ≫
        (Iso.refl ((Cocones.precompose (diagramIsoSpan F).inv).obj t).pt).hom =
      NatTrans.app
        (mk (NatTrans.app t.ι WalkingSpan.left) (NatTrans.app t.ι WalkingSpan.right)
            (_ : F.map fst ≫ NatTrans.app t.ι WalkingSpan.left = F.map snd ≫ NatTrans.app t.ι WalkingSpan.right)).ι
        j
[PROOFSTEP]
rintro (_ | (_ | _))
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ NatTrans.app ((Cocones.precompose (diagramIsoSpan F).inv).obj t).ι none ≫
      (Iso.refl ((Cocones.precompose (diagramIsoSpan F).inv).obj t).pt).hom =
    NatTrans.app
      (mk (NatTrans.app t.ι WalkingSpan.left) (NatTrans.app t.ι WalkingSpan.right)
          (_ : F.map fst ≫ NatTrans.app t.ι WalkingSpan.left = F.map snd ≫ NatTrans.app t.ι WalkingSpan.right)).ι
      none
[PROOFSTEP]
dsimp
[GOAL]
case none
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ (𝟙 (F.obj WalkingSpan.zero) ≫ NatTrans.app t.ι none) ≫ 𝟙 t.pt = F.map fst ≫ NatTrans.app t.ι WalkingSpan.left
[PROOFSTEP]
simp
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ NatTrans.app ((Cocones.precompose (diagramIsoSpan F).inv).obj t).ι (some WalkingPair.left) ≫
      (Iso.refl ((Cocones.precompose (diagramIsoSpan F).inv).obj t).pt).hom =
    NatTrans.app
      (mk (NatTrans.app t.ι WalkingSpan.left) (NatTrans.app t.ι WalkingSpan.right)
          (_ : F.map fst ≫ NatTrans.app t.ι WalkingSpan.left = F.map snd ≫ NatTrans.app t.ι WalkingSpan.right)).ι
      (some WalkingPair.left)
[PROOFSTEP]
dsimp
[GOAL]
case some.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ (𝟙 (F.obj WalkingSpan.left) ≫ NatTrans.app t.ι (some WalkingPair.left)) ≫ 𝟙 t.pt = NatTrans.app t.ι WalkingSpan.left
[PROOFSTEP]
simp
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ NatTrans.app ((Cocones.precompose (diagramIsoSpan F).inv).obj t).ι (some WalkingPair.right) ≫
      (Iso.refl ((Cocones.precompose (diagramIsoSpan F).inv).obj t).pt).hom =
    NatTrans.app
      (mk (NatTrans.app t.ι WalkingSpan.left) (NatTrans.app t.ι WalkingSpan.right)
          (_ : F.map fst ≫ NatTrans.app t.ι WalkingSpan.left = F.map snd ≫ NatTrans.app t.ι WalkingSpan.right)).ι
      (some WalkingPair.right)
[PROOFSTEP]
dsimp
[GOAL]
case some.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
F : WalkingSpan ⥤ C
t : Cocone F
⊢ (𝟙 (F.obj WalkingSpan.right) ≫ NatTrans.app t.ι (some WalkingPair.right)) ≫ 𝟙 t.pt =
    NatTrans.app t.ι WalkingSpan.right
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝¹ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ (fst ≫ i₁) ≫ g₁ = (snd ≫ i₂) ≫ g₂
[PROOFSTEP]
simp [← eq₁, ← eq₂, pullback.condition_assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝¹ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
⊢ f₁ ≫ i₁ ≫ inl = f₂ ≫ i₂ ≫ inr
[PROOFSTEP]
simp only [← Category.assoc, eq₁, eq₂]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝¹ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
⊢ (i₃ ≫ g₁) ≫ inl = (i₃ ≫ g₂) ≫ inr
[PROOFSTEP]
simp [pushout.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ ∀ (s : PullbackCone f g),
    (fun s =>
            pullback.lift (PullbackCone.fst s) (PullbackCone.snd s)
              (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g))
          s ≫
        pullback.fst =
      PullbackCone.fst s
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ ∀ (s : PullbackCone f g),
    (fun s =>
            pullback.lift (PullbackCone.fst s) (PullbackCone.snd s)
              (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g))
          s ≫
        pullback.snd =
      PullbackCone.snd s
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ ∀ (s : PullbackCone f g) (m : s.pt ⟶ pullback f g),
    m ≫ pullback.fst = PullbackCone.fst s →
      m ≫ pullback.snd = PullbackCone.snd s →
        m =
          (fun s =>
              pullback.lift (PullbackCone.fst s) (PullbackCone.snd s)
                (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g))
            s
[PROOFSTEP]
aesop_cat
[GOAL]
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.224485, u_1} C
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasBinaryProduct X Y
W : C
i₁ i₂ : W ⟶ pullback f g
h : i₁ ≫ prod.lift pullback.fst pullback.snd = i₂ ≫ prod.lift pullback.fst pullback.snd
⊢ i₁ = i₂
[PROOFSTEP]
ext
[GOAL]
case h₀
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.224485, u_1} C
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasBinaryProduct X Y
W : C
i₁ i₂ : W ⟶ pullback f g
h : i₁ ≫ prod.lift pullback.fst pullback.snd = i₂ ≫ prod.lift pullback.fst pullback.snd
⊢ i₁ ≫ pullback.fst = i₂ ≫ pullback.fst
[PROOFSTEP]
simpa using congrArg (fun f => f ≫ prod.fst) h
[GOAL]
case h₁
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.224485, u_1} C
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasBinaryProduct X Y
W : C
i₁ i₂ : W ⟶ pullback f g
h : i₁ ≫ prod.lift pullback.fst pullback.snd = i₂ ≫ prod.lift pullback.fst pullback.snd
⊢ i₁ ≫ pullback.snd = i₂ ≫ pullback.snd
[PROOFSTEP]
simpa using congrArg (fun f => f ≫ prod.snd) h
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ ∀ (s : PushoutCocone f g),
    pushout.inl ≫
        (fun s =>
            pushout.desc (PushoutCocone.inl s) (PushoutCocone.inr s)
              (_ : f ≫ PushoutCocone.inl s = g ≫ PushoutCocone.inr s))
          s =
      PushoutCocone.inl s
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ ∀ (s : PushoutCocone f g),
    pushout.inr ≫
        (fun s =>
            pushout.desc (PushoutCocone.inl s) (PushoutCocone.inr s)
              (_ : f ≫ PushoutCocone.inl s = g ≫ PushoutCocone.inr s))
          s =
      PushoutCocone.inr s
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ ∀ (s : PushoutCocone f g) (m : pushout f g ⟶ s.pt),
    pushout.inl ≫ m = PushoutCocone.inl s →
      pushout.inr ≫ m = PushoutCocone.inr s →
        m =
          (fun s =>
              pushout.desc (PushoutCocone.inl s) (PushoutCocone.inr s)
                (_ : f ≫ PushoutCocone.inl s = g ≫ PushoutCocone.inr s))
            s
[PROOFSTEP]
aesop_cat
[GOAL]
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.241525, u_1} C
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasBinaryCoproduct Y Z
W : C
i₁ i₂ : pushout f g ⟶ W
h : coprod.desc pushout.inl pushout.inr ≫ i₁ = coprod.desc pushout.inl pushout.inr ≫ i₂
⊢ i₁ = i₂
[PROOFSTEP]
ext
[GOAL]
case h₀
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.241525, u_1} C
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasBinaryCoproduct Y Z
W : C
i₁ i₂ : pushout f g ⟶ W
h : coprod.desc pushout.inl pushout.inr ≫ i₁ = coprod.desc pushout.inl pushout.inr ≫ i₂
⊢ pushout.inl ≫ i₁ = pushout.inl ≫ i₂
[PROOFSTEP]
simpa using congrArg (fun f => coprod.inl ≫ f) h
[GOAL]
case h₁
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ : C✝
C : Type u_1
inst✝² : Category.{?u.241525, u_1} C
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasBinaryCoproduct Y Z
W : C
i₁ i₂ : pushout f g ⟶ W
h : coprod.desc pushout.inl pushout.inr ≫ i₁ = coprod.desc pushout.inl pushout.inr ≫ i₂
⊢ pushout.inr ≫ i₁ = pushout.inr ≫ i₂
[PROOFSTEP]
simpa using congrArg (fun f => coprod.inr ≫ f) h
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝⁴ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝³ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ IsIso (map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
[PROOFSTEP]
refine' ⟨⟨pullback.map _ _ _ _ (inv i₁) (inv i₂) (inv i₃) _ _, _, _⟩⟩
[GOAL]
case refine'_1
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝⁴ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝³ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ g₁ ≫ inv i₃ = inv i₁ ≫ f₁
[PROOFSTEP]
rw [IsIso.comp_inv_eq, Category.assoc, eq₁, IsIso.inv_hom_id_assoc]
[GOAL]
case refine'_2
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝⁴ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝³ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ g₂ ≫ inv i₃ = inv i₂ ≫ f₂
[PROOFSTEP]
rw [IsIso.comp_inv_eq, Category.assoc, eq₂, IsIso.inv_hom_id_assoc]
[GOAL]
case refine'_3
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝⁴ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝³ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂ ≫
      map g₁ g₂ f₁ f₂ (inv i₁) (inv i₂) (inv i₃) (_ : g₁ ≫ inv i₃ = inv i₁ ≫ f₁) (_ : g₂ ≫ inv i₃ = inv i₂ ≫ f₂) =
    𝟙 (pullback f₁ f₂)
[PROOFSTEP]
aesop_cat
[GOAL]
case refine'_4
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : W ⟶ S
f₂ : X ⟶ S
inst✝⁴ : HasPullback f₁ f₂
g₁ : Y ⟶ T
g₂ : Z ⟶ T
inst✝³ : HasPullback g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ map g₁ g₂ f₁ f₂ (inv i₁) (inv i₂) (inv i₃) (_ : g₁ ≫ inv i₃ = inv i₁ ≫ f₁) (_ : g₂ ≫ inv i₃ = inv i₂ ≫ f₂) ≫
      map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂ =
    𝟙 (pullback g₁ g₂)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ f₁ ≫ 𝟙 Z = 𝟙 X ≫ f₂
[PROOFSTEP]
simp [h₁]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ g₁ ≫ 𝟙 Z = 𝟙 Y ≫ g₂
[PROOFSTEP]
simp [h₂]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ f₂ ≫ 𝟙 Z = 𝟙 X ≫ f₁
[PROOFSTEP]
simp [h₁]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ g₂ ≫ 𝟙 Z = 𝟙 Y ≫ g₁
[PROOFSTEP]
simp [h₂]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ (congrHom h₁ h₂).inv = map f₂ g₂ f₁ g₁ (𝟙 X) (𝟙 Y) (𝟙 Z) (_ : f₂ ≫ 𝟙 Z = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 Y ≫ g₁)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ (congrHom h₁ h₂).inv ≫ fst =
    map f₂ g₂ f₁ g₁ (𝟙 X) (𝟙 Y) (𝟙 Z) (_ : f₂ ≫ 𝟙 Z = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 Y ≫ g₁) ≫ fst
[PROOFSTEP]
erw [pullback.lift_fst]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ (congrHom h₁ h₂).inv ≫ fst = fst ≫ 𝟙 X
[PROOFSTEP]
rw [Iso.inv_comp_eq]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ fst = (congrHom h₁ h₂).hom ≫ fst ≫ 𝟙 X
[PROOFSTEP]
erw [pullback.lift_fst_assoc]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ fst = (fst ≫ 𝟙 X) ≫ 𝟙 X
[PROOFSTEP]
rw [Category.comp_id, Category.comp_id]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ (congrHom h₁ h₂).inv ≫ snd =
    map f₂ g₂ f₁ g₁ (𝟙 X) (𝟙 Y) (𝟙 Z) (_ : f₂ ≫ 𝟙 Z = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 Y ≫ g₁) ≫ snd
[PROOFSTEP]
erw [pullback.lift_snd]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ (congrHom h₁ h₂).inv ≫ snd = snd ≫ 𝟙 Y
[PROOFSTEP]
rw [Iso.inv_comp_eq]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ snd = (congrHom h₁ h₂).hom ≫ snd ≫ 𝟙 Y
[PROOFSTEP]
erw [pullback.lift_snd_assoc]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Z
g₁ g₂ : Y ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPullback f₁ g₁
inst✝ : HasPullback f₂ g₂
⊢ snd = (snd ≫ 𝟙 Y) ≫ 𝟙 Y
[PROOFSTEP]
rw [Category.comp_id, Category.comp_id]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝⁴ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝³ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ IsIso (map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
[PROOFSTEP]
refine' ⟨⟨pushout.map _ _ _ _ (inv i₁) (inv i₂) (inv i₃) _ _, _, _⟩⟩
[GOAL]
case refine'_1
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝⁴ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝³ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ g₁ ≫ inv i₁ = inv i₃ ≫ f₁
[PROOFSTEP]
rw [IsIso.comp_inv_eq, Category.assoc, eq₁, IsIso.inv_hom_id_assoc]
[GOAL]
case refine'_2
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝⁴ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝³ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ g₂ ≫ inv i₂ = inv i₃ ≫ f₂
[PROOFSTEP]
rw [IsIso.comp_inv_eq, Category.assoc, eq₂, IsIso.inv_hom_id_assoc]
[GOAL]
case refine'_3
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝⁴ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝³ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂ ≫
      map g₁ g₂ f₁ f₂ (inv i₁) (inv i₂) (inv i₃) (_ : g₁ ≫ inv i₁ = inv i₃ ≫ f₁) (_ : g₂ ≫ inv i₂ = inv i₃ ≫ f₂) =
    𝟙 (pushout f₁ f₂)
[PROOFSTEP]
aesop_cat
[GOAL]
case refine'_4
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
W✝ X✝ Y✝ Z✝ W X Y Z S T : C
f₁ : S ⟶ W
f₂ : S ⟶ X
inst✝⁴ : HasPushout f₁ f₂
g₁ : T ⟶ Y
g₂ : T ⟶ Z
inst✝³ : HasPushout g₁ g₂
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁
eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂
inst✝² : IsIso i₁
inst✝¹ : IsIso i₂
inst✝ : IsIso i₃
⊢ map g₁ g₂ f₁ f₂ (inv i₁) (inv i₂) (inv i₃) (_ : g₁ ≫ inv i₁ = inv i₃ ≫ f₁) (_ : g₂ ≫ inv i₂ = inv i₃ ≫ f₂) ≫
      map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂ =
    𝟙 (pushout g₁ g₂)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X✝ Y✝ Z X Y S T S' : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
i' : S ⟶ S'
inst✝³ : HasPullback f g
inst✝² : HasPullback (f ≫ i) (g ≫ i)
inst✝¹ : HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')
inst✝ : HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')
⊢ mapDesc f g (i ≫ i') =
    mapDesc f g i ≫
      mapDesc (f ≫ i) (g ≫ i) i' ≫ (congrHom (_ : (f ≫ i) ≫ i' = f ≫ i ≫ i') (_ : (g ≫ i) ≫ i' = g ≫ i ≫ i')).hom
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ f₁ ≫ 𝟙 Y = 𝟙 X ≫ f₂
[PROOFSTEP]
simp [h₁]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ g₁ ≫ 𝟙 Z = 𝟙 X ≫ g₂
[PROOFSTEP]
simp [h₂]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ f₂ ≫ 𝟙 Y = 𝟙 X ≫ f₁
[PROOFSTEP]
simp [h₁]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ g₂ ≫ 𝟙 Z = 𝟙 X ≫ g₁
[PROOFSTEP]
simp [h₂]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ (congrHom h₁ h₂).inv = map f₂ g₂ f₁ g₁ (𝟙 Y) (𝟙 Z) (𝟙 X) (_ : f₂ ≫ 𝟙 Y = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 X ≫ g₁)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inl ≫ (congrHom h₁ h₂).inv =
    inl ≫ map f₂ g₂ f₁ g₁ (𝟙 Y) (𝟙 Z) (𝟙 X) (_ : f₂ ≫ 𝟙 Y = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 X ≫ g₁)
[PROOFSTEP]
erw [pushout.inl_desc]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inl ≫ (congrHom h₁ h₂).inv = 𝟙 Y ≫ inl
[PROOFSTEP]
rw [Iso.comp_inv_eq, Category.id_comp]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inl = inl ≫ (congrHom h₁ h₂).hom
[PROOFSTEP]
erw [pushout.inl_desc]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inl = 𝟙 Y ≫ inl
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inr ≫ (congrHom h₁ h₂).inv =
    inr ≫ map f₂ g₂ f₁ g₁ (𝟙 Y) (𝟙 Z) (𝟙 X) (_ : f₂ ≫ 𝟙 Y = 𝟙 X ≫ f₁) (_ : g₂ ≫ 𝟙 Z = 𝟙 X ≫ g₁)
[PROOFSTEP]
erw [pushout.inr_desc]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inr ≫ (congrHom h₁ h₂).inv = 𝟙 Z ≫ inr
[PROOFSTEP]
rw [Iso.comp_inv_eq, Category.id_comp]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inr = inr ≫ (congrHom h₁ h₂).hom
[PROOFSTEP]
erw [pushout.inr_desc]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ X Y Z : C
f₁ f₂ : X ⟶ Y
g₁ g₂ : X ⟶ Z
h₁ : f₁ = f₂
h₂ : g₁ = g₂
inst✝¹ : HasPushout f₁ g₁
inst✝ : HasPushout f₂ g₂
⊢ inr = 𝟙 Z ≫ inr
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X✝ Y✝ Z X Y S T S' : C
f : T ⟶ X
g : T ⟶ Y
i : S ⟶ T
i' : S' ⟶ S
inst✝³ : HasPushout f g
inst✝² : HasPushout (i ≫ f) (i ≫ g)
inst✝¹ : HasPushout (i' ≫ i ≫ f) (i' ≫ i ≫ g)
inst✝ : HasPushout ((i' ≫ i) ≫ f) ((i' ≫ i) ≫ g)
⊢ mapLift f g (i' ≫ i) =
    (congrHom (_ : (i' ≫ i) ≫ f = i' ≫ i ≫ f) (_ : (i' ≫ i) ≫ g = i' ≫ i ≫ g)).hom ≫
      mapLift (i ≫ f) (i ≫ g) i' ≫ mapLift f g i
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
⊢ G.map pullback.fst ≫ G.map f = G.map pullback.snd ≫ G.map g
[PROOFSTEP]
simp only [← G.map_comp, pullback.condition]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map h ≫ G.map f = G.map k ≫ G.map g
[PROOFSTEP]
simp only [← G.map_comp, w]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ G.map (pullback.lift h k w) ≫ pullbackComparison G f g =
    pullback.lift (G.map h) (G.map k) (_ : G.map h ≫ G.map f = G.map k ≫ G.map g)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ (G.map (pullback.lift h k w) ≫ pullbackComparison G f g) ≫ pullback.fst =
    pullback.lift (G.map h) (G.map k) (_ : G.map h ≫ G.map f = G.map k ≫ G.map g) ≫ pullback.fst
[PROOFSTEP]
simp [← G.map_comp]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
W : C
h : W ⟶ X
k : W ⟶ Y
w : h ≫ f = k ≫ g
⊢ (G.map (pullback.lift h k w) ≫ pullbackComparison G f g) ≫ pullback.snd =
    pullback.lift (G.map h) (G.map k) (_ : G.map h ≫ G.map f = G.map k ≫ G.map g) ≫ pullback.snd
[PROOFSTEP]
simp [← G.map_comp]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
G : C ⥤ D
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ G.map f ≫ G.map pushout.inl = G.map g ≫ G.map pushout.inr
[PROOFSTEP]
simp only [← G.map_comp, pushout.condition]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
W : C
h : Y ⟶ W
k : Z ⟶ W
w : f ≫ h = g ≫ k
⊢ G.map f ≫ G.map h = G.map g ≫ G.map k
[PROOFSTEP]
simp only [← G.map_comp, w]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
W : C
h : Y ⟶ W
k : Z ⟶ W
w : f ≫ h = g ≫ k
⊢ pushoutComparison G f g ≫ G.map (pushout.desc h k w) =
    pushout.desc (G.map h) (G.map k) (_ : G.map f ≫ G.map h = G.map g ≫ G.map k)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
W : C
h : Y ⟶ W
k : Z ⟶ W
w : f ≫ h = g ≫ k
⊢ pushout.inl ≫ pushoutComparison G f g ≫ G.map (pushout.desc h k w) =
    pushout.inl ≫ pushout.desc (G.map h) (G.map k) (_ : G.map f ≫ G.map h = G.map g ≫ G.map k)
[PROOFSTEP]
simp [← G.map_comp]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W✝ X Y Z : C
G : C ⥤ D
f : X ⟶ Y
g : X ⟶ Z
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
W : C
h : Y ⟶ W
k : Z ⟶ W
w : f ≫ h = g ≫ k
⊢ pushout.inr ≫ pushoutComparison G f g ≫ G.map (pushout.desc h k w) =
    pushout.inr ≫ pushout.desc (G.map h) (G.map k) (_ : G.map f ≫ G.map h = G.map g ≫ G.map k)
[PROOFSTEP]
simp [← G.map_comp]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).hom ≫ pullback.fst = pullback.snd
[PROOFSTEP]
simp [pullbackSymmetry]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).hom ≫ pullback.snd = pullback.fst
[PROOFSTEP]
simp [pullbackSymmetry]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).inv ≫ pullback.fst = pullback.snd
[PROOFSTEP]
simp [Iso.inv_comp_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).inv ≫ pullback.snd = pullback.fst
[PROOFSTEP]
simp [Iso.inv_comp_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ pushout.inl ≫ (pushoutSymmetry f g).inv = pushout.inr
[PROOFSTEP]
simp [Iso.comp_inv_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ pushout.inr ≫ (pushoutSymmetry f g).inv = pushout.inl
[PROOFSTEP]
simp [Iso.comp_inv_eq]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ pullback.fst ≫ f ≫ i = pullback.snd ≫ g ≫ i
[PROOFSTEP]
simp only [← Category.assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ (pullback.fst ≫ f) ≫ i = (pullback.snd ≫ g) ≫ i
[PROOFSTEP]
rw [cancel_mono]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ pullback.fst ≫ f = pullback.snd ≫ g
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ C
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ X ⟶ ?m.358762
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ Y ⟶ ?m.358762
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ W
g : Y ⟶ W
i : W ⟶ Z
inst✝¹ : Mono i
inst✝ : HasPullback f g
⊢ HasPullback ?m.358763 ?m.358764
[PROOFSTEP]
apply pullback.condition
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ (g ≫ inv f) ≫ f = 𝟙 Y ≫ g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ NatTrans.app (pullbackConeOfLeftIso f g).π none = g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
s : PullbackCone f g
⊢ PullbackCone.snd s ≫ PullbackCone.fst (pullbackConeOfLeftIso f g) = PullbackCone.fst s ∧
    PullbackCone.snd s ≫ PullbackCone.snd (pullbackConeOfLeftIso f g) = PullbackCone.snd s ∧
      ∀ {m : s.pt ⟶ (pullbackConeOfLeftIso f g).pt},
        m ≫ PullbackCone.fst (pullbackConeOfLeftIso f g) = PullbackCone.fst s →
          m ≫ PullbackCone.snd (pullbackConeOfLeftIso f g) = PullbackCone.snd s → m = PullbackCone.snd s
[PROOFSTEP]
simp [← s.condition_assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ IsIso pullback.snd
[PROOFSTEP]
refine' ⟨⟨pullback.lift (g ≫ inv f) (𝟙 _) (by simp), _, by simp⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ (g ≫ inv f) ≫ f = 𝟙 Y ≫ g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ pullback.lift (g ≫ inv f) (𝟙 Y) (_ : (g ≫ inv f) ≫ f = 𝟙 Y ≫ g) ≫ pullback.snd = 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ pullback.snd ≫ pullback.lift (g ≫ inv f) (𝟙 Y) (_ : (g ≫ inv f) ≫ f = 𝟙 Y ≫ g) = 𝟙 (pullback f g)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ (pullback.snd ≫ pullback.lift (g ≫ inv f) (𝟙 Y) (_ : (g ≫ inv f) ≫ f = 𝟙 Y ≫ g)) ≫ pullback.fst =
    𝟙 (pullback f g) ≫ pullback.fst
[PROOFSTEP]
simp [← pullback.condition_assoc]
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ (pullback.snd ≫ pullback.lift (g ≫ inv f) (𝟙 Y) (_ : (g ≫ inv f) ≫ f = 𝟙 Y ≫ g)) ≫ pullback.snd =
    𝟙 (pullback f g) ≫ pullback.snd
[PROOFSTEP]
simp [pullback.condition_assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ HasPullback i (f ≫ i)
[PROOFSTEP]
conv =>
  congr
  rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback i (f ≫ i)
[PROOFSTEP]
  congr
  rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback i (f ≫ i)
[PROOFSTEP]
  congr
  rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback i (f ≫ i)
[PROOFSTEP]
congr
[GOAL]
case f
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| i
case g
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| f ≫ i
[PROOFSTEP]
rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ HasPullback (𝟙 Z ≫ i) (f ≫ i)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ IsIso pullback.snd
[PROOFSTEP]
convert
  (congrArg IsIso
        (show _ ≫ pullback.snd = _ from
          limit.isoLimitCone_hom_π ⟨_, pullbackIsPullbackOfCompMono (𝟙 _) f i⟩ WalkingCospan.right)).mp
    inferInstance
[GOAL]
case h.e'_3.h.e'_6.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ i = 𝟙 Z ≫ i
[PROOFSTEP]
exact (Category.id_comp _).symm
[GOAL]
case h.e'_5.e'_6.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso f✝
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
e_3✝ : pullback i (f ≫ i) = limit (cospan (𝟙 Z ≫ i) (f ≫ i))
e_4✝ : X = (cospan (𝟙 Z ≫ i) (f ≫ i)).obj right
⊢ i = 𝟙 Z ≫ i
[PROOFSTEP]
exact (Category.id_comp _).symm
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ 𝟙 X ≫ f = (f ≫ inv g) ≫ g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ NatTrans.app (pullbackConeOfRightIso f g).π none = f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
s : PullbackCone f g
⊢ PullbackCone.fst s ≫ PullbackCone.fst (pullbackConeOfRightIso f g) = PullbackCone.fst s ∧
    PullbackCone.fst s ≫ PullbackCone.snd (pullbackConeOfRightIso f g) = PullbackCone.snd s ∧
      ∀ {m : s.pt ⟶ (pullbackConeOfRightIso f g).pt},
        m ≫ PullbackCone.fst (pullbackConeOfRightIso f g) = PullbackCone.fst s →
          m ≫ PullbackCone.snd (pullbackConeOfRightIso f g) = PullbackCone.snd s → m = PullbackCone.fst s
[PROOFSTEP]
simp [s.condition_assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ IsIso pullback.fst
[PROOFSTEP]
refine' ⟨⟨pullback.lift (𝟙 _) (f ≫ inv g) (by simp), _, by simp⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ 𝟙 X ≫ f = (f ≫ inv g) ≫ g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ pullback.lift (𝟙 X) (f ≫ inv g) (_ : 𝟙 X ≫ f = (f ≫ inv g) ≫ g) ≫ pullback.fst = 𝟙 X
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ pullback.fst ≫ pullback.lift (𝟙 X) (f ≫ inv g) (_ : 𝟙 X ≫ f = (f ≫ inv g) ≫ g) = 𝟙 (pullback f g)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ (pullback.fst ≫ pullback.lift (𝟙 X) (f ≫ inv g) (_ : 𝟙 X ≫ f = (f ≫ inv g) ≫ g)) ≫ pullback.fst =
    𝟙 (pullback f g) ≫ pullback.fst
[PROOFSTEP]
simp
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso g
⊢ (pullback.fst ≫ pullback.lift (𝟙 X) (f ≫ inv g) (_ : 𝟙 X ≫ f = (f ≫ inv g) ≫ g)) ≫ pullback.snd =
    𝟙 (pullback f g) ≫ pullback.snd
[PROOFSTEP]
simp [pullback.condition_assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ HasPullback (f ≫ i) i
[PROOFSTEP]
conv =>
  congr
  case g => rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback (f ≫ i) i
[PROOFSTEP]
  congr
  case g => rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback (f ≫ i) i
[PROOFSTEP]
  congr
  case g => rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| HasPullback (f ≫ i) i
[PROOFSTEP]
congr
[GOAL]
case f
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| f ≫ i
case g
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| i
[PROOFSTEP]
case g => rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| i
[PROOFSTEP]
rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| i
[PROOFSTEP]
rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
| i
[PROOFSTEP]
rw [← Category.id_comp i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ HasPullback (f ≫ i) (𝟙 Z ≫ i)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ IsIso pullback.fst
[PROOFSTEP]
convert
  (congrArg IsIso
        (show _ ≫ pullback.fst = _ from
          limit.isoLimitCone_hom_π ⟨_, pullbackIsPullbackOfCompMono f (𝟙 _) i⟩ WalkingCospan.left)).mp
    inferInstance
[GOAL]
case h.e'_3.h.e'_7.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
⊢ i = 𝟙 Z ≫ i
[PROOFSTEP]
exact (Category.id_comp _).symm
[GOAL]
case h.e'_5.e'_7.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : IsIso g
i : Z ⟶ W
inst✝ : Mono i
f : X ⟶ Z
e_3✝ : pullback (f ≫ i) i = limit (cospan (f ≫ i) (𝟙 Z ≫ i))
e_4✝ : X = (cospan (f ≫ i) (𝟙 Z ≫ i)).obj left
⊢ i = 𝟙 Z ≫ i
[PROOFSTEP]
exact (Category.id_comp _).symm
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ (h ≫ f) ≫ pushout.inl = (h ≫ g) ≫ pushout.inr
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ h ≫ f ≫ pushout.inl = h ≫ g ≫ pushout.inr
[PROOFSTEP]
rw [cancel_epi]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ f ≫ pushout.inl = g ≫ pushout.inr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ C
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ ?m.421520 ⟶ Y
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ ?m.421520 ⟶ Z
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
h : W ⟶ X
inst✝¹ : Epi h
inst✝ : HasPushout f g
⊢ HasPushout ?m.421523 ?m.421524
[PROOFSTEP]
exact pushout.condition
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ f ≫ inv f ≫ g = g ≫ 𝟙 Z
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ NatTrans.app (pushoutCoconeOfLeftIso f g).ι none = g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
s : PushoutCocone f g
⊢ PushoutCocone.inl (pushoutCoconeOfLeftIso f g) ≫ PushoutCocone.inr s = PushoutCocone.inl s ∧
    PushoutCocone.inr (pushoutCoconeOfLeftIso f g) ≫ PushoutCocone.inr s = PushoutCocone.inr s ∧
      ∀ {m : (pushoutCoconeOfLeftIso f g).pt ⟶ s.pt},
        PushoutCocone.inl (pushoutCoconeOfLeftIso f g) ≫ m = PushoutCocone.inl s →
          PushoutCocone.inr (pushoutCoconeOfLeftIso f g) ≫ m = PushoutCocone.inr s → m = PushoutCocone.inr s
[PROOFSTEP]
simp [← s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ IsIso pushout.inr
[PROOFSTEP]
refine' ⟨⟨pushout.desc (inv f ≫ g) (𝟙 _) (by simp), by simp, _⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ f ≫ inv f ≫ g = g ≫ 𝟙 Z
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ pushout.inr ≫ pushout.desc (inv f ≫ g) (𝟙 Z) (_ : f ≫ inv f ≫ g = g ≫ 𝟙 Z) = 𝟙 Z
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ pushout.desc (inv f ≫ g) (𝟙 Z) (_ : f ≫ inv f ≫ g = g ≫ 𝟙 Z) ≫ pushout.inr = 𝟙 (pushout f g)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ pushout.inl ≫ pushout.desc (inv f ≫ g) (𝟙 Z) (_ : f ≫ inv f ≫ g = g ≫ 𝟙 Z) ≫ pushout.inr =
    pushout.inl ≫ 𝟙 (pushout f g)
[PROOFSTEP]
simp [← pushout.condition]
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ pushout.inr ≫ pushout.desc (inv f ≫ g) (𝟙 Z) (_ : f ≫ inv f ≫ g = g ≫ 𝟙 Z) ≫ pushout.inr =
    pushout.inr ≫ 𝟙 (pushout f g)
[PROOFSTEP]
simp [pushout.condition_assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ HasPushout h (h ≫ f)
[PROOFSTEP]
conv =>
  congr
  rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout h (h ≫ f)
[PROOFSTEP]
  congr
  rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout h (h ≫ f)
[PROOFSTEP]
  congr
  rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout h (h ≫ f)
[PROOFSTEP]
congr
[GOAL]
case f
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h
case g
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h ≫ f
[PROOFSTEP]
rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ HasPushout (h ≫ 𝟙 X) (h ≫ f)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ IsIso pushout.inr
[PROOFSTEP]
convert
  (congrArg IsIso
        (show pushout.inr ≫ _ = _ from
          colimit.isoColimitCocone_ι_inv ⟨_, pushoutIsPushoutOfEpiComp (𝟙 _) f h⟩ WalkingSpan.right)).mp
    inferInstance
[GOAL]
case h.e'_4.h.e'_6.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ h = h ≫ 𝟙 X
[PROOFSTEP]
apply (Category.comp_id _).symm
[GOAL]
case h.e'_5.e'_6.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso f✝
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
e_3✝ : Y = (span (h ≫ 𝟙 X) (h ≫ f)).obj right
e_4✝ : pushout h (h ≫ f) = colimit (span (h ≫ 𝟙 X) (h ≫ f))
⊢ h = h ≫ 𝟙 X
[PROOFSTEP]
apply (Category.comp_id _).symm
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ f ≫ 𝟙 Y = g ≫ inv g ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ NatTrans.app (pushoutCoconeOfRightIso f g).ι none = f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
s : PushoutCocone f g
⊢ PushoutCocone.inl (pushoutCoconeOfRightIso f g) ≫ PushoutCocone.inl s = PushoutCocone.inl s ∧
    PushoutCocone.inr (pushoutCoconeOfRightIso f g) ≫ PushoutCocone.inl s = PushoutCocone.inr s ∧
      ∀ {m : (pushoutCoconeOfRightIso f g).pt ⟶ s.pt},
        PushoutCocone.inl (pushoutCoconeOfRightIso f g) ≫ m = PushoutCocone.inl s →
          PushoutCocone.inr (pushoutCoconeOfRightIso f g) ≫ m = PushoutCocone.inr s → m = PushoutCocone.inl s
[PROOFSTEP]
simp [← s.condition]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ IsIso pushout.inl
[PROOFSTEP]
refine' ⟨⟨pushout.desc (𝟙 _) (inv g ≫ f) (by simp), by simp, _⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ f ≫ 𝟙 Y = g ≫ inv g ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ pushout.inl ≫ pushout.desc (𝟙 Y) (inv g ≫ f) (_ : f ≫ 𝟙 Y = g ≫ inv g ≫ f) = 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ pushout.desc (𝟙 Y) (inv g ≫ f) (_ : f ≫ 𝟙 Y = g ≫ inv g ≫ f) ≫ pushout.inl = 𝟙 (pushout f g)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ pushout.inl ≫ pushout.desc (𝟙 Y) (inv g ≫ f) (_ : f ≫ 𝟙 Y = g ≫ inv g ≫ f) ≫ pushout.inl =
    pushout.inl ≫ 𝟙 (pushout f g)
[PROOFSTEP]
simp [← pushout.condition]
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso g
⊢ pushout.inr ≫ pushout.desc (𝟙 Y) (inv g ≫ f) (_ : f ≫ 𝟙 Y = g ≫ inv g ≫ f) ≫ pushout.inl =
    pushout.inr ≫ 𝟙 (pushout f g)
[PROOFSTEP]
simp [pushout.condition]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ HasPushout (h ≫ f) h
[PROOFSTEP]
conv =>
  congr
  case g => rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout (h ≫ f) h
[PROOFSTEP]
  congr
  case g => rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout (h ≫ f) h
[PROOFSTEP]
  congr
  case g => rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| HasPushout (h ≫ f) h
[PROOFSTEP]
congr
[GOAL]
case f
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h ≫ f
case g
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h
[PROOFSTEP]
case g => rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h
[PROOFSTEP]
rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h
[PROOFSTEP]
rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
| h
[PROOFSTEP]
rw [← Category.comp_id h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ HasPushout (h ≫ f) (h ≫ 𝟙 X)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ IsIso pushout.inl
[PROOFSTEP]
convert
  (congrArg IsIso
        (show pushout.inl ≫ _ = _ from
          colimit.isoColimitCocone_ι_inv ⟨_, pushoutIsPushoutOfEpiComp f (𝟙 _) h⟩ WalkingSpan.left)).mp
    inferInstance
[GOAL]
case h.e'_4.h.e'_7.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
⊢ h = h ≫ 𝟙 X
[PROOFSTEP]
exact (Category.comp_id _).symm
[GOAL]
case h.e'_5.e'_7.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
W X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
inst✝¹ : IsIso g
h : W ⟶ X
inst✝ : Epi h
f : X ⟶ Y
e_3✝ : Y = (span (h ≫ f) (h ≫ 𝟙 X)).obj left
e_4✝ : pushout (h ≫ f) h = colimit (span (h ≫ f) (h ≫ 𝟙 X))
⊢ h = h ≫ 𝟙 X
[PROOFSTEP]
exact (Category.comp_id _).symm
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom = 𝟙 (pullback f f)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.fst = 𝟙 (pullback f f) ≫ pullback.fst
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.snd = 𝟙 (pullback f f) ≫ pullback.snd
[PROOFSTEP]
simp [fst_eq_snd_of_mono_eq]
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.snd = 𝟙 (pullback f f) ≫ pullback.snd
[PROOFSTEP]
simp [fst_eq_snd_of_mono_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ IsIso pullback.fst
[PROOFSTEP]
refine' ⟨⟨pullback.lift (𝟙 _) (𝟙 _) (by simp), _, by simp⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ 𝟙 X ≫ f = 𝟙 X ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ pullback.lift (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f) ≫ pullback.fst = 𝟙 X
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ pullback.fst ≫ pullback.lift (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f) = 𝟙 (pullback f f)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullback.fst ≫ pullback.lift (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)) ≫ pullback.fst = 𝟙 (pullback f f) ≫ pullback.fst
[PROOFSTEP]
simp
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullback.fst ≫ pullback.lift (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)) ≫ pullback.snd = 𝟙 (pullback f f) ≫ pullback.snd
[PROOFSTEP]
simp [fst_eq_snd_of_mono_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ IsIso pullback.snd
[PROOFSTEP]
rw [← fst_eq_snd_of_mono_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ IsIso pullback.fst
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ (pushoutSymmetry f f).hom = 𝟙 (pushout f f)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.inl ≫ (pushoutSymmetry f f).hom = pushout.inl ≫ 𝟙 (pushout f f)
[PROOFSTEP]
simp [inl_eq_inr_of_epi_eq]
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.inr ≫ (pushoutSymmetry f f).hom = pushout.inr ≫ 𝟙 (pushout f f)
[PROOFSTEP]
simp [inl_eq_inr_of_epi_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ IsIso pushout.inl
[PROOFSTEP]
refine' ⟨⟨pushout.desc (𝟙 _) (𝟙 _) (by simp), by simp, _⟩⟩
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ f ≫ 𝟙 Y = f ≫ 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.inl ≫ pushout.desc (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y) = 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.desc (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y) ≫ pushout.inl = 𝟙 (pushout f f)
[PROOFSTEP]
apply pushout.hom_ext
[GOAL]
case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.inl ≫ pushout.desc (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y) ≫ pushout.inl = pushout.inl ≫ 𝟙 (pushout f f)
[PROOFSTEP]
simp
[GOAL]
case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ pushout.inr ≫ pushout.desc (𝟙 Y) (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y) ≫ pushout.inl = pushout.inr ≫ 𝟙 (pushout f f)
[PROOFSTEP]
simp [inl_eq_inr_of_epi_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ IsIso pushout.inr
[PROOFSTEP]
rw [← inl_eq_inr_of_epi_eq]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
⊢ IsIso pushout.inl
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
⊢ i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃
[PROOFSTEP]
rw [← Category.assoc, h₁, Category.assoc, h₂, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
⊢ IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
[PROOFSTEP]
fapply PullbackCone.isLimitAux'
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
⊢ (s : PullbackCone (g₁ ≫ g₂) i₃) →
    { l //
      l ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
        l ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
          ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
            m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                PullbackCone.fst s →
              m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
have : (s.fst ≫ g₁) ≫ g₂ = s.snd ≫ i₃ := by rw [← s.condition, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
⊢ (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
[PROOFSTEP]
rw [← s.condition, Category.assoc]
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
rcases PullbackCone.IsLimit.lift' H (s.fst ≫ g₁) s.snd this with ⟨l₁, hl₁, hl₁'⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
rcases PullbackCone.IsLimit.lift' H' s.fst l₁ hl₁.symm with ⟨l₂, hl₂, hl₂'⟩
[GOAL]
case create.mk.intro.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
use l₂
[GOAL]
case property
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s ∧
    l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
      ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
        m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
          m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s →
            m = l₂
[PROOFSTEP]
use hl₂
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ∧
    ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
      m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
        m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s →
          m = l₂
[PROOFSTEP]
use show l₂ ≫ f₁ ≫ f₂ = s.snd by
    rw [← hl₁', ← hl₂', Category.assoc]
    rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ l₂ ≫ f₁ ≫ f₂ = PullbackCone.snd s
[PROOFSTEP]
rw [← hl₁', ← hl₂', Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ l₂ ≫ f₁ ≫ f₂ = l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
rfl
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
⊢ ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt},
    m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s →
      m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s →
        m = l₂
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ m = l₂
[PROOFSTEP]
apply PullbackCone.IsLimit.hom_ext H'
[GOAL]
case right.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁)
[PROOFSTEP]
erw [hm₁, hl₂]
[GOAL]
case right.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)
[PROOFSTEP]
apply PullbackCone.IsLimit.hom_ext H
[GOAL]
case right.h₁.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ (m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) =
    (l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
erw [Category.assoc, ← h₁, ← Category.assoc, hm₁, ← hl₂, Category.assoc, Category.assoc, h₁]
[GOAL]
case right.h₁.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ l₂ ≫ f₁ ≫ i₂ = l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
rfl
[GOAL]
case right.h₁.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ f₁ h₁)
s : PullbackCone (g₁ ≫ g₂) i₃
this : (PullbackCone.fst s ≫ g₁) ≫ g₂ = PullbackCone.snd s ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₂ f₂ h₂).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.fst s ≫ g₁
hl₁' : l₁ ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) = PullbackCone.snd s
l₂ : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hl₂ : l₂ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hl₂' : l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = l₁
m : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s
⊢ (m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) =
    (l₂ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
erw [Category.assoc, hm₂, ← hl₁', ← hl₂']
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
⊢ i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃
[PROOFSTEP]
rw [← Category.assoc, h₁, Category.assoc, h₂, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
⊢ IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
[PROOFSTEP]
fapply PushoutCocone.isColimitAux'
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
⊢ (s : PushoutCocone i₁ (f₁ ≫ f₂)) →
    { l //
      PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inl s ∧
        PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l =
            PushoutCocone.inr s ∧
          ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
            PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                PushoutCocone.inl s →
              PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                  PushoutCocone.inr s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
              PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                PushoutCocone.inr s →
              m = l }
[PROOFSTEP]
have : i₁ ≫ s.inl = f₁ ≫ f₂ ≫ s.inr := by rw [s.condition, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
⊢ i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
[PROOFSTEP]
rw [s.condition, Category.assoc]
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
              PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                PushoutCocone.inr s →
              m = l }
[PROOFSTEP]
rcases PushoutCocone.IsColimit.desc' H' s.inl (f₂ ≫ s.inr) this with ⟨l₁, hl₁, hl₁'⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
              PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                PushoutCocone.inr s →
              m = l }
[PROOFSTEP]
rcases PushoutCocone.IsColimit.desc' H l₁ s.inr hl₁' with ⟨l₂, hl₂, hl₂'⟩
[GOAL]
case create.mk.intro.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
              PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
                PushoutCocone.inr s →
              m = l }
[PROOFSTEP]
use l₂
[GOAL]
case property
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₂ = PushoutCocone.inl s ∧
    PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₂ = PushoutCocone.inr s ∧
      ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
        PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
            PushoutCocone.inl s →
          PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
              PushoutCocone.inr s →
            m = l₂
[PROOFSTEP]
use show (g₁ ≫ g₂) ≫ l₂ = s.inl by
    rw [← hl₁, ← hl₂, Category.assoc]
    rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ (g₁ ≫ g₂) ≫ l₂ = PushoutCocone.inl s
[PROOFSTEP]
rw [← hl₁, ← hl₂, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ g₁ ≫ g₂ ≫ l₂ = PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂
[PROOFSTEP]
rfl
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₂ = PushoutCocone.inr s ∧
    ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
      PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s →
        PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
            PushoutCocone.inr s →
          m = l₂
[PROOFSTEP]
use hl₂'
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
⊢ ∀ {m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt},
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s →
      PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s →
        m = l₂
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ m = l₂
[PROOFSTEP]
apply PushoutCocone.IsColimit.hom_ext H
[GOAL]
case right.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂
[PROOFSTEP]
apply PushoutCocone.IsColimit.hom_ext H'
[GOAL]
case right.h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m =
    PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂
[PROOFSTEP]
erw [← Category.assoc, hm₁, hl₂, hl₁]
[GOAL]
case right.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m =
    PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂
[PROOFSTEP]
erw [← Category.assoc, h₂, Category.assoc, hm₂, ← hl₂', ← Category.assoc, ← Category.assoc, ← h₂]
[GOAL]
case right.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ (i₂ ≫ g₂) ≫ l₂ = (PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂)) ≫ l₂
[PROOFSTEP]
rfl
[GOAL]
case right.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₂ i₃ h₂)
H' : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
s : PushoutCocone i₁ (f₁ ≫ f₂)
this : i₁ ≫ PushoutCocone.inl s = f₁ ≫ f₂ ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk g₁ i₂ h₁).pt ⟶ s.pt
hl₁ : PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ l₁ = f₂ ≫ PushoutCocone.inr s
l₂ : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt
hl₂ : PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = l₁
hl₂' : PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂ = PushoutCocone.inr s
m : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hm₁ : PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inl s
hm₂ : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l₂
[PROOFSTEP]
erw [hm₂, hl₂']
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
⊢ i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃
[PROOFSTEP]
rw [← Category.assoc, h₁, Category.assoc, h₂, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
⊢ IsLimit (PullbackCone.mk i₁ f₁ h₁)
[PROOFSTEP]
fapply PullbackCone.isLimitAux'
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
⊢ (s : PullbackCone g₁ i₂) →
    { l //
      l ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s ∧
        l ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
          ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
            m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
              m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l }
[PROOFSTEP]
have : s.fst ≫ g₁ ≫ g₂ = (s.snd ≫ f₂) ≫ i₃ := by rw [← Category.assoc, s.condition, Category.assoc, Category.assoc, h₂]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
⊢ PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
[PROOFSTEP]
rw [← Category.assoc, s.condition, Category.assoc, Category.assoc, h₂]
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l }
[PROOFSTEP]
rcases PullbackCone.IsLimit.lift' H' s.fst (s.snd ≫ f₂) this with ⟨l₁, hl₁, hl₁'⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l }
[PROOFSTEP]
use l₁
[GOAL]
case property
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s ∧
    l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
      ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
        m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
          m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l₁
[PROOFSTEP]
use hl₁
[GOAL]
case right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s ∧
    ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
      m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
        m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l₁
[PROOFSTEP]
constructor
[GOAL]
case right.left
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s
[PROOFSTEP]
apply PullbackCone.IsLimit.hom_ext H
[GOAL]
case right.left.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ (l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂) =
    PullbackCone.snd s ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
erw [Category.assoc, ← h₁, ← Category.assoc, hl₁, s.condition]
[GOAL]
case right.left.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ PullbackCone.snd s ≫ i₂ = PullbackCone.snd s ≫ PullbackCone.fst (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
rfl
[GOAL]
case right.left.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ (l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂) =
    PullbackCone.snd s ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
erw [Category.assoc, hl₁']
[GOAL]
case right.left.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ PullbackCone.snd s ≫ f₂ = PullbackCone.snd s ≫ PullbackCone.snd (PullbackCone.mk i₂ f₂ h₂)
[PROOFSTEP]
rfl
[GOAL]
case right.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
⊢ ∀ {m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt},
    m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s →
      m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s → m = l₁
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case right.right
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s
⊢ m = l₁
[PROOFSTEP]
apply PullbackCone.IsLimit.hom_ext H'
[GOAL]
case right.right.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s
⊢ m ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
    l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
[PROOFSTEP]
erw [hm₁, hl₁]
[GOAL]
case right.right.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s
⊢ m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
    l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
[PROOFSTEP]
erw [hl₁', ← hm₂]
[GOAL]
case right.right.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsLimit (PullbackCone.mk i₂ f₂ h₂)
H' : IsLimit (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PullbackCone g₁ i₂
this : PullbackCone.fst s ≫ g₁ ≫ g₂ = (PullbackCone.snd s ≫ f₂) ≫ i₃
l₁ : s.pt ⟶ (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt
hl₁ : l₁ ≫ PullbackCone.fst (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.fst s
hl₁' :
  l₁ ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) = PullbackCone.snd s ≫ f₂
m : s.pt ⟶ (PullbackCone.mk i₁ f₁ h₁).pt
hm₁ : m ≫ PullbackCone.fst (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.fst s
hm₂ : m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁) = PullbackCone.snd s
⊢ m ≫ PullbackCone.snd (PullbackCone.mk i₁ (f₁ ≫ f₂) (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) =
    (m ≫ PullbackCone.snd (PullbackCone.mk i₁ f₁ h₁)) ≫ f₂
[PROOFSTEP]
exact (Category.assoc _ _ _).symm
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
⊢ i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃
[PROOFSTEP]
rw [← Category.assoc, h₁, Category.assoc, h₂, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
⊢ IsColimit (PushoutCocone.mk g₂ i₃ h₂)
[PROOFSTEP]
fapply PushoutCocone.isColimitAux'
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
⊢ (s : PushoutCocone i₂ f₂) →
    { l //
      PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inl s ∧
        PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inr s ∧
          ∀ {m : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt},
            PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inl s →
              PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inr s → m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inr s → m = l }
[PROOFSTEP]
have : i₁ ≫ g₁ ≫ s.inl = (f₁ ≫ f₂) ≫ s.inr := by
  rw [Category.assoc, ← s.condition, ← Category.assoc, ← Category.assoc, h₁]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
⊢ i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
[PROOFSTEP]
rw [Category.assoc, ← s.condition, ← Category.assoc, ← Category.assoc, h₁]
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inr s → m = l }
[PROOFSTEP]
rcases PushoutCocone.IsColimit.desc' H' (g₁ ≫ s.inl) s.inr this with ⟨l₁, hl₁, hl₁'⟩
[GOAL]
case create.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ :
  PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₁ = PushoutCocone.inr s
⊢ { l //
    PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inl s ∧
      PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ l = PushoutCocone.inr s ∧
        ∀ {m : (PushoutCocone.mk g₂ i₃ h₂).pt ⟶ s.pt},
          PushoutCocone.inl (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inl s →
            PushoutCocone.inr (PushoutCocone.mk g₂ i₃ h₂) ≫ m = PushoutCocone.inr s → m = l }
[PROOFSTEP]
dsimp at *
[GOAL]
case create.mk.intro
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ { l //
    g₂ ≫ l = PushoutCocone.inl s ∧
      i₃ ≫ l = PushoutCocone.inr s ∧
        ∀ {m : Y₃ ⟶ s.pt}, g₂ ≫ m = PushoutCocone.inl s → i₃ ≫ m = PushoutCocone.inr s → m = l }
[PROOFSTEP]
use l₁
[GOAL]
case property
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ g₂ ≫ l₁ = PushoutCocone.inl s ∧
    i₃ ≫ l₁ = PushoutCocone.inr s ∧
      ∀ {m : Y₃ ⟶ s.pt}, g₂ ≫ m = PushoutCocone.inl s → i₃ ≫ m = PushoutCocone.inr s → m = l₁
[PROOFSTEP]
refine' ⟨_, _, _⟩
[GOAL]
case property.refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ g₂ ≫ l₁ = PushoutCocone.inl s
[PROOFSTEP]
apply PushoutCocone.IsColimit.hom_ext H
[GOAL]
case property.refine'_1.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ g₂ ≫ l₁ =
    PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl s
[PROOFSTEP]
erw [← Category.assoc, hl₁]
[GOAL]
case property.refine'_1.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ g₁ ≫ PushoutCocone.inl s = PushoutCocone.inl (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl s
[PROOFSTEP]
rfl
[GOAL]
case property.refine'_1.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ g₂ ≫ l₁ =
    PushoutCocone.inr (PushoutCocone.mk g₁ i₂ h₁) ≫ PushoutCocone.inl s
[PROOFSTEP]
erw [← Category.assoc, h₂, Category.assoc, hl₁', s.condition]
[GOAL]
case property.refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ i₃ ≫ l₁ = PushoutCocone.inr s
[PROOFSTEP]
exact hl₁'
[GOAL]
case property.refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
⊢ ∀ {m : Y₃ ⟶ s.pt}, g₂ ≫ m = PushoutCocone.inl s → i₃ ≫ m = PushoutCocone.inr s → m = l₁
[PROOFSTEP]
intro m hm₁ hm₂
[GOAL]
case property.refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
m : Y₃ ⟶ s.pt
hm₁ : g₂ ≫ m = PushoutCocone.inl s
hm₂ : i₃ ≫ m = PushoutCocone.inr s
⊢ m = l₁
[PROOFSTEP]
apply PushoutCocone.IsColimit.hom_ext H'
[GOAL]
case property.refine'_3.h₀
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
m : Y₃ ⟶ s.pt
hm₁ : g₂ ≫ m = PushoutCocone.inl s
hm₂ : i₃ ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
    PushoutCocone.inl (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₁
[PROOFSTEP]
erw [hl₁, Category.assoc, hm₁]
[GOAL]
case property.refine'_3.h₁
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ X₂
f₂ : X₂ ⟶ X₃
g₁ : Y₁ ⟶ Y₂
g₂ : Y₂ ⟶ Y₃
i₁ : X₁ ⟶ Y₁
i₂ : X₂ ⟶ Y₂
i₃ : X₃ ⟶ Y₃
h₁ : i₁ ≫ g₁ = f₁ ≫ i₂
h₂ : i₂ ≫ g₂ = f₂ ≫ i₃
H : IsColimit (PushoutCocone.mk g₁ i₂ h₁)
H' : IsColimit (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃))
s : PushoutCocone i₂ f₂
this : i₁ ≫ g₁ ≫ PushoutCocone.inl s = (f₁ ≫ f₂) ≫ PushoutCocone.inr s
l₁ : (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)).pt ⟶ s.pt
hl₁ : (g₁ ≫ g₂) ≫ l₁ = g₁ ≫ PushoutCocone.inl s
hl₁' : i₃ ≫ l₁ = PushoutCocone.inr s
m : Y₃ ⟶ s.pt
hm₁ : g₂ ≫ m = PushoutCocone.inl s
hm₂ : i₃ ≫ m = PushoutCocone.inr s
⊢ PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ m =
    PushoutCocone.inr (PushoutCocone.mk (g₁ ≫ g₂) i₃ (_ : i₁ ≫ g₁ ≫ g₂ = (f₁ ≫ f₂) ≫ i₃)) ≫ l₁
[PROOFSTEP]
erw [hm₂, hl₁']
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ pullback f' pullback.fst ≅ pullback (f' ≫ f) g
[PROOFSTEP]
let this :=
  bigSquareIsPullback (pullback.snd : pullback f' (pullback.fst : pullback f g ⟶ _) ⟶ _) pullback.snd f' f pullback.fst
    pullback.fst g pullback.condition pullback.condition (pullbackIsPullback _ _) (pullbackIsPullback _ _)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
this : IsLimit
  (PullbackCone.mk pullback.fst (pullback.snd ≫ pullback.snd)
    (_ : pullback.fst ≫ f' ≫ f = (pullback.snd ≫ pullback.snd) ≫ g)) :=
  bigSquareIsPullback pullback.snd pullback.snd f' f pullback.fst pullback.fst g
    (_ : pullback.fst ≫ f' = pullback.snd ≫ pullback.fst) (_ : pullback.fst ≫ f = pullback.snd ≫ g)
    (pullbackIsPullback f g) (pullbackIsPullback f' pullback.fst)
⊢ pullback f' pullback.fst ≅ pullback (f' ≫ f) g
[PROOFSTEP]
exact (this.conePointUniqueUpToIso (pullbackIsPullback _ _) : _)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.snd ≫ pullback.fst = pullback.fst ≫ f'
[PROOFSTEP]
rw [← pullback.condition]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.fst ≫ f' = pullback.fst ≫ f'
[PROOFSTEP]
exact pullbackRightPullbackFstIso_inv_fst_assoc _ _ _ _
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
g' : Z ⟶ W
inst✝² : HasPushout f g
inst✝¹ : HasPushout pushout.inr g'
inst✝ : HasPushout f (g ≫ g')
⊢ pushout.inr ≫ (pushoutLeftPushoutInrIso f g g').inv = pushout.inr
[PROOFSTEP]
rw [Iso.comp_inv_eq, inr_pushoutLeftPushoutInrIso_hom]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
g' : Z ⟶ W
inst✝² : HasPushout f g
inst✝¹ : HasPushout pushout.inr g'
inst✝ : HasPushout f (g ≫ g')
⊢ pushout.inl ≫ pushout.inl ≫ (pushoutLeftPushoutInrIso f g g').hom = pushout.inl
[PROOFSTEP]
rw [← Category.assoc, ← Iso.eq_comp_inv, inl_pushoutLeftPushoutInrIso_inv]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
g' : Z ⟶ W
inst✝² : HasPushout f g
inst✝¹ : HasPushout pushout.inr g'
inst✝ : HasPushout f (g ≫ g')
⊢ pushout.inr ≫ pushout.inl ≫ (pushoutLeftPushoutInrIso f g g').hom = g' ≫ pushout.inr
[PROOFSTEP]
rw [← Category.assoc, ← Iso.eq_comp_inv, Category.assoc, inr_pushoutLeftPushoutInrIso_inv, pushout.condition]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk pullback.fst
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄))
      (_ :
        pullback.fst ≫ pullback.snd =
          pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
              (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
            pullback.fst))
[PROOFSTEP]
apply leftSquareIsPullback
[GOAL]
case H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit (PullbackCone.mk pullback.fst ?f₂ ?h₂)
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk pullback.fst
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
          (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
        ?f₂)
      (_ :
        pullback.fst ≫ pullback.snd ≫ ?g₂ =
          (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
                (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
              ?f₂) ≫
            ?i₃))
case X₃
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ C
case Y₃
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ C
case f₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ Z₂ ⟶ ?X₃
case g₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ X₂ ⟶ ?Y₃
case i₃
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ ?X₃ ⟶ ?Y₃
case h₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ pullback.fst ≫ ?g₂ = ?f₂ ≫ ?i₃
[PROOFSTEP]
exact pullbackIsPullback f₃ f₄
[GOAL]
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk pullback.fst
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
          (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
        pullback.snd)
      (_ :
        pullback.fst ≫ pullback.snd ≫ f₃ =
          (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
                (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
              pullback.snd) ≫
            f₄))
[PROOFSTEP]
convert pullbackIsPullback (g₂ ≫ f₃) f₄
[GOAL]
case h.e'_6.h.e'_10
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd =
    pullback.snd
[PROOFSTEP]
rw [pullback.lift_snd]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ (pullback.fst ≫ pullback.fst) ≫ f₁ =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst ≫ f₂
[PROOFSTEP]
rw [pullback.lift_fst_assoc, Category.assoc, Category.assoc, pullback.condition]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk (pullback.fst ≫ pullback.fst)
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄))
      (_ :
        (pullback.fst ≫ pullback.fst) ≫ f₁ =
          pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
              (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
            pullback.fst ≫ f₂))
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄))
      (pullback.fst ≫ pullback.fst)
      (_ :
        pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
              (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
            pullback.fst ≫ f₂ =
          (pullback.fst ≫ pullback.fst) ≫ f₁))
[PROOFSTEP]
apply bigSquareIsPullback
[GOAL]
case t.H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit (PullbackCone.mk ?t.i₂ pullback.fst ?t.h₂)
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t.H.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit (PullbackCone.mk pullback.fst ?t.i₂ (_ : pullback.fst ≫ f₁ = ?t.i₂ ≫ f₂))
[PROOFSTEP]
exact pullbackIsPullback f₁ f₂
[GOAL]
case t.H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄))
      pullback.fst ?t.h₁)
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t.H'.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ IsLimit
    (PullbackCone.mk pullback.fst
      (pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄))
      (_ :
        pullback.fst ≫ pullback.snd =
          pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
              (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
            pullback.fst))
[PROOFSTEP]
apply pullbackPullbackLeftIsPullback
[GOAL]
case t.h₁
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact pullback.lift_fst _ _ _
[GOAL]
case t.h₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback (pullback.snd ≫ f₃) f₄
⊢ pullback.snd ≫ f₂ = pullback.fst ≫ f₁
[PROOFSTEP]
exact pullback.condition.symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂))
      pullback.snd
      (_ :
        pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
              (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
            pullback.snd =
          pullback.snd ≫ pullback.fst))
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk pullback.snd
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂))
      (_ :
        pullback.snd ≫ pullback.fst =
          pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
              (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
            pullback.snd))
[PROOFSTEP]
apply leftSquareIsPullback
[GOAL]
case t.H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit (PullbackCone.mk pullback.snd ?t.f₂ ?t.h₂)
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t.H.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit (PullbackCone.mk ?t.f₂ pullback.snd (_ : ?t.f₂ ≫ ?t.i₃ = pullback.snd ≫ ?t.g₂))
[PROOFSTEP]
exact pullbackIsPullback f₁ f₂
[GOAL]
case t.H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk pullback.snd
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
          (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
        pullback.fst)
      (_ :
        pullback.snd ≫ pullback.fst ≫ f₂ =
          (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
                (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
              pullback.fst) ≫
            f₁))
[PROOFSTEP]
apply PullbackCone.flipIsLimit
[GOAL]
case t.H'.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
          (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
        pullback.fst)
      pullback.snd
      (_ :
        (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
                (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
              pullback.fst) ≫
            f₁ =
          pullback.snd ≫ pullback.fst ≫ f₂))
[PROOFSTEP]
convert pullbackIsPullback f₁ (g₃ ≫ f₂)
[GOAL]
case h.e'_6.h.e'_9
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst =
    pullback.fst
[PROOFSTEP]
rw [pullback.lift_fst]
[GOAL]
case t.h₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.snd ≫ f₂ = pullback.fst ≫ f₁
[PROOFSTEP]
exact pullback.condition.symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.snd ≫ f₃ =
    (pullback.snd ≫ pullback.snd) ≫ f₄
[PROOFSTEP]
rw [pullback.lift_snd_assoc, Category.assoc, Category.assoc, pullback.condition]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂))
      (pullback.snd ≫ pullback.snd)
      (_ :
        pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
              (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
            pullback.snd ≫ f₃ =
          (pullback.snd ≫ pullback.snd) ≫ f₄))
[PROOFSTEP]
apply bigSquareIsPullback
[GOAL]
case H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit (PullbackCone.mk ?i₂ pullback.snd ?h₂)
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂))
      pullback.snd ?h₁)
case i₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ Z₂ ⟶ X₂
case h₁
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.snd =
    pullback.snd ≫ ?i₂
case h₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ ?i₂ ≫ f₃ = pullback.snd ≫ f₄
[PROOFSTEP]
exact pullbackIsPullback f₃ f₄
[GOAL]
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ IsLimit
    (PullbackCone.mk
      (pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂))
      pullback.snd ?h₁)
case h₁
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝² : HasPullback f₁ f₂
inst✝¹ : HasPullback f₃ f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.snd =
    pullback.snd ≫ pullback.fst
[PROOFSTEP]
apply pullbackPullbackRightIsPullback
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst ≫ pullback.fst = pullback.fst
[PROOFSTEP]
trans l₁' ≫ pullback.fst
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst ≫ pullback.fst =
    pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst =
    pullback.fst
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ ((pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst) ≫ pullback.fst =
    pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst =
    pullback.fst
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst =
    pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
      (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂)
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst =
    pullback.fst
[PROOFSTEP]
exact IsLimit.conePointUniqueUpToIso_inv_comp _ _ WalkingCospan.left
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift pullback.fst (pullback.snd ≫ pullback.fst)
        (_ : pullback.fst ≫ f₁ = (pullback.snd ≫ pullback.fst) ≫ f₂) ≫
      pullback.fst =
    pullback.fst
[PROOFSTEP]
exact pullback.lift_fst _ _ _
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.fst = pullback.fst ≫ pullback.fst
[PROOFSTEP]
rw [← Iso.eq_inv_comp, pullbackAssoc_inv_fst_fst]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd ≫ pullback.fst = pullback.fst ≫ pullback.snd
[PROOFSTEP]
trans l₂ ≫ pullback.fst
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd ≫ pullback.fst =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ ((pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd) ≫ pullback.fst =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
      (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄)
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact IsLimit.conePointUniqueUpToIso_hom_comp _ _ WalkingCospan.right
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact pullback.lift_fst _ _ _
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd ≫ pullback.snd = pullback.snd
[PROOFSTEP]
trans l₂ ≫ pullback.snd
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd ≫ pullback.snd =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd =
    pullback.snd
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ ((pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd) ≫ pullback.snd =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd =
    pullback.snd
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd =
    pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
      (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄)
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd =
    pullback.snd
[PROOFSTEP]
exact IsLimit.conePointUniqueUpToIso_hom_comp _ _ WalkingCospan.right
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ pullback.lift (pullback.fst ≫ pullback.snd) pullback.snd
        (_ : (pullback.fst ≫ pullback.snd) ≫ f₃ = pullback.snd ≫ f₄) ≫
      pullback.snd =
    pullback.snd
[PROOFSTEP]
exact pullback.lift_snd _ _ _
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.fst ≫ pullback.snd = pullback.snd ≫ pullback.fst
[PROOFSTEP]
rw [Iso.inv_comp_eq, pullbackAssoc_hom_snd_fst]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Y₁ Y₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₁
f₃ : X₂ ⟶ Y₂
f₄ : X₃ ⟶ Y₂
inst✝⁵ : HasPullback f₁ f₂
inst✝⁴ : HasPullback f₃ f₄
inst✝³ : HasPullback (pullback.snd ≫ sorryAx (sorryAx C true ⟶ Y₂) true) f₄
inst✝² : HasPullback f₁ (pullback.fst ≫ f₂)
inst✝¹ : HasPullback (pullback.snd ≫ f₃) f₄
inst✝ : HasPullback f₁ (pullback.fst ≫ f₂)
⊢ (pullbackAssoc f₁ f₂ f₃ f₄).inv ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
rw [Iso.inv_comp_eq, pullbackAssoc_hom_snd_snd]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk pushout.inl
      (pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      (_ :
        pushout.inr ≫ pushout.inl =
          pushout.inl ≫
            pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr
              (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)))
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      pushout.inl
      (_ :
        pushout.inl ≫
            pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr
              (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr) =
          pushout.inr ≫ pushout.inl))
[PROOFSTEP]
apply rightSquareIsPushout
[GOAL]
case t.H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit (PushoutCocone.mk ?t.g₁ pushout.inl ?t.h₁)
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t.H.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit (PushoutCocone.mk pushout.inl ?t.g₁ (_ : ?t.f₁ ≫ pushout.inl = ?t.i₁ ≫ ?t.g₁))
[PROOFSTEP]
exact pushoutIsPushout _ _
[GOAL]
case t.H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.inr ≫
        pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      pushout.inl
      (_ :
        g₄ ≫
            pushout.inr ≫
              pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr
                (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr) =
          (g₃ ≫ pushout.inr) ≫ pushout.inl))
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t.H'.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk pushout.inl
      (pushout.inr ≫
        pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      (_ :
        (g₃ ≫ pushout.inr) ≫ pushout.inl =
          g₄ ≫
            pushout.inr ≫
              pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr
                (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)))
[PROOFSTEP]
convert pushoutIsPushout (g₃ ≫ f₂) g₄
[GOAL]
case h.e'_6.h.e'_10
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ pushout.inr ≫
      pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr) =
    pushout.inr
[PROOFSTEP]
exact pushout.inr_desc _ _ _
[GOAL]
case t.h₁
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ g₄ ≫ pushout.inr = g₃ ≫ pushout.inl
[PROOFSTEP]
exact pushout.condition.symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ g₁ ≫ pushout.inl ≫ pushout.inl =
    (g₂ ≫ pushout.inl) ≫
      pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)
[PROOFSTEP]
rw [Category.assoc, pushout.inl_desc, pushout.condition_assoc]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk (pushout.inl ≫ pushout.inl)
      (pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      (_ :
        g₁ ≫ pushout.inl ≫ pushout.inl =
          (g₂ ≫ pushout.inl) ≫
            pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr
              (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)))
[PROOFSTEP]
apply bigSquareIsPushout
[GOAL]
case H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit
    (PushoutCocone.mk pushout.inl
      (pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr))
      ?h₂)
[PROOFSTEP]
apply pushoutPushoutLeftIsPushout
[GOAL]
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout (g₃ ≫ pushout.inr) g₄
⊢ IsColimit (PushoutCocone.mk pushout.inl pushout.inr ?h₁)
[PROOFSTEP]
exact pushoutIsPushout _ _
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      pushout.inr
      (_ :
        pushout.inr ≫
            pushout.desc pushout.inl (pushout.inl ≫ pushout.inr)
              (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
          pushout.inl ≫ pushout.inr))
[PROOFSTEP]
apply rightSquareIsPushout
[GOAL]
case H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit (PushoutCocone.mk ?g₁ pushout.inr ?h₁)
[PROOFSTEP]
exact pushoutIsPushout _ _
[GOAL]
case H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.inl ≫
        pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      pushout.inr
      (_ :
        g₁ ≫
            pushout.inl ≫
              pushout.desc pushout.inl (pushout.inl ≫ pushout.inr)
                (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
          (g₂ ≫ pushout.inl) ≫ pushout.inr))
[PROOFSTEP]
convert pushoutIsPushout g₁ (g₂ ≫ f₃)
[GOAL]
case h.e'_6.h.e'_9
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
    pushout.inl
[PROOFSTEP]
rw [pushout.inl_desc]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ (g₃ ≫ pushout.inr) ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
    g₄ ≫ pushout.inr ≫ pushout.inr
[PROOFSTEP]
rw [Category.assoc, pushout.inr_desc, pushout.condition_assoc]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      (pushout.inr ≫ pushout.inr)
      (_ :
        (g₃ ≫ pushout.inr) ≫
            pushout.desc pushout.inl (pushout.inl ≫ pushout.inr)
              (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
          g₄ ≫ pushout.inr ≫ pushout.inr))
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk (pushout.inr ≫ pushout.inr)
      (pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      (_ :
        g₄ ≫ pushout.inr ≫ pushout.inr =
          (g₃ ≫ pushout.inr) ≫
            pushout.desc pushout.inl (pushout.inl ≫ pushout.inr)
              (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)))
[PROOFSTEP]
apply bigSquareIsPushout
[GOAL]
case t.H
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk pushout.inr
      (pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      ?t.h₂)
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t.H.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit
    (PushoutCocone.mk
      (pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr))
      pushout.inr
      (_ :
        pushout.inr ≫
            pushout.desc pushout.inl (pushout.inl ≫ pushout.inr)
              (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
          ?t.i₂ ≫ pushout.inr))
[PROOFSTEP]
apply pushoutPushoutRightIsPushout
[GOAL]
case t.H'
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit (PushoutCocone.mk pushout.inr pushout.inl ?t.h₁)
[PROOFSTEP]
apply PushoutCocone.flipIsColimit
[GOAL]
case t.H'.t
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ IsColimit (PushoutCocone.mk pushout.inl pushout.inr (_ : g₃ ≫ pushout.inl = g₄ ≫ pushout.inr))
[PROOFSTEP]
exact pushoutIsPushout _ _
[GOAL]
case t.h₁
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ g₄ ≫ pushout.inr = g₃ ≫ pushout.inl
[PROOFSTEP]
exact pushout.condition.symm
[GOAL]
case t.h₂
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝² : HasPushout g₁ g₂
inst✝¹ : HasPushout g₃ g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ pushout.inr =
    pushout.inr ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)
[PROOFSTEP]
exact (pushout.inr_desc _ _ _).symm
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inl
[PROOFSTEP]
trans f₁ ≫ l₁
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.inl ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)
[PROOFSTEP]
exact (pushoutPushoutLeftIsPushout g₁ g₂ g₃ g₄).comp_coconePointUniqueUpToIso_hom _ WalkingCospan.left
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
    pushout.inl
[PROOFSTEP]
exact pushout.inl_desc _ _ _
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inl ≫ pushout.inr
[PROOFSTEP]
trans f₂ ≫ l₁
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.inr ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom =
    pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr)
[PROOFSTEP]
exact (pushoutPushoutLeftIsPushout g₁ g₂ g₃ g₄).comp_coconePointUniqueUpToIso_hom _ WalkingCospan.left
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫
      pushout.desc pushout.inl (pushout.inl ≫ pushout.inr) (_ : g₁ ≫ pushout.inl = g₂ ≫ pushout.inl ≫ pushout.inr) =
    pushout.inl ≫ pushout.inr
[PROOFSTEP]
exact pushout.inr_desc _ _ _
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inr
[PROOFSTEP]
trans f₄ ≫ l₂'
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
    pushout.inr ≫
      pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
    pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr)
[PROOFSTEP]
exact
  (pushoutPushoutLeftIsPushout g₁ g₂ g₃ g₄).comp_coconePointUniqueUpToIso_inv (pushoutPushoutRightIsPushout g₁ g₂ g₃ g₄)
    WalkingCospan.right
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫
      pushout.desc (pushout.inr ≫ pushout.inl) pushout.inr (_ : g₃ ≫ pushout.inr ≫ pushout.inl = g₄ ≫ pushout.inr) =
    pushout.inr
[PROOFSTEP]
exact pushout.inr_desc _ _ _
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inl ≫ pushout.inl
[PROOFSTEP]
rw [Iso.comp_inv_eq, Category.assoc, inl_inl_pushoutAssoc_hom]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inr ≫ pushout.inl
[PROOFSTEP]
rw [← Category.assoc, Iso.comp_inv_eq, Category.assoc, inr_inl_pushoutAssoc_hom]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inr ≫ pushout.inr
[PROOFSTEP]
rw [← Iso.eq_comp_inv, Category.assoc, inr_inr_pushoutAssoc_inv]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D✝ : Type u₂
inst✝ : Category.{v₂, u₂} D✝
W X Y Z : C
D : Type u
h : Category.{v, u} D
h' : HasWidePullbacks D
⊢ HasPullbacks D
[PROOFSTEP]
haveI I := @hasWidePullbacks_shrink.{0, w} D h h'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D✝ : Type u₂
inst✝ : Category.{v₂, u₂} D✝
W X Y Z : C
D : Type u
h : Category.{v, u} D
h' : HasWidePullbacks D
I : HasWidePullbacks D
⊢ HasPullbacks D
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D✝ : Type u₂
inst✝ : Category.{v₂, u₂} D✝
W X Y Z : C
D : Type u
h : Category.{v, u} D
h' : HasWidePushouts D
⊢ HasPushouts D
[PROOFSTEP]
haveI I := @hasWidePushouts_shrink.{0, w} D h h'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D✝ : Type u₂
inst✝ : Category.{v₂, u₂} D✝
W X Y Z : C
D : Type u
h : Category.{v, u} D
h' : HasWidePushouts D
I : HasWidePushouts D
⊢ HasPushouts D
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
X✝ Y✝ : Over Y
i : X✝ ⟶ Y✝
⊢ X✝.hom ≫ 𝟙 ((Functor.fromPUnit Y).obj X✝.right) = i.left ≫ Y✝.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
X✝ Y✝ : Over Y
i : X✝ ⟶ Y✝
⊢ f ≫ 𝟙 ((Functor.fromPUnit Y).obj X✝.right) = 𝟙 X ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ { obj := fun g => Over.mk pullback.snd,
          map := fun {X_1 Y_1} i =>
            Over.homMk
              (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.map
      (𝟙 Z) =
    𝟙
      ({ obj := fun g => Over.mk pullback.snd,
            map := fun {X_1 Y_1} i =>
              Over.homMk
                (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                  (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.obj
        Z)
[PROOFSTEP]
apply Over.OverMorphism.ext
[GOAL]
case h
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ ({ obj := fun g => Over.mk pullback.snd,
            map := fun {X_1 Y_1} i =>
              Over.homMk
                (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                  (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.map
        (𝟙 Z)).left =
    (𝟙
        ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.obj
          Z)).left
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h.h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.map
          (𝟙 Z)).left ≫
      pullback.fst =
    (𝟙
          ({ obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.obj
            Z)).left ≫
      pullback.fst
[PROOFSTEP]
dsimp
[GOAL]
case h.h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ pullback.map Z.hom f Z.hom f (𝟙 Z.left) (𝟙 X) (𝟙 Y) (_ : Z.hom ≫ 𝟙 Y = 𝟙 Z.left ≫ Z.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f) ≫
      pullback.fst =
    𝟙 (pullback Z.hom f) ≫ pullback.fst
[PROOFSTEP]
simp
[GOAL]
case h.h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.map
          (𝟙 Z)).left ≫
      pullback.snd =
    (𝟙
          ({ obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f Y_1.hom f i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f)) }.obj
            Z)).left ≫
      pullback.snd
[PROOFSTEP]
dsimp
[GOAL]
case h.h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝ Y✝ Z✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
Z : Over Y
⊢ pullback.map Z.hom f Z.hom f (𝟙 Z.left) (𝟙 X) (𝟙 Y) (_ : Z.hom ≫ 𝟙 Y = 𝟙 Z.left ≫ Z.hom) (_ : f ≫ 𝟙 Y = 𝟙 X ≫ f) ≫
      pullback.snd =
    𝟙 (pullback Z.hom f) ≫ pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun g => Over.mk pullback.snd,
          map := fun {X_1 Y_1} i =>
            Over.homMk
              (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
      (f ≫ g) =
    { obj := fun g => Over.mk pullback.snd,
            map := fun {X_1 Y_1} i =>
              Over.homMk
                (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                  (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
        f ≫
      { obj := fun g => Over.mk pullback.snd,
            map := fun {X_1 Y_1} i =>
              Over.homMk
                (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                  (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
        g
[PROOFSTEP]
apply Over.OverMorphism.ext
[GOAL]
case h
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun g => Over.mk pullback.snd,
            map := fun {X_1 Y_1} i =>
              Over.homMk
                (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                  (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
        (f ≫ g)).left =
    ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
          f ≫
        { obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
          g).left
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h.h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
          (f ≫ g)).left ≫
      pullback.fst =
    ({ obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
            f ≫
          { obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
            g).left ≫
      pullback.fst
[PROOFSTEP]
dsimp
[GOAL]
case h.h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ pullback.map X✝.hom f✝ Z✝.hom f✝ (f.left ≫ g.left) (𝟙 X) (𝟙 Y) (_ : X✝.hom ≫ 𝟙 Y = (f.left ≫ g.left) ≫ Z✝.hom)
        (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝) ≫
      pullback.fst =
    (pullback.map X✝.hom f✝ Y✝.hom f✝ f.left (𝟙 X) (𝟙 Y) (_ : X✝.hom ≫ 𝟙 Y = f.left ≫ Y✝.hom)
          (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝) ≫
        pullback.map Y✝.hom f✝ Z✝.hom f✝ g.left (𝟙 X) (𝟙 Y) (_ : Y✝.hom ≫ 𝟙 Y = g.left ≫ Z✝.hom)
          (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) ≫
      pullback.fst
[PROOFSTEP]
simp
[GOAL]
case h.h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun g => Over.mk pullback.snd,
              map := fun {X_1 Y_1} i =>
                Over.homMk
                  (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                    (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
          (f ≫ g)).left ≫
      pullback.snd =
    ({ obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
            f ≫
          { obj := fun g => Over.mk pullback.snd,
                map := fun {X_1 Y_1} i =>
                  Over.homMk
                    (pullback.map X_1.hom f✝ Y_1.hom f✝ i.left (𝟙 X) (𝟙 ((Functor.fromPUnit Y).obj X_1.right))
                      (_ : X_1.hom ≫ 𝟙 Y = i.left ≫ Y_1.hom) (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) }.map
            g).left ≫
      pullback.snd
[PROOFSTEP]
dsimp
[GOAL]
case h.h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X✝¹ Y✝¹ Z : C
inst✝ : HasPullbacks C
X Y : C
f✝ : X ⟶ Y
X✝ Y✝ Z✝ : Over Y
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ pullback.map X✝.hom f✝ Z✝.hom f✝ (f.left ≫ g.left) (𝟙 X) (𝟙 Y) (_ : X✝.hom ≫ 𝟙 Y = (f.left ≫ g.left) ≫ Z✝.hom)
        (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝) ≫
      pullback.snd =
    (pullback.map X✝.hom f✝ Y✝.hom f✝ f.left (𝟙 X) (𝟙 Y) (_ : X✝.hom ≫ 𝟙 Y = f.left ≫ Y✝.hom)
          (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝) ≫
        pullback.map Y✝.hom f✝ Z✝.hom f✝ g.left (𝟙 X) (𝟙 Y) (_ : Y✝.hom ≫ 𝟙 Y = g.left ≫ Z✝.hom)
          (_ : f✝ ≫ 𝟙 Y = 𝟙 X ≫ f✝)) ≫
      pullback.snd
[PROOFSTEP]
simp