ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.prod.leftUnitorEquivalence_inverse
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.leftUnitorEquivalence C).inverse = CategoryTheory.prod.leftInverseUnitor C
-- CategoryTheory.prod.leftUnitorEquivalence_counitIso
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.leftUnitorEquivalence C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.prod.leftInverseUnitor C ⋙ CategoryTheory.prod.leftUnitor C)
-- CategoryTheory.prod.leftUnitorEquivalence_unitIso
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.leftUnitorEquivalence C).unitIso =
  CategoryTheory.Iso.refl (𝟭 (CategoryTheory.Discrete PUnit.{w + 1} × C))
-- CategoryTheory.prod.rightUnitorEquivalence_unitIso
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.rightUnitorEquivalence C).unitIso =
  CategoryTheory.Iso.refl (𝟭 (C × CategoryTheory.Discrete PUnit.{w + 1}))
-- CategoryTheory.prod.rightUnitorEquivalence_counitIso
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.rightUnitorEquivalence C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.prod.rightInverseUnitor C ⋙ CategoryTheory.prod.rightUnitor C)
-- CategoryTheory.prod.rightUnitorEquivalence_functor
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.rightUnitorEquivalence C).functor = CategoryTheory.prod.rightUnitor C
-- CategoryTheory.prod.rightUnitorEquivalence_inverse
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.rightUnitorEquivalence C).inverse = CategoryTheory.prod.rightInverseUnitor C
-- CategoryTheory.Functor.Final.out
class Final (F : C ⥤ D) : Prop where
  out (d : D) : IsConnected (StructuredArrow d F)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [self : F.Final] (d : D)
Goal: CategoryTheory.IsConnected (CategoryTheory.StructuredArrow d F)
-- CategoryTheory.Functor.Initial.out
class Initial (F : C ⥤ D) : Prop where
  out (d : D) : IsConnected (CostructuredArrow F d)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [self : F.Initial] (d : D)
Goal: CategoryTheory.IsConnected (CategoryTheory.CostructuredArrow F d)
-- CategoryTheory.Functor.final_of_initial_op
theorem final_of_initial_op (F : C ⥤ D) [Initial F.op] : Final F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.op.Initial]
Goal: F.Final
-- CategoryTheory.Functor.initial_of_final_op
theorem initial_of_final_op (F : C ⥤ D) [Final F.op] : Initial F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.op.Final]
Goal: F.Initial
-- CategoryTheory.Functor.final_of_adjunction
theorem final_of_adjunction {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) : Final R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (adj : L ⊣ R)
Goal: R.Final
-- CategoryTheory.Functor.initial_of_adjunction
theorem initial_of_adjunction {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) : Initial L 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (adj : L ⊣ R)
Goal: L.Initial
-- CategoryTheory.Functor.final_of_natIso
theorem final_of_natIso {F F' : C ⥤ D} [Final F] (i : F ≅ F') : Final F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} [F.Final] (i : F ≅ F')
Goal: F'.Final
-- CategoryTheory.Functor.final_natIso_iff
theorem final_natIso_iff {F F' : C ⥤ D} (i : F ≅ F') : Final F ↔ Final F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (i : F ≅ F')
Goal: F.Final ↔ F'.Final
-- CategoryTheory.Functor.initial_of_natIso
theorem initial_of_natIso {F F' : C ⥤ D} [Initial F] (i : F ≅ F') : Initial F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} [F.Initial] (i : F ≅ F')
Goal: F'.Initial
-- CategoryTheory.Functor.initial_natIso_iff
theorem initial_natIso_iff {F F' : C ⥤ D} (i : F ≅ F') : Initial F ↔ Initial F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (i : F ≅ F')
Goal: F.Initial ↔ F'.Initial
-- CategoryTheory.Functor.Final.extendCocone_obj_pt
@[simps]
def extendCocone : Cocone (F ⋙ G) ⥤ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cocone (F.comp G))
Goal: (CategoryTheory.Functor.Final.extendCocone.obj c).pt = c.pt
-- CategoryTheory.Functor.Final.extendCocone_obj_ι_app
@[simps]
def extendCocone : Cocone (F ⋙ G) ⥤ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cocone (F.comp G)) (X : D)
Goal: (CategoryTheory.Functor.Final.extendCocone.obj c).ι.app X =
  CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Functor.Final.homToLift F X))
    (c.ι.app (CategoryTheory.Functor.Final.lift F X))
-- CategoryTheory.Functor.Final.extendCocone_map_hom
@[simps]
def extendCocone : Cocone (F ⋙ G) ⥤ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E}
Goal: ∀ {X Y : CategoryTheory.Limits.Cocone (F.comp G)} (f : X ⟶ Y),
  (CategoryTheory.Functor.Final.extendCocone.map f).hom = f.hom
-- CategoryTheory.Functor.Final.colimit_cocone_comp_aux
@[simp]
theorem colimit_cocone_comp_aux (s : Cocone (F ⋙ G)) (j : C) :
    G.map (homToLift F (F.obj j)) ≫ s.ι.app (lift F (F.obj j)) = s.ι.app j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (s : CategoryTheory.Limits.Cocone (F.comp G)) (j : C)
Goal: CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Functor.Final.homToLift F (F.obj j)))
    (s.ι.app (CategoryTheory.Functor.Final.lift F (F.obj j))) =
  s.ι.app j
-- CategoryTheory.Functor.Final.coconesEquiv_inverse
@[simps]
def coconesEquiv : Cocone (F ⋙ G) ≌ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Final.coconesEquiv F G).inverse = CategoryTheory.Limits.Cocones.whiskering F
-- CategoryTheory.Functor.Final.coconesEquiv_unitIso
@[simps]
def coconesEquiv : Cocone (F ⋙ G) ≌ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Final.coconesEquiv F G).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).obj c).pt) ⋯)
    ⋯
-- CategoryTheory.Functor.Final.coconesEquiv_functor
@[simps]
def coconesEquiv : Cocone (F ⋙ G) ≌ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Final.coconesEquiv F G).functor = CategoryTheory.Functor.Final.extendCocone
-- CategoryTheory.Functor.Final.coconesEquiv_counitIso
@[simps]
def coconesEquiv : Cocone (F ⋙ G) ≌ Cocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Final.coconesEquiv F G).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cocones.whiskering F).comp CategoryTheory.Functor.Final.extendCocone).obj c).pt)
        ⋯)
    ⋯
-- CategoryTheory.Functor.Final.colimitCoconeComp_isColimit
@[simps]
def colimitCoconeComp (t : ColimitCocone G) : ColimitCocone (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone G)
Goal: (CategoryTheory.Functor.Final.colimitCoconeComp F t).isColimit =
  (CategoryTheory.Functor.Final.isColimitWhiskerEquiv F t.cocone).symm t.isColimit
-- CategoryTheory.Functor.Final.colimitCoconeComp_cocone
@[simps]
def colimitCoconeComp (t : ColimitCocone G) : ColimitCocone (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone G)
Goal: (CategoryTheory.Functor.Final.colimitCoconeComp F t).cocone = CategoryTheory.Limits.Cocone.whisker F t.cocone
-- CategoryTheory.Functor.Final.colimitCoconeOfComp_isColimit
@[simps]
def colimitCoconeOfComp (t : ColimitCocone (F ⋙ G)) : ColimitCocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone (F.comp G))
Goal: (CategoryTheory.Functor.Final.colimitCoconeOfComp F t).isColimit =
  (CategoryTheory.Functor.Final.isColimitExtendCoconeEquiv F t.cocone).symm t.isColimit
-- CategoryTheory.Functor.Final.colimitCoconeOfComp_cocone
@[simps]
def colimitCoconeOfComp (t : ColimitCocone (F ⋙ G)) : ColimitCocone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone (F.comp G))
Goal: (CategoryTheory.Functor.Final.colimitCoconeOfComp F t).cocone = CategoryTheory.Functor.Final.extendCocone.obj t.cocone
-- CategoryTheory.Functor.Final.hasColimit_of_comp
theorem hasColimit_of_comp [HasColimit (F ⋙ G)] : HasColimit G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} [CategoryTheory.Limits.HasColimit (F.comp G)]
Goal: CategoryTheory.Limits.HasColimit G
-- CategoryTheory.Functor.Final.hasColimitsOfShape_of_final
theorem hasColimitsOfShape_of_final [HasColimitsOfShape C E] : HasColimitsOfShape D E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Limits.HasColimitsOfShape C E]
Goal: CategoryTheory.Limits.HasColimitsOfShape D E
-- CategoryTheory.Functor.Final.zigzag_of_eqvGen_quot_rel
theorem zigzag_of_eqvGen_quot_rel {F : C ⥤ D} {d : D} {f₁ f₂ : ΣX, d ⟶ F.obj X}
    (t : EqvGen (Types.Quot.Rel.{v, v} (F ⋙ coyoneda.obj (op d))) f₁ f₂) :
    Zigzag (StructuredArrow.mk f₁.2) (StructuredArrow.mk f₂.2) 
Arguments: {C : Type v} [CategoryTheory.Category.{v, v} C] {D : Type u₁} [CategoryTheory.Category.{v, u₁} D] {F : CategoryTheory.Functor C D} {d : D} {f₁ f₂ : (X : C) × (d ⟶ F.obj X)} (t : EqvGen (CategoryTheory.Limits.Types.Quot.Rel (F.comp (CategoryTheory.coyoneda.obj (Opposite.op d)))) f₁ f₂)
Goal: CategoryTheory.Zigzag (CategoryTheory.StructuredArrow.mk f₁.snd) (CategoryTheory.StructuredArrow.mk f₂.snd)
-- CategoryTheory.Functor.cofinal_of_colimit_comp_coyoneda_iso_pUnit
theorem cofinal_of_colimit_comp_coyoneda_iso_pUnit
    (I : ∀ d, colimit (F ⋙ coyoneda.obj (op d)) ≅ PUnit) : Final F 
Arguments: {C : Type v} [CategoryTheory.Category.{v, v} C] {D : Type u₁} [CategoryTheory.Category.{v, u₁} D] (F : CategoryTheory.Functor C D) (I : (d : D) → CategoryTheory.Limits.colimit (F.comp (CategoryTheory.coyoneda.obj (Opposite.op d))) ≅ PUnit.{v + 1})
Goal: F.Final
-- CategoryTheory.Functor.cofinal_of_isTerminal_colimit_comp_yoneda
theorem cofinal_of_isTerminal_colimit_comp_yoneda
    (h : IsTerminal (colimit (F ⋙ yoneda))) : Final F 
Arguments: {C : Type v} [CategoryTheory.Category.{v, v} C] {D : Type u₁} [CategoryTheory.Category.{v, u₁} D] (F : CategoryTheory.Functor C D) (h : CategoryTheory.Limits.IsTerminal (CategoryTheory.Limits.colimit (F.comp CategoryTheory.yoneda)))
Goal: F.Final
-- CategoryTheory.Functor.final_iff_isIso_colimit_pre
theorem final_iff_isIso_colimit_pre : Final F ↔ ∀ G : D ⥤ Type v, IsIso (colimit.pre G F) 
Arguments: {C : Type v} [CategoryTheory.Category.{v, v} C] {D : Type v} [CategoryTheory.Category.{v, v} D] (F : CategoryTheory.Functor C D)
Goal: F.Final ↔ ∀ (G : CategoryTheory.Functor D (Type v)), CategoryTheory.IsIso (CategoryTheory.Limits.colimit.pre G F)
-- CategoryTheory.Functor.Initial.extendCone_map_hom
@[simps]
def extendCone : Cone (F ⋙ G) ⥤ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E}
Goal: ∀ {X Y : CategoryTheory.Limits.Cone (F.comp G)} (f : X ⟶ Y),
  (CategoryTheory.Functor.Initial.extendCone.map f).hom = f.hom
-- CategoryTheory.Functor.Initial.extendCone_obj_pt
@[simps]
def extendCone : Cone (F ⋙ G) ⥤ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cone (F.comp G))
Goal: (CategoryTheory.Functor.Initial.extendCone.obj c).pt = c.pt
-- CategoryTheory.Functor.Initial.extendCone_obj_π_app
@[simps]
def extendCone : Cone (F ⋙ G) ⥤ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cone (F.comp G)) (d : D)
Goal: (CategoryTheory.Functor.Initial.extendCone.obj c).π.app d =
  CategoryTheory.CategoryStruct.comp (c.π.app (CategoryTheory.Functor.Initial.lift F d))
    (G.map (CategoryTheory.Functor.Initial.homToLift F d))
-- CategoryTheory.Functor.Initial.limit_cone_comp_aux
@[simp]
theorem limit_cone_comp_aux (s : Cone (F ⋙ G)) (j : C) :
    s.π.app (lift F (F.obj j)) ≫ G.map (homToLift F (F.obj j)) = s.π.app j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (s : CategoryTheory.Limits.Cone (F.comp G)) (j : C)
Goal: CategoryTheory.CategoryStruct.comp (s.π.app (CategoryTheory.Functor.Initial.lift F (F.obj j)))
    (G.map (CategoryTheory.Functor.Initial.homToLift F (F.obj j))) =
  s.π.app j
-- CategoryTheory.Functor.Initial.conesEquiv_counitIso
@[simps]
def conesEquiv : Cone (F ⋙ G) ≌ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Initial.conesEquiv F G).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cones.whiskering F).comp CategoryTheory.Functor.Initial.extendCone).obj c).pt)
        ⋯)
    ⋯
-- CategoryTheory.Functor.Initial.conesEquiv_inverse
@[simps]
def conesEquiv : Cone (F ⋙ G) ≌ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Initial.conesEquiv F G).inverse = CategoryTheory.Limits.Cones.whiskering F
-- CategoryTheory.Functor.Initial.conesEquiv_functor
@[simps]
def conesEquiv : Cone (F ⋙ G) ≌ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Initial.conesEquiv F G).functor = CategoryTheory.Functor.Initial.extendCone
-- CategoryTheory.Functor.Initial.conesEquiv_unitIso
@[simps]
def conesEquiv : Cone (F ⋙ G) ≌ Cone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (G : CategoryTheory.Functor D E)
Goal: (CategoryTheory.Functor.Initial.conesEquiv F G).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cone (F.comp G))).obj c).pt) ⋯)
    ⋯
-- CategoryTheory.Functor.Initial.limitConeComp_isLimit
@[simps]
def limitConeComp (t : LimitCone G) : LimitCone (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone G)
Goal: (CategoryTheory.Functor.Initial.limitConeComp F t).isLimit =
  (CategoryTheory.Functor.Initial.isLimitWhiskerEquiv F t.cone).symm t.isLimit
-- CategoryTheory.Functor.Initial.limitConeComp_cone
@[simps]
def limitConeComp (t : LimitCone G) : LimitCone (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone G)
Goal: (CategoryTheory.Functor.Initial.limitConeComp F t).cone = CategoryTheory.Limits.Cone.whisker F t.cone
-- CategoryTheory.Functor.Initial.limitConeOfComp_cone
@[simps]
def limitConeOfComp (t : LimitCone (F ⋙ G)) : LimitCone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone (F.comp G))
Goal: (CategoryTheory.Functor.Initial.limitConeOfComp F t).cone = CategoryTheory.Functor.Initial.extendCone.obj t.cone
-- CategoryTheory.Functor.Initial.limitConeOfComp_isLimit
@[simps]
def limitConeOfComp (t : LimitCone (F ⋙ G)) : LimitCone G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone (F.comp G))
Goal: (CategoryTheory.Functor.Initial.limitConeOfComp F t).isLimit =
  (CategoryTheory.Functor.Initial.isLimitExtendConeEquiv F t.cone).symm t.isLimit
-- CategoryTheory.Functor.Initial.hasLimit_of_comp
theorem hasLimit_of_comp [HasLimit (F ⋙ G)] : HasLimit G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor D E} [CategoryTheory.Limits.HasLimit (F.comp G)]
Goal: CategoryTheory.Limits.HasLimit G
-- CategoryTheory.Functor.Initial.hasLimitsOfShape_of_initial
theorem hasLimitsOfShape_of_initial [HasLimitsOfShape C E] : HasLimitsOfShape D E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Initial] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Limits.HasLimitsOfShape C E]
Goal: CategoryTheory.Limits.HasLimitsOfShape D E
-- CategoryTheory.Functor.final_of_comp_full_faithful
theorem final_of_comp_full_faithful [Full G] [Faithful G] [Final (F ⋙ G)] : Final F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Full] [G.Faithful] [(F.comp G).Final]
Goal: F.Final
-- CategoryTheory.Functor.initial_of_comp_full_faithful
theorem initial_of_comp_full_faithful [Full G] [Faithful G] [Initial (F ⋙ G)] : Initial F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Full] [G.Faithful] [(F.comp G).Initial]
Goal: F.Initial
-- CategoryTheory.Functor.final_comp_equivalence
theorem final_comp_equivalence [Final F] [IsEquivalence G] : Final (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.Final] [G.IsEquivalence]
Goal: (F.comp G).Final
-- CategoryTheory.Functor.initial_comp_equivalence
theorem initial_comp_equivalence [Initial F] [IsEquivalence G] : Initial (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [F.Initial] [G.IsEquivalence]
Goal: (F.comp G).Initial