l3lab/ntp-mathlib huggingface dataset:
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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))

Next tactic:
dsimp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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)

Next tactic:
dsimp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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))

Next tactic:
dsimp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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)

Next tactic:
simp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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

Next tactic:
simp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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))

Next tactic:
simp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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

Next tactic:
simp
/-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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))

Next tactic:
simp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by 

Proof state:
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

Next tactic:
rcases j with (⟨⟩ | ⟨⟨⟩⟩)
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
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

Next tactic:
rfl
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
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)

Next tactic:
rfl
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
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)

Next tactic:
rfl
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by 

Proof state:
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

Next tactic:
rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> 

Proof state:
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

Next tactic:
cases f
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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)

Next tactic:
dsimp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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)

Next tactic:
dsimp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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)

Next tactic:
dsimp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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))

Next tactic:
dsimp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> 

Proof state:
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))

Next tactic:
dsimp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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)

Next tactic:
simp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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

Next tactic:
simp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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

Next tactic:
simp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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))

Next tactic:
simp
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) :=
  NatIso.ofComponents
  (fun j => eqToIso (by rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl))
  (by rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> 

Proof state:
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))

Next tactic:
simp
/-- A functor applied to a cospan is a cospan. -/
def cospanCompIso (F : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    cospan f g ⋙ F ≅ cospan (F.map f) (F.map g) :=
  NatIso.ofComponents (by 

Proof state:
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

Next tactic:
rintro (⟨⟩ | ⟨⟨⟩⟩)