l3lab/ntp-mathlib huggingface dataset:
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> 

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
⊢ (parallelPair f g).map right ≫
      (fun j =>
          match j with
          | zero => p
          | one => q)
        one =
    (fun j =>
          match j with
          | zero => p
          | one => q)
        zero ≫
      (parallelPair f' g').map right

Next tactic:
{dsimp; simp [wf,wg]}
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> {

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
⊢ (parallelPair f g).map right ≫
      (fun j =>
          match j with
          | zero => p
          | one => q)
        one =
    (fun j =>
          match j with
          | zero => p
          | one => q)
        zero ≫
      (parallelPair f' g').map right

Next tactic:
dsimp
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> {dsimp; 

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
⊢ g ≫ q = p ≫ g'

Next tactic:
simp [wf,wg]
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> 

Proof state:
case id
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
X✝ : WalkingParallelPair
⊢ (parallelPair f g).map (WalkingParallelPairHom.id X✝) ≫
      (fun j =>
          match j with
          | zero => p
          | one => q)
        X✝ =
    (fun j =>
          match j with
          | zero => p
          | one => q)
        X✝ ≫
      (parallelPair f' g').map (WalkingParallelPairHom.id X✝)

Next tactic:
{dsimp; simp [wf,wg]}
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> {

Proof state:
case id
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
X✝ : WalkingParallelPair
⊢ (parallelPair f g).map (WalkingParallelPairHom.id X✝) ≫
      (fun j =>
          match j with
          | zero => p
          | one => q)
        X✝ =
    (fun j =>
          match j with
          | zero => p
          | one => q)
        X✝ ≫
      (parallelPair f' g').map (WalkingParallelPairHom.id X✝)

Next tactic:
dsimp
/-- Construct a morphism between parallel pairs. -/
def parallelPairHom {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y')
    (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') : parallelPair f g ⟶ parallelPair f' g'
    where
  app j :=
    match j with
    | zero => p
    | one => q
  naturality := by
    rintro _ _ ⟨⟩ <;> {dsimp; 

Proof state:
case id
C : Type u
inst✝ : Category.{v, u} C
X Y X' Y' : C
f g : X ⟶ Y
f' g' : X' ⟶ Y'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
X✝ : WalkingParallelPair
⊢ ((parallelPair f g).map (𝟙 X✝) ≫
      match X✝ with
      | zero => p
      | one => q) =
    (match X✝ with
      | zero => p
      | one => q) ≫
      (parallelPair f' g').map (𝟙 X✝)

Next tactic:
simp [wf,wg]
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ (X : WalkingParallelPair) → F.obj X ≅ G.obj X

Next tactic:
rintro ⟨j⟩
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      rintro ⟨j⟩
      

Proof state:
case zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one

Next tactic:
exacts [zero, one]
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      rintro ⟨j⟩
      exacts [zero, one])
    (by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    F.map f ≫ (WalkingParallelPair.casesOn Y zero one).hom = (WalkingParallelPair.casesOn X zero one).hom ≫ G.map f

Next tactic:
rintro _ _ ⟨_⟩
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      rintro ⟨j⟩
      exacts [zero, one])
    (by rintro _ _ ⟨_⟩ <;> 

Proof state:
case left
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫
      (WalkingParallelPair.casesOn CategoryTheory.Limits.WalkingParallelPair.one zero one).hom =
    (WalkingParallelPair.casesOn CategoryTheory.Limits.WalkingParallelPair.zero zero one).hom ≫
      G.map CategoryTheory.Limits.WalkingParallelPairHom.left

Next tactic:
simp [left, right]
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      rintro ⟨j⟩
      exacts [zero, one])
    (by rintro _ _ ⟨_⟩ <;> 

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
⊢ F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫
      (WalkingParallelPair.casesOn CategoryTheory.Limits.WalkingParallelPair.one zero one).hom =
    (WalkingParallelPair.casesOn CategoryTheory.Limits.WalkingParallelPair.zero zero one).hom ≫
      G.map CategoryTheory.Limits.WalkingParallelPairHom.right

Next tactic:
simp [left, right]
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G :=
  NatIso.ofComponents
    (by
      rintro ⟨j⟩
      exacts [zero, one])
    (by rintro _ _ ⟨_⟩ <;> 

Proof state:
case id
C : Type u
inst✝ : Category.{v, u} C
X Y : C
F G : WalkingParallelPair ⥤ C
zero : F.obj CategoryTheory.Limits.WalkingParallelPair.zero ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.zero
one : F.obj CategoryTheory.Limits.WalkingParallelPair.one ≅ G.obj CategoryTheory.Limits.WalkingParallelPair.one
left :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.left ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.left
right :
  F.map CategoryTheory.Limits.WalkingParallelPairHom.right ≫ one.hom =
    zero.hom ≫ G.map CategoryTheory.Limits.WalkingParallelPairHom.right
X✝ : WalkingParallelPair
⊢ F.map (WalkingParallelPairHom.id X✝) ≫ (WalkingParallelPair.casesOn X✝ zero one).hom =
    (WalkingParallelPair.casesOn X✝ zero one).hom ≫ G.map (WalkingParallelPairHom.id X✝)

Next tactic:
simp [left, right]
/-- Construct a natural isomorphism between `parallelPair f g` and `parallelPair f' g'` given
equalities `f = f'` and `g = g'`. -/
@[simps!]
def parallelPair.eqOfHomEq {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g') :
    parallelPair f g ≅ parallelPair f' g' :=
  parallelPair.ext (Iso.refl _) (Iso.refl _) (by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g f' g' : X ⟶ Y
hf : f = f'
hg : g = g'
⊢ (parallelPair f g).map left ≫ (Iso.refl ((parallelPair f g).obj one)).hom =
    (Iso.refl ((parallelPair f g).obj zero)).hom ≫ (parallelPair f' g').map left

Next tactic:
simp [hf]
/-- Construct a natural isomorphism between `parallelPair f g` and `parallelPair f' g'` given
equalities `f = f'` and `g = g'`. -/
@[simps!]
def parallelPair.eqOfHomEq {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g') :
    parallelPair f g ≅ parallelPair f' g' :=
  parallelPair.ext (Iso.refl _) (Iso.refl _) (by simp [hf]) (by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g f' g' : X ⟶ Y
hf : f = f'
hg : g = g'
⊢ (parallelPair f g).map right ≫ (Iso.refl ((parallelPair f g).obj one)).hom =
    (Iso.refl ((parallelPair f g).obj zero)).hom ≫ (parallelPair f' g').map right

Next tactic:
simp [hg]
@[simp]
theorem Fork.app_one_eq_ι_comp_left (s : Fork f g) : s.π.app one = s.ι ≫ f := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Fork f g
⊢ s.π.app one = ι s ≫ f

Next tactic:
rw [← s.app_zero_eq_ι, ← s.w left, parallelPair_map_left]
@[reassoc]
theorem Fork.app_one_eq_ι_comp_right (s : Fork f g) : s.π.app one = s.ι ≫ g := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Fork f g
⊢ s.π.app one = ι s ≫ g

Next tactic:
rw [← s.app_zero_eq_ι, ← s.w right, parallelPair_map_right]
@[simp]
theorem Cofork.app_zero_eq_comp_π_left (s : Cofork f g) : s.ι.app zero = f ≫ s.π := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Cofork f g
⊢ s.ι.app zero = f ≫ π s

Next tactic:
rw [← s.app_one_eq_π, ← s.w left, parallelPair_map_left]
@[reassoc]
theorem Cofork.app_zero_eq_comp_π_right (s : Cofork f g) : s.ι.app zero = g ≫ s.π := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Cofork f g
⊢ s.ι.app zero = g ≫ π s

Next tactic:
rw [← s.app_one_eq_π, ← s.w right, parallelPair_map_right]
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f g : X✝ ⟶ Y
P : C
ι : P ⟶ X✝
w : ι ≫ f = ι ≫ g
X : WalkingParallelPair
⊢ ((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f g).obj X

Next tactic:
cases X
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; 

Proof state:
case zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj zero ⟶ (parallelPair f g).obj zero
case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj one ⟶ (parallelPair f g).obj one

Next tactic:
exact ι
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; 

Proof state:
case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj one ⟶ (parallelPair f g).obj one

Next tactic:
exact ι ≫ f
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
f✝ g : X✝ ⟶ Y✝
P : C
ι : P ⟶ X✝
w : ι ≫ f✝ = ι ≫ g
X Y : WalkingParallelPair
f : X ⟶ Y
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X
            (fun h => (_ : zero = X) ▸ ι) (fun h => (_ : one = X) ▸ ι ≫ f✝) (_ : X = X))
        Y =
    (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X
            (fun h => (_ : zero = X) ▸ ι) (fun h => (_ : one = X) ▸ ι ≫ f✝) (_ : X = X))
        X ≫
      (parallelPair f✝ g).map f

Next tactic:
cases X
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by cases X <;> 

Proof state:
case zero
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
f✝ g : X ⟶ Y✝
P : C
ι : P ⟶ X
w : ι ≫ f✝ = ι ≫ g
Y : WalkingParallelPair
f : zero ⟶ Y
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        Y =
    (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        zero ≫
      (parallelPair f✝ g).map f

Next tactic:
cases Y
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by cases X <;> 

Proof state:
case one
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
f✝ g : X ⟶ Y✝
P : C
ι : P ⟶ X
w : ι ≫ f✝ = ι ≫ g
Y : WalkingParallelPair
f : one ⟶ Y
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        Y =
    (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        one ≫
      (parallelPair f✝ g).map f

Next tactic:
cases Y
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by cases X <;> cases Y <;> 

Proof state:
case zero.zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f✝ = ι ≫ g
f : zero ⟶ zero
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        zero =
    (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        zero ≫
      (parallelPair f✝ g).map f

Next tactic:
cases f
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by cases X <;> cases Y <;> 

Proof state:
case zero.one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f✝ = ι ≫ g
f : zero ⟶ one
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        one =
    (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        zero ≫
      (parallelPair f✝ g).map f

Next tactic:
cases f
/-- A fork on `f g : X ⟶ Y` is determined by the morphism `ι : P ⟶ X` satisfying `ι ≫ f = ι ≫ g`.
-/
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g where
  pt := P
  π :=
    { app := fun X => by cases X; exact ι; exact ι ≫ f
      naturality := fun {X} {Y} f =>
        by cases X <;> cases Y <;> 

Proof state:
case one.zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f✝ = ι ≫ g
f : one ⟶ zero
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        zero =
    (fun X_1 =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X_1 = t → (((Functor.const WalkingParallelPair).obj P).obj X_1 ⟶ (parallelPair f✝ g).obj X_1)) X_1
            (fun h => (_ : zero = X_1) ▸ ι) (fun h => (_ : one = X_1) ▸ ι ≫ f✝) (_ : X_1 = X_1))
        one ≫
      (parallelPair f✝ g).map f

Next tactic:
cases f