l3lab/ntp-mathlib huggingface dataset:
/-- `parallelFamily f` is the diagram in `C` consisting of the given family of morphisms, each with
common domain and codomain.
-/
def parallelFamily : WalkingParallelFamily J ⥤ C where
  obj x := WalkingParallelFamily.casesOn x X Y
  map {x y} h :=
    match x, y, h with
    | _, _, Hom.id _ => 𝟙 _
    | _, _, line j => f j
  map_comp := by
    rintro _ _ _ ⟨⟩ ⟨⟩ <;>
      · 

Proof state:
case line.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
x✝ : J
⊢ { obj := fun x => WalkingParallelFamily.casesOn x X Y,
          map := fun {x y} h =>
            match x, y, h with
            | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
            | .(zero), .(one), line j => f j }.map
      (line x✝ ≫ Hom.id one) =
    { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (line x✝) ≫
      { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (Hom.id one)

Next tactic:
aesop_cat
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by 

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
j : WalkingParallelFamily J
⊢ F.obj j = (parallelFamily fun j => F.map (line j)).obj j

Next tactic:
cases j
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by cases j <;> 

Proof state:
case zero
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
⊢ F.obj zero = (parallelFamily fun j => F.map (line j)).obj zero

Next tactic:
aesop_cat
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by cases j <;> 

Proof state:
case one
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
⊢ F.obj one = (parallelFamily fun j => F.map (line j)).obj one

Next tactic:
aesop_cat
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by cases j <;> aesop_cat) <| by
    

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
⊢ ∀ {X Y : WalkingParallelFamily J} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) Y).hom =
      ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) X).hom ≫
        (parallelFamily fun j => F.map (line j)).map f

Next tactic:
rintro _ _ (_|_)
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by cases j <;> aesop_cat) <| by
    rintro _ _ (_|_) <;> 

Proof state:
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
X✝ : WalkingParallelFamily J
⊢ F.map (Hom.id X✝) ≫ ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) X✝).hom =
    ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) X✝).hom ≫
      (parallelFamily fun j => F.map (line j)).map (Hom.id X✝)

Next tactic:
aesop_cat
/-- Every functor indexing a wide (co)equalizer is naturally isomorphic (actually, equal) to a
    `parallelFamily` -/
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) :=
  NatIso.ofComponents (fun j => eqToIso <| by cases j <;> aesop_cat) <| by
    rintro _ _ (_|_) <;> 

Proof state:
case line
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
x✝ : J
⊢ F.map (line x✝) ≫ ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) one).hom =
    ((fun j => eqToIso (_ : F.obj j = (parallelFamily fun j => F.map (line j)).obj j)) zero).hom ≫
      (parallelFamily fun j => F.map (line j)).map (line x✝)

Next tactic:
aesop_cat
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by 

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelFamily (ULift.{w, 0} Bool)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      X

Next tactic:
cases X
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> 

Proof state:
case zero
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj zero =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      zero

Next tactic:
rfl
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> 

Proof state:
case one
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj one =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      one

Next tactic:
rfl
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelFamily (ULift.{w, 0} Bool)} (f : X ⟶ Y),
    (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map f ≫
        ((fun X =>
              eqToIso
                (_ :
                  (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                    ((parallelFamily fun p =>
                            bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                          parallelPair (line { down := true }) (line { down := false })).obj
                      X))
            Y).hom =
      ((fun X =>
              eqToIso
                (_ :
                  (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                    ((parallelFamily fun p =>
                            bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                          parallelPair (line { down := true }) (line { down := false })).obj
                      X))
            X).hom ≫
        ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
              parallelPair (line { down := true }) (line { down := false })).map
          f

Next tactic:
rintro _ _ (_|⟨_|_⟩)
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> 

Proof state:
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
X✝ : WalkingParallelFamily (ULift.{w, 0} Bool)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map (Hom.id X✝) ≫
      ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          X✝).hom =
    ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          X✝).hom ≫
      ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
            parallelPair (line { down := true }) (line { down := false })).map
        (Hom.id X✝)

Next tactic:
aesop_cat
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> 

Proof state:
case line.up.false
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map (line { down := false }) ≫
      ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          one).hom =
    ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          zero).hom ≫
      ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
            parallelPair (line { down := true }) (line { down := false })).map
        (line { down := false })

Next tactic:
aesop_cat
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> 

Proof state:
case line.up.true
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map (line { down := true }) ≫
      ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          one).hom =
    ((fun X =>
            eqToIso
              (_ :
                (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
                  ((parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
                        parallelPair (line { down := true }) (line { down := false })).obj
                    X))
          zero).hom ≫
      ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
            parallelPair (line { down := true }) (line { down := false })).map
        (line { down := true })

Next tactic:
aesop_cat
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by 

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelPair
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      X =
    (𝟭 WalkingParallelPair).obj X

Next tactic:
cases X
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> 

Proof state:
case zero
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      WalkingParallelPair.zero =
    (𝟭 WalkingParallelPair).obj WalkingParallelPair.zero

Next tactic:
rfl
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> 

Proof state:
case one
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      WalkingParallelPair.one =
    (𝟭 WalkingParallelPair).obj WalkingParallelPair.one

Next tactic:
rfl
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    (parallelPair (line { down := true }) (line { down := false }) ⋙
              parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          f ≫
        ((fun X =>
              eqToIso
                (_ :
                  (parallelPair (line { down := true }) (line { down := false }) ⋙
                          parallelFamily fun p =>
                            bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                      X =
                    (𝟭 WalkingParallelPair).obj X))
            Y).hom =
      ((fun X =>
              eqToIso
                (_ :
                  (parallelPair (line { down := true }) (line { down := false }) ⋙
                          parallelFamily fun p =>
                            bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                      X =
                    (𝟭 WalkingParallelPair).obj X))
            X).hom ≫
        (𝟭 WalkingParallelPair).map f

Next tactic:
rintro _ _ (_|_|_)
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|_|_) <;> 

Proof state:
case left
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
            parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
        WalkingParallelPairHom.left ≫
      ((fun X =>
            eqToIso
              (_ :
                (parallelPair (line { down := true }) (line { down := false }) ⋙
                        parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                    X =
                  (𝟭 WalkingParallelPair).obj X))
          WalkingParallelPair.one).hom =
    ((fun X =>
            eqToIso
              (_ :
                (parallelPair (line { down := true }) (line { down := false }) ⋙
                        parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                    X =
                  (𝟭 WalkingParallelPair).obj X))
          WalkingParallelPair.zero).hom ≫
      (𝟭 WalkingParallelPair).map WalkingParallelPairHom.left

Next tactic:
aesop_cat
/-- `WalkingParallelPair` as a category is equivalent to a special case of
`WalkingParallelFamily`.  -/
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair where
  functor :=
    parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
  inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
  unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|⟨_|_⟩) <;> aesop_cat)
  counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
    rintro _ _ (_|_|_) <;> 

Proof state:
case right
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
            parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
        WalkingParallelPairHom.right ≫
      ((fun X =>
            eqToIso
              (_ :
                (parallelPair (line { down := true }) (line { down := false }) ⋙
                        parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                    X =
                  (𝟭 WalkingParallelPair).obj X))
          WalkingParallelPair.one).hom =
    ((fun X =>
            eqToIso
              (_ :
                (parallelPair (line { down := true }) (line { down := false }) ⋙
                        parallelFamily fun p =>
                          bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
                    X =
                  (𝟭 WalkingParallelPair).obj X))
          WalkingParallelPair.zero).hom ≫
      (𝟭 WalkingParallelPair).map WalkingParallelPairHom.right

Next tactic:
aesop_cat