ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.pullback_symmetry_hom_of_epi_eq
@[simp]
theorem pullback_symmetry_hom_of_epi_eq [Epi f] : (pushoutSymmetry f f).hom = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: (CategoryTheory.Limits.pushoutSymmetry f f).hom = 𝟙 (CategoryTheory.Limits.pushout f f)
-- CategoryTheory.Limits.WalkingParallelFamily.hom_id
@[simp]
theorem WalkingParallelFamily.hom_id (X : WalkingParallelFamily J) :
    WalkingParallelFamily.Hom.id X = 𝟙 X 
Arguments: {J : Type w} (X : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: CategoryTheory.Limits.WalkingParallelFamily.Hom.id X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.parallelFamily_obj_zero
@[simp]
theorem parallelFamily_obj_zero : (parallelFamily f).obj zero = X 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y))
Goal: (CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.zero = X
-- CategoryTheory.Limits.parallelFamily_obj_one
@[simp]
theorem parallelFamily_obj_one : (parallelFamily f).obj one = Y 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y))
Goal: (CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.one = Y
-- CategoryTheory.Limits.parallelFamily_map_left
@[simp]
theorem parallelFamily_map_left {j : J} : (parallelFamily f).map (line j) = f j 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) {j : J}
Goal: (CategoryTheory.Limits.parallelFamily f).map (CategoryTheory.Limits.WalkingParallelFamily.Hom.line j) = f j
-- CategoryTheory.Limits.diagramIsoParallelFamily_inv_app
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C) (X : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.diagramIsoParallelFamily F).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.diagramIsoParallelFamily_hom_app
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J ⥤ C) :
    F ≅ parallelFamily fun j => F.map (line j) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C) (X : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.diagramIsoParallelFamily F).hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_counitIso_hom_app
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.counitIso.hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_functor_map
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: {x y : CategoryTheory.Limits.WalkingParallelFamily (ULift.{w, 0} Bool)} (h : x ⟶ y)
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.functor.map h =
  match x, y, h with
  | x, .(x), CategoryTheory.Limits.WalkingParallelFamily.Hom.id .(x) =>
    CategoryTheory.CategoryStruct.id
      (CategoryTheory.Limits.WalkingParallelFamily.rec CategoryTheory.Limits.WalkingParallelPair.zero
        CategoryTheory.Limits.WalkingParallelPair.one x)
  | .(CategoryTheory.Limits.WalkingParallelFamily.zero), .(CategoryTheory.Limits.WalkingParallelFamily.one),
    CategoryTheory.Limits.WalkingParallelFamily.Hom.line j =>
    bif j.down then CategoryTheory.Limits.WalkingParallelPairHom.left
    else CategoryTheory.Limits.WalkingParallelPairHom.right
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_counitIso_inv_app
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.counitIso.inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_unitIso_inv_app
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (X : CategoryTheory.Limits.WalkingParallelFamily (ULift.{w, 0} Bool))
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.unitIso.inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_inverse_obj
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (x : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.inverse.obj x =
  match x with
  | CategoryTheory.Limits.WalkingParallelPair.zero => CategoryTheory.Limits.WalkingParallelFamily.zero
  | CategoryTheory.Limits.WalkingParallelPair.one => CategoryTheory.Limits.WalkingParallelFamily.one
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_unitIso_hom_app
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (X : CategoryTheory.Limits.WalkingParallelFamily (ULift.{w, 0} Bool))
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.unitIso.hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_functor_obj
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Arguments: (x : CategoryTheory.Limits.WalkingParallelFamily (ULift.{w, 0} Bool))
Goal: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.functor.obj x =
  CategoryTheory.Limits.WalkingParallelFamily.rec CategoryTheory.Limits.WalkingParallelPair.zero
    CategoryTheory.Limits.WalkingParallelPair.one x
-- CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_inverse_map
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
    WalkingParallelFamily.{w} (ULift Bool) ≌ WalkingParallelPair 
Goal: ∀ {X Y : CategoryTheory.Limits.WalkingParallelPair} (h : X ⟶ Y),
  CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair.inverse.map h =
    match X, Y, h with
    | x, .(x), CategoryTheory.Limits.WalkingParallelPairHom.id .(x) =>
      CategoryTheory.CategoryStruct.id
        (match x with
        | CategoryTheory.Limits.WalkingParallelPair.zero => CategoryTheory.Limits.WalkingParallelFamily.zero
        | CategoryTheory.Limits.WalkingParallelPair.one => CategoryTheory.Limits.WalkingParallelFamily.one)
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.left =>
      CategoryTheory.Limits.WalkingParallelFamily.Hom.line { down := true }
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.right =>
      CategoryTheory.Limits.WalkingParallelFamily.Hom.line { down := false }
-- CategoryTheory.Limits.Trident.ι_eq_app_zero
@[simp]
theorem Trident.ι_eq_app_zero (t : Trident f) : t.ι = t.π.app zero 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (t : CategoryTheory.Limits.Trident f)
Goal: t.ι = t.π.app CategoryTheory.Limits.WalkingParallelFamily.zero
-- CategoryTheory.Limits.Cotrident.π_eq_app_one
@[simp]
theorem Cotrident.π_eq_app_one (t : Cotrident f) : t.π = t.ι.app one 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (t : CategoryTheory.Limits.Cotrident f)
Goal: t.π = t.ι.app CategoryTheory.Limits.WalkingParallelFamily.one
-- CategoryTheory.Limits.Trident.app_zero
@[reassoc (attr := simp)]
theorem Trident.app_zero (s : Trident f) (j : J) : s.π.app zero ≫ f j = s.π.app one 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (s : CategoryTheory.Limits.Trident f) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (s.π.app CategoryTheory.Limits.WalkingParallelFamily.zero) (f j) =
  s.π.app CategoryTheory.Limits.WalkingParallelFamily.one
-- CategoryTheory.Limits.Cotrident.app_one
@[reassoc (attr := simp)]
theorem Cotrident.app_one (s : Cotrident f) (j : J) : f j ≫ s.ι.app one = s.ι.app zero 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (s : CategoryTheory.Limits.Cotrident f) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (f j) (s.ι.app CategoryTheory.Limits.WalkingParallelFamily.one) =
  s.ι.app CategoryTheory.Limits.WalkingParallelFamily.zero
-- CategoryTheory.Limits.Trident.ofι_π_app
@[simps]
def Trident.ofι [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂) :
    Trident f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂))
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelFamily J),
  (CategoryTheory.Limits.Trident.ofι ι w).π.app X_1 =
    CategoryTheory.Limits.WalkingParallelFamily.casesOn X_1 ι
      (CategoryTheory.CategoryStruct.comp ι (f (Classical.arbitrary J)))
-- CategoryTheory.Limits.Trident.ofι_pt
@[simps]
def Trident.ofι [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂) :
    Trident f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂))
Goal: (CategoryTheory.Limits.Trident.ofι ι w).pt = P
-- CategoryTheory.Limits.Cotrident.ofπ_pt
@[simps]
def Cotrident.ofπ [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ j₁ j₂, f j₁ ≫ π = f j₂ ≫ π) :
    Cotrident f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp (f j₁) π = CategoryTheory.CategoryStruct.comp (f j₂) π)
Goal: (CategoryTheory.Limits.Cotrident.ofπ π w).pt = P
-- CategoryTheory.Limits.Cotrident.ofπ_ι_app
@[simps]
def Cotrident.ofπ [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ j₁ j₂, f j₁ ≫ π = f j₂ ≫ π) :
    Cotrident f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp (f j₁) π = CategoryTheory.CategoryStruct.comp (f j₂) π)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelFamily J),
  (CategoryTheory.Limits.Cotrident.ofπ π w).ι.app X_1 =
    CategoryTheory.Limits.WalkingParallelFamily.casesOn X_1
      (CategoryTheory.CategoryStruct.comp (f (Classical.arbitrary J)) π) π
-- CategoryTheory.Limits.Trident.ι_ofι
theorem Trident.ι_ofι [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂) :
    (Trident.ofι ι w).ι = ι 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂))
Goal: (CategoryTheory.Limits.Trident.ofι ι w).ι = ι
-- CategoryTheory.Limits.Cotrident.π_ofπ
theorem Cotrident.π_ofπ [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ j₁ j₂, f j₁ ≫ π = f j₂ ≫ π) :
    (Cotrident.ofπ π w).π = π 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {P : C} (π : Y ⟶ P) (w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp (f j₁) π = CategoryTheory.CategoryStruct.comp (f j₂) π)
Goal: (CategoryTheory.Limits.Cotrident.ofπ π w).π = π
-- CategoryTheory.Limits.Trident.condition
@[reassoc]
theorem Trident.condition (j₁ j₂ : J) (t : Trident f) : t.ι ≫ f j₁ = t.ι ≫ f j₂ 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (j₁ j₂ : J) (t : CategoryTheory.Limits.Trident f)
Goal: CategoryTheory.CategoryStruct.comp t.ι (f j₁) = CategoryTheory.CategoryStruct.comp t.ι (f j₂)
-- CategoryTheory.Limits.Cotrident.condition
@[reassoc]
theorem Cotrident.condition (j₁ j₂ : J) (t : Cotrident f) : f j₁ ≫ t.π = f j₂ ≫ t.π 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} (j₁ j₂ : J) (t : CategoryTheory.Limits.Cotrident f)
Goal: CategoryTheory.CategoryStruct.comp (f j₁) t.π = CategoryTheory.CategoryStruct.comp (f j₂) t.π
-- CategoryTheory.Limits.Trident.equalizer_ext
theorem Trident.equalizer_ext [Nonempty J] (s : Trident f) {W : C} {k l : W ⟶ s.pt}
    (h : k ≫ s.ι = l ≫ s.ι) : ∀ j : WalkingParallelFamily J, k ≫ s.π.app j = l ≫ s.π.app j
  
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] (s : CategoryTheory.Limits.Trident f) {W : C} {k l : W ⟶ s.pt} (h : CategoryTheory.CategoryStruct.comp k s.ι = CategoryTheory.CategoryStruct.comp l s.ι) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: CategoryTheory.CategoryStruct.comp k (s.π.app j) = CategoryTheory.CategoryStruct.comp l (s.π.app j)
-- CategoryTheory.Limits.Cotrident.coequalizer_ext
theorem Cotrident.coequalizer_ext [Nonempty J] (s : Cotrident f) {W : C} {k l : s.pt ⟶ W}
    (h : s.π ≫ k = s.π ≫ l) : ∀ j : WalkingParallelFamily J, s.ι.app j ≫ k = s.ι.app j ≫ l
  
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] (s : CategoryTheory.Limits.Cotrident f) {W : C} {k l : s.pt ⟶ W} (h : CategoryTheory.CategoryStruct.comp s.π k = CategoryTheory.CategoryStruct.comp s.π l) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: CategoryTheory.CategoryStruct.comp (s.ι.app j) k = CategoryTheory.CategoryStruct.comp (s.ι.app j) l
-- CategoryTheory.Limits.Trident.IsLimit.hom_ext
theorem Trident.IsLimit.hom_ext [Nonempty J] {s : Trident f} (hs : IsLimit s) {W : C}
    {k l : W ⟶ s.pt} (h : k ≫ s.ι = l ≫ s.ι) : k = l 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s : CategoryTheory.Limits.Trident f} (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.Cotrident.IsColimit.hom_ext
theorem Cotrident.IsColimit.hom_ext [Nonempty J] {s : Cotrident f} (hs : IsColimit s) {W : C}
    {k l : s.pt ⟶ W} (h : s.π ≫ k = s.π ≫ l) : k = l 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s : CategoryTheory.Limits.Cotrident f} (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.Trident.IsLimit.homIso_symm_apply
@[simps]
def Trident.IsLimit.homIso [Nonempty J] {t : Trident f} (ht : IsLimit t) (Z : C) :
    (Z ⟶ t.pt) ≃ { h : Z ⟶ X // ∀ j₁ j₂, h ≫ f j₁ = h ≫ f j₂ } 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (h : { h // ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp h (f j₁) = CategoryTheory.CategoryStruct.comp h (f j₂) })
Goal: (CategoryTheory.Limits.Trident.IsLimit.homIso ht Z).symm h = ↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑h ⋯)
-- CategoryTheory.Limits.Trident.IsLimit.homIso_apply_coe
@[simps]
def Trident.IsLimit.homIso [Nonempty J] {t : Trident f} (ht : IsLimit t) (Z : C) :
    (Z ⟶ t.pt) ≃ { h : Z ⟶ X // ∀ j₁ j₂, h ≫ f j₁ = h ≫ f j₂ } 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (k : Z ⟶ t.pt)
Goal: ↑((CategoryTheory.Limits.Trident.IsLimit.homIso ht Z) k) = CategoryTheory.CategoryStruct.comp k t.ι
-- CategoryTheory.Limits.Trident.IsLimit.homIso_natural
theorem Trident.IsLimit.homIso_natural [Nonempty J] {t : Trident f} (ht : IsLimit t) {Z Z' : C}
    (q : Z' ⟶ Z) (k : Z ⟶ t.pt) :
    (Trident.IsLimit.homIso ht _ (q ≫ k) : Z' ⟶ X) =
      q ≫ (Trident.IsLimit.homIso ht _ k : Z ⟶ X) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) {Z Z' : C} (q : Z' ⟶ Z) (k : Z ⟶ t.pt)
Goal: ↑((CategoryTheory.Limits.Trident.IsLimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp q k)) =
  CategoryTheory.CategoryStruct.comp q ↑((CategoryTheory.Limits.Trident.IsLimit.homIso ht Z) k)
-- CategoryTheory.Limits.Cotrident.IsColimit.homIso_apply_coe
@[simps]
def Cotrident.IsColimit.homIso [Nonempty J] {t : Cotrident f} (ht : IsColimit t) (Z : C) :
    (t.pt ⟶ Z) ≃ { h : Y ⟶ Z // ∀ j₁ j₂, f j₁ ≫ h = f j₂ ≫ h } 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Cotrident f} (ht : CategoryTheory.Limits.IsColimit t) (Z : C) (k : t.pt ⟶ Z)
Goal: ↑((CategoryTheory.Limits.Cotrident.IsColimit.homIso ht Z) k) = CategoryTheory.CategoryStruct.comp t.π k
-- CategoryTheory.Limits.Cotrident.IsColimit.homIso_symm_apply
@[simps]
def Cotrident.IsColimit.homIso [Nonempty J] {t : Cotrident f} (ht : IsColimit t) (Z : C) :
    (t.pt ⟶ Z) ≃ { h : Y ⟶ Z // ∀ j₁ j₂, f j₁ ≫ h = f j₂ ≫ h } 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Cotrident f} (ht : CategoryTheory.Limits.IsColimit t) (Z : C) (h : { h // ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp (f j₁) h = CategoryTheory.CategoryStruct.comp (f j₂) h })
Goal: (CategoryTheory.Limits.Cotrident.IsColimit.homIso ht Z).symm h =
  ↑(CategoryTheory.Limits.Cotrident.IsColimit.desc' ht ↑h ⋯)
-- CategoryTheory.Limits.Cotrident.IsColimit.homIso_natural
theorem Cotrident.IsColimit.homIso_natural [Nonempty J] {t : Cotrident f} {Z Z' : C} (q : Z ⟶ Z')
    (ht : IsColimit t) (k : t.pt ⟶ Z) :
    (Cotrident.IsColimit.homIso ht _ (k ≫ q) : Y ⟶ Z') =
      (Cotrident.IsColimit.homIso ht _ k : Y ⟶ Z) ≫ q 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {t : CategoryTheory.Limits.Cotrident f} {Z Z' : C} (q : Z ⟶ Z') (ht : CategoryTheory.Limits.IsColimit t) (k : t.pt ⟶ Z)
Goal: ↑((CategoryTheory.Limits.Cotrident.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
  CategoryTheory.CategoryStruct.comp (↑((CategoryTheory.Limits.Cotrident.IsColimit.homIso ht Z) k)) q
-- CategoryTheory.Limits.Cone.ofTrident_π
@[simp]
theorem Cone.ofTrident_π {F : WalkingParallelFamily J ⥤ C} (t : Trident fun j => F.map (line j))
    (j) : (Cone.ofTrident t).π.app j = t.π.app j ≫ eqToHom (by cases j <;> aesop_cat) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C} (t : CategoryTheory.Limits.Trident fun j => F.map (CategoryTheory.Limits.WalkingParallelFamily.Hom.line j)) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.Cone.ofTrident t).π.app j =
  CategoryTheory.CategoryStruct.comp (t.π.app j) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.Limits.Cocone.ofCotrident_ι
@[simp]
theorem Cocone.ofCotrident_ι {F : WalkingParallelFamily J ⥤ C}
    (t : Cotrident fun j => F.map (line j)) (j) :
    (Cocone.ofCotrident t).ι.app j = eqToHom (by cases j <;> aesop_cat) ≫ t.ι.app j 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C} (t : CategoryTheory.Limits.Cotrident fun j => F.map (CategoryTheory.Limits.WalkingParallelFamily.Hom.line j)) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.Cocone.ofCotrident t).ι.app j =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (t.ι.app j)
-- CategoryTheory.Limits.Trident.ofCone_π
@[simp]
theorem Trident.ofCone_π {F : WalkingParallelFamily J ⥤ C} (t : Cone F) (j) :
    (Trident.ofCone t).π.app j = t.π.app j ≫ eqToHom (by cases j <;> aesop_cat) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C} (t : CategoryTheory.Limits.Cone F) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.Trident.ofCone t).π.app j =
  CategoryTheory.CategoryStruct.comp (t.π.app j) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.Limits.Cotrident.ofCocone_ι
@[simp]
theorem Cotrident.ofCocone_ι {F : WalkingParallelFamily J ⥤ C} (t : Cocone F) (j) :
    (Cotrident.ofCocone t).ι.app j = eqToHom (by cases j <;> aesop_cat) ≫ t.ι.app j 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C} (t : CategoryTheory.Limits.Cocone F) (j : CategoryTheory.Limits.WalkingParallelFamily J)
Goal: (CategoryTheory.Limits.Cotrident.ofCocone t).ι.app j =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (t.ι.app j)
-- CategoryTheory.Limits.Trident.mkHom_hom
@[simps]
def Trident.mkHom [Nonempty J] {s t : Trident f} (k : s.pt ⟶ t.pt)
    (w : k ≫ t.ι = s.ι := by aesop_cat) : s ⟶ t 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s t : CategoryTheory.Limits.Trident f} (k : s.pt ⟶ t.pt) (w : CategoryTheory.CategoryStruct.comp k t.ι = s.ι := by aesop_cat)
Goal: (CategoryTheory.Limits.Trident.mkHom k w).hom = k
-- CategoryTheory.Limits.Trident.ext_hom
@[simps]
def Trident.ext [Nonempty J] {s t : Trident f} (i : s.pt ≅ t.pt)
    (w : i.hom ≫ t.ι = s.ι := by aesop_cat) : s ≅ t 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s t : CategoryTheory.Limits.Trident f} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp i.hom t.ι = s.ι := by aesop_cat)
Goal: (CategoryTheory.Limits.Trident.ext i w).hom = CategoryTheory.Limits.Trident.mkHom i.hom w
-- CategoryTheory.Limits.Trident.ext_inv
@[simps]
def Trident.ext [Nonempty J] {s t : Trident f} (i : s.pt ≅ t.pt)
    (w : i.hom ≫ t.ι = s.ι := by aesop_cat) : s ≅ t 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s t : CategoryTheory.Limits.Trident f} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp i.hom t.ι = s.ι := by aesop_cat)
Goal: (CategoryTheory.Limits.Trident.ext i w).inv = CategoryTheory.Limits.Trident.mkHom i.inv ⋯
-- CategoryTheory.Limits.Cotrident.mkHom_hom
@[simps]
def Cotrident.mkHom [Nonempty J] {s t : Cotrident f} (k : s.pt ⟶ t.pt)
    (w : s.π ≫ k = t.π := by aesop_cat) : s ⟶ t 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J] {s t : CategoryTheory.Limits.Cotrident f} (k : s.pt ⟶ t.pt) (w : CategoryTheory.CategoryStruct.comp s.π k = t.π := by aesop_cat)
Goal: (CategoryTheory.Limits.Cotrident.mkHom k w).hom = k
-- CategoryTheory.Limits.wideEqualizer.trident_ι
@[simp]
theorem wideEqualizer.trident_ι : (wideEqualizer.trident f).ι = wideEqualizer.ι f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)) [CategoryTheory.Limits.HasWideEqualizer f]
Goal: (CategoryTheory.Limits.wideEqualizer.trident f).ι = CategoryTheory.Limits.wideEqualizer.ι f