l3lab/ntp-mathlib huggingface dataset:
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.none
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ none
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.some.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ some WalkingPair.left
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.some.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : none ⟶ some WalkingPair.right
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.left.none
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ none
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.left.some.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.left
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.left.some.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.left ⟶ some WalkingPair.right
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.right.none
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ none
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn none (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.right.some.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.left
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case some.right.some.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Z
g : Y ⟶ Z
f : some WalkingPair.right ⟶ some WalkingPair.right
⊢ (span f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> 

Proof state:
case none.none.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id none) ≫
      (Option.casesOn none (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id none)

Next tactic:
aesop_cat
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> 

Proof state:
case none.some.left.init
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.init WalkingPair.left) ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.init WalkingPair.left)

Next tactic:
aesop_cat
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> 

Proof state:
case none.some.right.init
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.init WalkingPair.right) ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.init WalkingPair.right)

Next tactic:
aesop_cat
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> 

Proof state:
case some.left.some.left.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.left) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id (some WalkingPair.left))

Next tactic:
aesop_cat
/-- The canonical isomorphism relating `Span f.op g.op` and `(Cospan f g).op` -/
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> 

Proof state:
case some.right.some.right.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn (some WalkingPair.right) (Iso.refl ((span f.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((span f.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((span f.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id (some WalkingPair.right))

Next tactic:
aesop_cat
/-- The canonical isomorphism relating `(Cospan f g).op` and `Span f.op g.op` -/
@[simps!]
def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op :=
  calc
    (cospan f g).op ≅ 𝟭 _ ⋙ (cospan f g).op := by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (cospan f g).op ≅ 𝟭 WalkingCospanᵒᵖ ⋙ (cospan f g).op

Next tactic:
rfl
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (X_1 : WalkingCospan) → (cospan f.op g.op).obj X_1 ≅ (walkingSpanOpEquiv.inverse ⋙ (span f g).op).obj X_1

Next tactic:
rintro (_ | _ | _)
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> 

Proof state:
case none
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (cospan f.op g.op).obj none ≅ (walkingSpanOpEquiv.inverse ⋙ (span f g).op).obj none

Next tactic:
rfl
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> 

Proof state:
case some.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (cospan f.op g.op).obj (some WalkingPair.left) ≅
    (walkingSpanOpEquiv.inverse ⋙ (span f g).op).obj (some WalkingPair.left)

Next tactic:
rfl
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> 

Proof state:
case some.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ (cospan f.op g.op).obj (some WalkingPair.right) ≅
    (walkingSpanOpEquiv.inverse ⋙ (span f g).op).obj (some WalkingPair.right)

Next tactic:
rfl
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
⊢ ∀ {X_1 Y_1 : WalkingCospan} (f_1 : X_1 ⟶ Y_1),
    (cospan f.op g.op).map f_1 ≫
        (Option.casesOn Y_1 (Iso.refl ((cospan f.op g.op).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.right)))).hom =
      (Option.casesOn X_1 (Iso.refl ((cospan f.op g.op).obj none)) fun val =>
            WalkingPair.casesOn val (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.left)))
              (Iso.refl ((cospan f.op g.op).obj (some WalkingPair.right)))).hom ≫
        (walkingSpanOpEquiv.inverse ⋙ (span f g).op).map f_1

Next tactic:
rintro (_ | _ | _) (_ | _ | _) f
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.none
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ none
⊢ (cospan f✝.op g.op).map f ≫
      (Option.casesOn none (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingSpanOpEquiv.inverse ⋙ (span f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.some.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ some WalkingPair.left
⊢ (cospan f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.left) (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingSpanOpEquiv.inverse ⋙ (span f✝ g).op).map f

Next tactic:
cases f
/-- The canonical isomorphism relating `Cospan f.op g.op` and `(Span f g).op` -/
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
  NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
    (by rintro (_ | _ | _) (_ | _ | _) f <;> 

Proof state:
case none.some.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f✝ : X ⟶ Y
g : X ⟶ Z
f : none ⟶ some WalkingPair.right
⊢ (cospan f✝.op g.op).map f ≫
      (Option.casesOn (some WalkingPair.right) (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom =
    (Option.casesOn none (Iso.refl ((cospan f✝.op g.op).obj none)) fun val =>
          WalkingPair.casesOn val (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.left)))
            (Iso.refl ((cospan f✝.op g.op).obj (some WalkingPair.right)))).hom ≫
      (walkingSpanOpEquiv.inverse ⋙ (span f✝ g).op).map f

Next tactic:
cases f