ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.parallelPair.ext_hom_app
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor CategoryTheory.Limits.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 :
  CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingParallelPairHom.left) one.hom =
    CategoryTheory.CategoryStruct.comp zero.hom (G.map CategoryTheory.Limits.WalkingParallelPairHom.left)) (right :
  CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingParallelPairHom.right) one.hom =
    CategoryTheory.CategoryStruct.comp zero.hom (G.map CategoryTheory.Limits.WalkingParallelPairHom.right)) (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.parallelPair.ext zero one left right).hom.app X =
  (CategoryTheory.Limits.WalkingParallelPair.rec zero one X).hom
-- CategoryTheory.Limits.parallelPair.ext_inv_app
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor CategoryTheory.Limits.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 :
  CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingParallelPairHom.left) one.hom =
    CategoryTheory.CategoryStruct.comp zero.hom (G.map CategoryTheory.Limits.WalkingParallelPairHom.left)) (right :
  CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.Limits.WalkingParallelPairHom.right) one.hom =
    CategoryTheory.CategoryStruct.comp zero.hom (G.map CategoryTheory.Limits.WalkingParallelPairHom.right)) (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.parallelPair.ext zero one left right).inv.app X =
  (CategoryTheory.Limits.WalkingParallelPair.rec zero one X).inv
-- CategoryTheory.Limits.parallelPair.eqOfHomEq_hom_app
@[simps!]
def parallelPair.eqOfHomEq {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g') :
    parallelPair f g ≅ parallelPair f' g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g')
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.parallelPair.eqOfHomEq hf hg).hom.app X_1 =
    (CategoryTheory.Limits.WalkingParallelPair.rec (CategoryTheory.Iso.refl X) (CategoryTheory.Iso.refl Y) X_1).hom
-- CategoryTheory.Limits.parallelPair.eqOfHomEq_inv_app
@[simps!]
def parallelPair.eqOfHomEq {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g') :
    parallelPair f g ≅ parallelPair f' g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g f' g' : X ⟶ Y} (hf : f = f') (hg : g = g')
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.parallelPair.eqOfHomEq hf hg).inv.app X_1 =
    (CategoryTheory.Limits.WalkingParallelPair.rec (CategoryTheory.Iso.refl X) (CategoryTheory.Iso.refl Y) X_1).inv
-- CategoryTheory.Limits.Fork.app_zero_eq_ι
@[simp]
theorem Fork.app_zero_eq_ι (t : Fork f g) : t.π.app zero = t.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Fork f g)
Goal: t.π.app CategoryTheory.Limits.WalkingParallelPair.zero = t.ι
-- CategoryTheory.Limits.Cofork.app_one_eq_π
@[simp]
theorem Cofork.app_one_eq_π (t : Cofork f g) : t.ι.app one = t.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g)
Goal: t.ι.app CategoryTheory.Limits.WalkingParallelPair.one = t.π
-- CategoryTheory.Limits.Fork.app_one_eq_ι_comp_left
@[simp]
theorem Fork.app_one_eq_ι_comp_left (s : Fork f g) : s.π.app one = s.ι ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Fork f g)
Goal: s.π.app CategoryTheory.Limits.WalkingParallelPair.one = CategoryTheory.CategoryStruct.comp s.ι f
-- CategoryTheory.Limits.Fork.app_one_eq_ι_comp_right
@[reassoc]
theorem Fork.app_one_eq_ι_comp_right (s : Fork f g) : s.π.app one = s.ι ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Fork f g)
Goal: s.π.app CategoryTheory.Limits.WalkingParallelPair.one = CategoryTheory.CategoryStruct.comp s.ι g
-- CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_left
@[simp]
theorem Cofork.app_zero_eq_comp_π_left (s : Cofork f g) : s.ι.app zero = f ≫ s.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Cofork f g)
Goal: s.ι.app CategoryTheory.Limits.WalkingParallelPair.zero = CategoryTheory.CategoryStruct.comp f s.π
-- CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_right
@[reassoc]
theorem Cofork.app_zero_eq_comp_π_right (s : Cofork f g) : s.ι.app zero = g ≫ s.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Cofork f g)
Goal: s.ι.app CategoryTheory.Limits.WalkingParallelPair.zero = CategoryTheory.CategoryStruct.comp g s.π
-- CategoryTheory.Limits.Fork.ofι_π_app
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (ι : P ⟶ X) (w : CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.Fork.ofι ι w).π.app X_1 =
    CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
      X_1 = t →
        (((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj P).obj X_1 ⟶
          (CategoryTheory.Limits.parallelPair f g).obj X_1))
      X_1 (fun h => ⋯ ▸ ι) (fun h => ⋯ ▸ CategoryTheory.CategoryStruct.comp ι f) ⋯
-- CategoryTheory.Limits.Fork.ofι_pt
@[simps]
def Fork.ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : Fork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (ι : P ⟶ X) (w : CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g)
Goal: (CategoryTheory.Limits.Fork.ofι ι w).pt = P
-- CategoryTheory.Limits.Cofork.ofπ_pt
@[simps]
def Cofork.ofπ {P : C} (π : Y ⟶ P) (w : f ≫ π = g ≫ π) : Cofork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (π : Y ⟶ P) (w : CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π)
Goal: (CategoryTheory.Limits.Cofork.ofπ π w).pt = P
-- CategoryTheory.Limits.Cofork.ofπ_ι_app
@[simps]
def Cofork.ofπ {P : C} (π : Y ⟶ P) (w : f ≫ π = g ≫ π) : Cofork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (π : Y ⟶ P) (w : CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.Cofork.ofπ π w).ι.app X_1 =
    CategoryTheory.Limits.WalkingParallelPair.casesOn X_1 (CategoryTheory.CategoryStruct.comp f π) π
-- CategoryTheory.Limits.Fork.ι_ofι
@[simp]
theorem Fork.ι_ofι {P : C} (ι : P ⟶ X) (w : ι ≫ f = ι ≫ g) : (Fork.ofι ι w).ι = ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (ι : P ⟶ X) (w : CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g)
Goal: (CategoryTheory.Limits.Fork.ofι ι w).ι = ι
-- CategoryTheory.Limits.Cofork.π_ofπ
@[simp]
theorem Cofork.π_ofπ {P : C} (π : Y ⟶ P) (w : f ≫ π = g ≫ π) : (Cofork.ofπ π w).π = π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {P : C} (π : Y ⟶ P) (w : CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π)
Goal: (CategoryTheory.Limits.Cofork.ofπ π w).π = π
-- CategoryTheory.Limits.Fork.condition
@[reassoc (attr := simp)]
theorem Fork.condition (t : Fork f g) : t.ι ≫ f = t.ι ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Fork f g)
Goal: CategoryTheory.CategoryStruct.comp t.ι f = CategoryTheory.CategoryStruct.comp t.ι g
-- CategoryTheory.Limits.Cofork.condition
@[reassoc (attr := simp)]
theorem Cofork.condition (t : Cofork f g) : f ≫ t.π = g ≫ t.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g)
Goal: CategoryTheory.CategoryStruct.comp f t.π = CategoryTheory.CategoryStruct.comp g t.π
-- CategoryTheory.Limits.Fork.equalizer_ext
theorem Fork.equalizer_ext (s : Fork f g) {W : C} {k l : W ⟶ s.pt} (h : k ≫ s.ι = l ≫ s.ι) :
    ∀ j : WalkingParallelPair, k ≫ s.π.app j = l ≫ s.π.app j
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Fork f g) {W : C} {k l : W ⟶ s.pt} (h : CategoryTheory.CategoryStruct.comp k s.ι = CategoryTheory.CategoryStruct.comp l s.ι) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.CategoryStruct.comp k (s.π.app j) = CategoryTheory.CategoryStruct.comp l (s.π.app j)
-- CategoryTheory.Limits.Cofork.coequalizer_ext
theorem Cofork.coequalizer_ext (s : Cofork f g) {W : C} {k l : s.pt ⟶ W}
    (h : Cofork.π s ≫ k = Cofork.π s ≫ l) : ∀ j : WalkingParallelPair, s.ι.app j ≫ k = s.ι.app j ≫ l
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Cofork f g) {W : C} {k l : s.pt ⟶ W} (h : CategoryTheory.CategoryStruct.comp s.π k = CategoryTheory.CategoryStruct.comp s.π l) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.CategoryStruct.comp (s.ι.app j) k = CategoryTheory.CategoryStruct.comp (s.ι.app j) l
-- CategoryTheory.Limits.Fork.IsLimit.hom_ext
theorem Fork.IsLimit.hom_ext {s : Fork f g} (hs : IsLimit s) {W : C} {k l : W ⟶ s.pt}
    (h : k ≫ Fork.ι s = l ≫ Fork.ι s) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Fork f g} (hs : CategoryTheory.Limits.IsLimit s) {W : C} {k l : W ⟶ s.pt} (h : CategoryTheory.CategoryStruct.comp k s.ι = CategoryTheory.CategoryStruct.comp l s.ι)
Goal: k = l
-- CategoryTheory.Limits.Cofork.IsColimit.hom_ext
theorem Cofork.IsColimit.hom_ext {s : Cofork f g} (hs : IsColimit s) {W : C} {k l : s.pt ⟶ W}
    (h : Cofork.π s ≫ k = Cofork.π s ≫ l) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s) {W : C} {k l : s.pt ⟶ W} (h : CategoryTheory.CategoryStruct.comp s.π k = CategoryTheory.CategoryStruct.comp s.π l)
Goal: k = l
-- CategoryTheory.Limits.Fork.IsLimit.lift_ι
@[reassoc (attr := simp)]
theorem Fork.IsLimit.lift_ι {s t : Fork f g} (hs : IsLimit s) : hs.lift t ≫ s.ι = t.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Fork f g} (hs : CategoryTheory.Limits.IsLimit s)
Goal: CategoryTheory.CategoryStruct.comp (hs.lift t) s.ι = t.ι
-- CategoryTheory.Limits.Cofork.IsColimit.π_desc
@[reassoc (attr := simp)]
theorem Cofork.IsColimit.π_desc {s t : Cofork f g} (hs : IsColimit s) : s.π ≫ hs.desc t = t.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s)
Goal: CategoryTheory.CategoryStruct.comp s.π (hs.desc t) = t.π
-- CategoryTheory.Limits.Fork.IsLimit.lift_ι'
@[reassoc (attr := simp)]
lemma Fork.IsLimit.lift_ι' {s : Fork f g} (hs : IsLimit s) {W : C} (k : W ⟶ X) (h : k ≫ f = k ≫ g) :
    Fork.IsLimit.lift hs k h ≫ Fork.ι s = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Fork f g} (hs : CategoryTheory.Limits.IsLimit s) {W : C} (k : W ⟶ X) (h : CategoryTheory.CategoryStruct.comp k f = CategoryTheory.CategoryStruct.comp k g)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.IsLimit.lift hs k h) s.ι = k
-- CategoryTheory.Limits.Cofork.IsColimit.π_desc'
@[reassoc (attr := simp)]
lemma Cofork.IsColimit.π_desc' {s : Cofork f g} (hs : IsColimit s) {W : C} (k : Y ⟶ W)
    (h : f ≫ k = g ≫ k) : Cofork.π s ≫ Cofork.IsColimit.desc hs k h = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s) {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k)
Goal: CategoryTheory.CategoryStruct.comp s.π (CategoryTheory.Limits.Cofork.IsColimit.desc hs k h) = k
-- CategoryTheory.Limits.Fork.IsLimit.existsUnique
theorem Fork.IsLimit.existsUnique {s : Fork f g} (hs : IsLimit s) {W : C} (k : W ⟶ X)
    (h : k ≫ f = k ≫ g) : ∃! l : W ⟶ s.pt, l ≫ Fork.ι s = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Fork f g} (hs : CategoryTheory.Limits.IsLimit s) {W : C} (k : W ⟶ X) (h : CategoryTheory.CategoryStruct.comp k f = CategoryTheory.CategoryStruct.comp k g)
Goal: ∃! l, CategoryTheory.CategoryStruct.comp l s.ι = k
-- CategoryTheory.Limits.Cofork.IsColimit.existsUnique
theorem Cofork.IsColimit.existsUnique {s : Cofork f g} (hs : IsColimit s) {W : C} (k : Y ⟶ W)
    (h : f ≫ k = g ≫ k) : ∃! d : s.pt ⟶ W, Cofork.π s ≫ d = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s) {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k)
Goal: ∃! d, CategoryTheory.CategoryStruct.comp s.π d = k
-- CategoryTheory.Limits.Fork.IsLimit.mk_lift
@[simps]
def Fork.IsLimit.mk (t : Fork f g) (lift : ∀ s : Fork f g, s.pt ⟶ t.pt)
    (fac : ∀ s : Fork f g, lift s ≫ Fork.ι t = Fork.ι s)
    (uniq : ∀ (s : Fork f g) (m : s.pt ⟶ t.pt) (_ : m ≫ t.ι = s.ι), m = lift s) : IsLimit t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt) (fac : ∀ (s : CategoryTheory.Limits.Fork f g), CategoryTheory.CategoryStruct.comp (lift s) t.ι = s.ι) (uniq :
  ∀ (s : CategoryTheory.Limits.Fork f g) (m : s.pt ⟶ t.pt), CategoryTheory.CategoryStruct.comp m t.ι = s.ι → m = lift s) (s : CategoryTheory.Limits.Fork f g)
Goal: (CategoryTheory.Limits.Fork.IsLimit.mk t lift fac uniq).lift s = lift s
-- CategoryTheory.Limits.Fork.IsLimit.homIso_symm_apply
@[simps]
def Fork.IsLimit.homIso {X Y : C} {f g : X ⟶ Y} {t : Fork f g} (ht : IsLimit t) (Z : C) :
    (Z ⟶ t.pt) ≃ { h : Z ⟶ X // h ≫ f = h ≫ g } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (h : { h // CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g })
Goal: (CategoryTheory.Limits.Fork.IsLimit.homIso ht Z).symm h = ↑(CategoryTheory.Limits.Fork.IsLimit.lift' ht ↑h ⋯)
-- CategoryTheory.Limits.Fork.IsLimit.homIso_apply_coe
@[simps]
def Fork.IsLimit.homIso {X Y : C} {f g : X ⟶ Y} {t : Fork f g} (ht : IsLimit t) (Z : C) :
    (Z ⟶ t.pt) ≃ { h : Z ⟶ X // h ≫ f = h ≫ g } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (k : Z ⟶ t.pt)
Goal: ↑((CategoryTheory.Limits.Fork.IsLimit.homIso ht Z) k) = CategoryTheory.CategoryStruct.comp k t.ι
-- CategoryTheory.Limits.Fork.IsLimit.homIso_natural
theorem Fork.IsLimit.homIso_natural {X Y : C} {f g : X ⟶ Y} {t : Fork f g} (ht : IsLimit t)
    {Z Z' : C} (q : Z' ⟶ Z) (k : Z ⟶ t.pt) :
    (Fork.IsLimit.homIso ht _ (q ≫ k) : Z' ⟶ X) = q ≫ (Fork.IsLimit.homIso ht _ k : Z ⟶ X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) {Z Z' : C} (q : Z' ⟶ Z) (k : Z ⟶ t.pt)
Goal: ↑((CategoryTheory.Limits.Fork.IsLimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp q k)) =
  CategoryTheory.CategoryStruct.comp q ↑((CategoryTheory.Limits.Fork.IsLimit.homIso ht Z) k)
-- CategoryTheory.Limits.Cofork.IsColimit.homIso_apply_coe
@[simps]
def Cofork.IsColimit.homIso {X Y : C} {f g : X ⟶ Y} {t : Cofork f g} (ht : IsColimit t) (Z : C) :
    (t.pt ⟶ Z) ≃ { h : Y ⟶ Z // f ≫ h = g ≫ h } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g} (ht : CategoryTheory.Limits.IsColimit t) (Z : C) (k : t.pt ⟶ Z)
Goal: ↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z) k) = CategoryTheory.CategoryStruct.comp t.π k
-- CategoryTheory.Limits.Cofork.IsColimit.homIso_symm_apply
@[simps]
def Cofork.IsColimit.homIso {X Y : C} {f g : X ⟶ Y} {t : Cofork f g} (ht : IsColimit t) (Z : C) :
    (t.pt ⟶ Z) ≃ { h : Y ⟶ Z // f ≫ h = g ≫ h } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g} (ht : CategoryTheory.Limits.IsColimit t) (Z : C) (h : { h // CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h })
Goal: (CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z).symm h = ↑(CategoryTheory.Limits.Cofork.IsColimit.desc' ht ↑h ⋯)
-- CategoryTheory.Limits.Cofork.IsColimit.homIso_natural
theorem Cofork.IsColimit.homIso_natural {X Y : C} {f g : X ⟶ Y} {t : Cofork f g} {Z Z' : C}
    (q : Z ⟶ Z') (ht : IsColimit t) (k : t.pt ⟶ Z) :
    (Cofork.IsColimit.homIso ht _ (k ≫ q) : Y ⟶ Z') =
      (Cofork.IsColimit.homIso ht _ k : Y ⟶ Z) ≫ q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g} {Z Z' : C} (q : Z ⟶ Z') (ht : CategoryTheory.Limits.IsColimit t) (k : t.pt ⟶ Z)
Goal: ↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
  CategoryTheory.CategoryStruct.comp (↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z) k)) q
-- CategoryTheory.Limits.Cone.ofFork_π
@[simp]
theorem Cone.ofFork_π {F : WalkingParallelPair ⥤ C} (t : Fork (F.map left) (F.map right)) (j) :
    (Cone.ofFork t).π.app j = t.π.app j ≫ eqToHom (by aesop) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (t :
  CategoryTheory.Limits.Fork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
    (F.map CategoryTheory.Limits.WalkingParallelPairHom.right)) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.Cone.ofFork t).π.app j =
  CategoryTheory.CategoryStruct.comp (t.π.app j) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.Limits.Cocone.ofCofork_ι
@[simp]
theorem Cocone.ofCofork_ι {F : WalkingParallelPair ⥤ C} (t : Cofork (F.map left) (F.map right))
    (j) : (Cocone.ofCofork t).ι.app j = eqToHom (by aesop) ≫ t.ι.app j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (t :
  CategoryTheory.Limits.Cofork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
    (F.map CategoryTheory.Limits.WalkingParallelPairHom.right)) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.Cocone.ofCofork t).ι.app j =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (t.ι.app j)
-- CategoryTheory.Limits.Fork.ofCone_π
@[simp]
theorem Fork.ofCone_π {F : WalkingParallelPair ⥤ C} (t : Cone F) (j) :
    (Fork.ofCone t).π.app j = t.π.app j ≫ eqToHom (by aesop) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (t : CategoryTheory.Limits.Cone F) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.Fork.ofCone t).π.app j =
  CategoryTheory.CategoryStruct.comp (t.π.app j) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.Limits.Cofork.ofCocone_ι
@[simp]
theorem Cofork.ofCocone_ι {F : WalkingParallelPair ⥤ C} (t : Cocone F) (j) :
    (Cofork.ofCocone t).ι.app j = eqToHom (by aesop) ≫ t.ι.app j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (t : CategoryTheory.Limits.Cocone F) (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.Cofork.ofCocone t).ι.app j =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (t.ι.app j)
-- CategoryTheory.Limits.Fork.ι_postcompose
@[simp]
theorem Fork.ι_postcompose {f' g' : X ⟶ Y} {α : parallelPair f g ⟶ parallelPair f' g'}
    {c : Fork f g} : Fork.ι ((Cones.postcompose α).obj c) = c.ι ≫ α.app _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g f' g' : X ⟶ Y} {α : CategoryTheory.Limits.parallelPair f g ⟶ CategoryTheory.Limits.parallelPair f' g'} {c : CategoryTheory.Limits.Fork f g}
Goal: CategoryTheory.Limits.Fork.ι ((CategoryTheory.Limits.Cones.postcompose α).obj c) =
  CategoryTheory.CategoryStruct.comp c.ι (α.app CategoryTheory.Limits.WalkingParallelPair.zero)
-- CategoryTheory.Limits.Cofork.π_precompose
@[simp]
theorem Cofork.π_precompose {f' g' : X ⟶ Y} {α : parallelPair f g ⟶ parallelPair f' g'}
    {c : Cofork f' g'} : Cofork.π ((Cocones.precompose α).obj c) = α.app _ ≫ c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g f' g' : X ⟶ Y} {α : CategoryTheory.Limits.parallelPair f g ⟶ CategoryTheory.Limits.parallelPair f' g'} {c : CategoryTheory.Limits.Cofork f' g'}
Goal: CategoryTheory.Limits.Cofork.π ((CategoryTheory.Limits.Cocones.precompose α).obj c) =
  CategoryTheory.CategoryStruct.comp (α.app CategoryTheory.Limits.WalkingParallelPair.one) c.π
-- CategoryTheory.Limits.Fork.mkHom_hom
@[simps]
def Fork.mkHom {s t : Fork f g} (k : s.pt ⟶ t.pt) (w : k ≫ t.ι = s.ι) : s ⟶ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Fork f g} (k : s.pt ⟶ t.pt) (w : CategoryTheory.CategoryStruct.comp k t.ι = s.ι)
Goal: (CategoryTheory.Limits.Fork.mkHom k w).hom = k
-- CategoryTheory.Limits.Fork.ext_inv
@[simps]
def Fork.ext {s t : Fork f g} (i : s.pt ≅ t.pt) (w : i.hom ≫ t.ι = s.ι := by aesop_cat) :
    s ≅ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Fork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp i.hom t.ι = s.ι := by aesop_cat)
Goal: (CategoryTheory.Limits.Fork.ext i w).inv = CategoryTheory.Limits.Fork.mkHom i.inv ⋯
-- CategoryTheory.Limits.Fork.ext_hom
@[simps]
def Fork.ext {s t : Fork f g} (i : s.pt ≅ t.pt) (w : i.hom ≫ t.ι = s.ι := by aesop_cat) :
    s ≅ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Fork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp i.hom t.ι = s.ι := by aesop_cat)
Goal: (CategoryTheory.Limits.Fork.ext i w).hom = CategoryTheory.Limits.Fork.mkHom i.hom w
-- CategoryTheory.Limits.Cofork.mkHom_hom
@[simps]
def Cofork.mkHom {s t : Cofork f g} (k : s.pt ⟶ t.pt) (w : s.π ≫ k = t.π) : s ⟶ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Cofork f g} (k : s.pt ⟶ t.pt) (w : CategoryTheory.CategoryStruct.comp s.π k = t.π)
Goal: (CategoryTheory.Limits.Cofork.mkHom k w).hom = k
-- CategoryTheory.Limits.Fork.hom_comp_ι
@[reassoc (attr := simp)]
theorem Fork.hom_comp_ι {s t : Fork f g} (f : s ⟶ t) : f.hom ≫ t.ι = s.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Fork f g}
Goal: ∀ (f_1 : s ⟶ t), CategoryTheory.CategoryStruct.comp f_1.hom t.ι = s.ι