ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.projective_of_preservesFiniteColimits_preadditiveCoyonedaObj
theorem projective_of_preservesFiniteColimits_preadditiveCoyonedaObj (P : C)
    [hP : PreservesFiniteColimits (preadditiveCoyonedaObj (op P))] : Projective P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] (P : C) [hP : CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.preadditiveCoyonedaObj (Opposite.op P))]
Goal: CategoryTheory.Projective P
-- CategoryTheory.Limits.map_id_left_eq_curry_map
theorem map_id_left_eq_curry_map {j : J} {k k' : K} {f : k ⟶ k'} :
    F.map ((𝟙 j, f) : (j, k) ⟶ (j, k')) = ((curry.obj F).obj j).map f 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J × K ⥤ C) {j : J} {k k' : K} {f : k ⟶ k'}
Goal: F.map (𝟙 j, f) = ((CategoryTheory.curry.obj F).obj j).map f
-- CategoryTheory.Limits.map_id_right_eq_curry_swap_map
theorem map_id_right_eq_curry_swap_map {j j' : J} {f : j ⟶ j'} {k : K} :
    F.map ((f, 𝟙 k) : (j, k) ⟶ (j', k)) = ((curry.obj (Prod.swap K J ⋙ F)).obj k).map f 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J × K ⥤ C) {j j' : J} {f : j ⟶ j'} {k : K}
Goal: F.map (f, 𝟙 k) = ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F)).obj k).map f
-- CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π
@[reassoc (attr := simp)]
theorem ι_colimitLimitToLimitColimit_π (j) (k) :
    colimit.ι _ k ≫ colimitLimitToLimitColimit F ≫ limit.π _ j =
      limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J × K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] (j : J) (k : K)
Goal: CategoryTheory.Limits.colimit.ι
      (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F) ⋙ CategoryTheory.Limits.lim) k ≫
    CategoryTheory.Limits.colimitLimitToLimitColimit F ≫
      CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj F ⋙ CategoryTheory.Limits.colim) j =
  CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F)).obj k) j ≫
    CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj F).obj j) k
-- CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π_apply
@[simp]
theorem ι_colimitLimitToLimitColimit_π_apply [Small.{v} J] [Small.{v} K] (F : J × K ⥤ Type v)
    (j : J) (k : K) (f) : limit.π (curry.obj F ⋙ colim) j
        (colimitLimitToLimitColimit F (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
      colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f) 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] [Small.{v, u₁} J] [Small.{v, u₂} K] (F : J × K ⥤ Type v) (j : J) (k : K) (f : (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F) ⋙ CategoryTheory.Limits.lim).obj k)
Goal: CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj F ⋙ CategoryTheory.Limits.colim) j
    (CategoryTheory.Limits.colimitLimitToLimitColimit F
      (CategoryTheory.Limits.colimit.ι
        (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F) ⋙ CategoryTheory.Limits.lim) k f)) =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj F).obj j) k
    (CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ F)).obj k) j f)
-- CategoryTheory.Limits.colimitLimitToLimitColimitCone_hom
@[simps]
noncomputable def colimitLimitToLimitColimitCone (G : J ⥤ K ⥤ C) [HasLimit G] :
    colim.mapCone (limit.cone G) ⟶ limit.cone (G ⋙ colim) 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] (G : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimit G]
Goal: (CategoryTheory.Limits.colimitLimitToLimitColimitCone G).hom =
  CategoryTheory.Limits.colim.map (CategoryTheory.Limits.limitIsoSwapCompLim G).hom ≫
    CategoryTheory.Limits.colimitLimitToLimitColimit (CategoryTheory.uncurry.obj G) ≫
      CategoryTheory.Limits.lim.map
        (CategoryTheory.whiskerRight (CategoryTheory.currying.unitIso.app G).inv CategoryTheory.Limits.colim)
-- CategoryTheory.Limits.MonoCoprod.binaryCofan_inl
class MonoCoprod : Prop where
    binaryCofan_inl : ∀ ⦃A B : C⦄ (c : BinaryCofan A B) (_ : IsColimit c), Mono c.inl
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [self : CategoryTheory.Limits.MonoCoprod C] ⦃A B : C⦄ (c : CategoryTheory.Limits.BinaryCofan A B)
Goal: CategoryTheory.Limits.IsColimit c → CategoryTheory.Mono c.inl
-- CategoryTheory.Limits.MonoCoprod.binaryCofan_inr
theorem binaryCofan_inr {A B : C} [MonoCoprod C] (c : BinaryCofan A B) (hc : IsColimit c) :
    Mono c.inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B : C} [CategoryTheory.Limits.MonoCoprod C] (c : CategoryTheory.Limits.BinaryCofan A B) (hc : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Mono c.inr
-- CategoryTheory.Limits.MonoCoprod.mono_inl_iff
theorem mono_inl_iff {A B : C} {c₁ c₂ : BinaryCofan A B} (hc₁ : IsColimit c₁) (hc₂ : IsColimit c₂) :
    Mono c₁.inl ↔ Mono c₂.inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B : C} {c₁ c₂ : CategoryTheory.Limits.BinaryCofan A B} (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂)
Goal: CategoryTheory.Mono c₁.inl ↔ CategoryTheory.Mono c₂.inl
-- CategoryTheory.Limits.MonoCoprod.mk'
theorem mk' (h : ∀ A B : C, ∃ (c : BinaryCofan A B) (_ : IsColimit c), Mono c.inl) : MonoCoprod C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (h : ∀ (A B : C), ∃ c x, CategoryTheory.Mono c.inl)
Goal: CategoryTheory.Limits.MonoCoprod C
-- CategoryTheory.Limits.MonoCoprod.mono_binaryCofanSum_inl
lemma mono_binaryCofanSum_inl [MonoCoprod C] :
    Mono (binaryCofanSum c c₁ c₂ hc₁ hc₂).inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {I₁ : Type u_2} {I₂ : Type u_3} {X : I₁ ⊕ I₂ → C} (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl)) (c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂) [CategoryTheory.Limits.MonoCoprod C]
Goal: CategoryTheory.Mono (CategoryTheory.Limits.MonoCoprod.binaryCofanSum c c₁ c₂ hc₁ hc₂).inl
-- CategoryTheory.Limits.MonoCoprod.mono_binaryCofanSum_inr
lemma mono_binaryCofanSum_inr [MonoCoprod C] :
    Mono (binaryCofanSum c c₁ c₂ hc₁ hc₂).inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {I₁ : Type u_2} {I₂ : Type u_3} {X : I₁ ⊕ I₂ → C} (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl)) (c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂) [CategoryTheory.Limits.MonoCoprod C]
Goal: CategoryTheory.Mono (CategoryTheory.Limits.MonoCoprod.binaryCofanSum c c₁ c₂ hc₁ hc₂).inr
-- CategoryTheory.Limits.MonoCoprod.mono_binaryCofanSum_inl'
lemma mono_binaryCofanSum_inl' [MonoCoprod C] (inl : c₁.pt ⟶ c.pt)
    (hinl : ∀ (i₁ : I₁), c₁.inj i₁ ≫ inl = c.inj (Sum.inl i₁)) :
    Mono inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {I₁ : Type u_2} {I₂ : Type u_3} {X : I₁ ⊕ I₂ → C} (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl)) (c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂) [CategoryTheory.Limits.MonoCoprod C] (inl : c₁.pt ⟶ c.pt) (hinl : ∀ (i₁ : I₁), c₁.inj i₁ ≫ inl = c.inj (Sum.inl i₁))
Goal: CategoryTheory.Mono inl
-- CategoryTheory.Limits.MonoCoprod.mono_binaryCofanSum_inr'
lemma mono_binaryCofanSum_inr' [MonoCoprod C] (inr : c₂.pt ⟶ c.pt)
    (hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂)) :
    Mono inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {I₁ : Type u_2} {I₂ : Type u_3} {X : I₁ ⊕ I₂ → C} (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl)) (c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hc₂ : CategoryTheory.Limits.IsColimit c₂) [CategoryTheory.Limits.MonoCoprod C] (inr : c₂.pt ⟶ c.pt) (hinr : ∀ (i₂ : I₂), c₂.inj i₂ ≫ inr = c.inj (Sum.inr i₂))
Goal: CategoryTheory.Mono inr
-- CategoryTheory.Limits.MonoCoprod.mono_of_injective_aux
lemma mono_of_injective_aux (hι : Function.Injective ι) (c : Cofan X) (c₁ : Cofan (X ∘ ι))
    (hc : IsColimit c) (hc₁ : IsColimit c₁)
    (c₂ : Cofan (fun (k : ((Set.range ι)ᶜ : Set I)) => X k.1))
    (hc₂ : IsColimit c₂) : Mono (Cofan.IsColimit.desc hc₁ (fun i => c.inj (ι i))) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2} {J : Type u_3} (X : I → C) (ι : J → I) (hι : Function.Injective ι) (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ ι)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cofan fun k => X ↑k) (hc₂ : CategoryTheory.Limits.IsColimit c₂)
Goal: CategoryTheory.Mono (CategoryTheory.Limits.Cofan.IsColimit.desc hc₁ fun i => c.inj (ι i))
-- CategoryTheory.Limits.MonoCoprod.mono_of_injective
lemma mono_of_injective [HasCoproduct (fun (k : ((Set.range ι)ᶜ : Set I)) => X k.1)] :
    Mono (Cofan.IsColimit.desc hc₁ (fun i => c.inj (ι i))) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2} {J : Type u_3} (X : I → C) (ι : J → I) (hι : Function.Injective ι) (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ ι)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) [CategoryTheory.Limits.HasCoproduct fun k => X ↑k]
Goal: CategoryTheory.Mono (CategoryTheory.Limits.Cofan.IsColimit.desc hc₁ fun i => c.inj (ι i))
-- CategoryTheory.Limits.MonoCoprod.mono_of_injective'
lemma mono_of_injective' [HasCoproduct (X ∘ ι)] [HasCoproduct X]
    [HasCoproduct (fun (k : ((Set.range ι)ᶜ : Set I)) => X k.1)] :
    Mono (Sigma.desc (f := X ∘ ι) (fun j => Sigma.ι X (ι j))) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2} {J : Type u_3} (X : I → C) (ι : J → I) (hι : Function.Injective ι) [CategoryTheory.Limits.HasCoproduct (X ∘ ι)] [CategoryTheory.Limits.HasCoproduct X] [CategoryTheory.Limits.HasCoproduct fun k => X ↑k]
Goal: CategoryTheory.Mono (CategoryTheory.Limits.Sigma.desc fun j => CategoryTheory.Limits.Sigma.ι X (ι j))
-- CategoryTheory.Limits.MonoCoprod.mono_map'_of_injective
lemma mono_map'_of_injective [HasCoproduct (X ∘ ι)] [HasCoproduct X]
    [HasCoproduct (fun (k : ((Set.range ι)ᶜ : Set I)) => X k.1)] :
    Mono (Sigma.map' ι (fun j => 𝟙 ((X ∘ ι) j))) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2} {J : Type u_3} (X : I → C) (ι : J → I) (hι : Function.Injective ι) [CategoryTheory.Limits.HasCoproduct (X ∘ ι)] [CategoryTheory.Limits.HasCoproduct X] [CategoryTheory.Limits.HasCoproduct fun k => X ↑k]
Goal: CategoryTheory.Mono (CategoryTheory.Limits.Sigma.map' ι fun j => 𝟙 ((X ∘ ι) j))
-- CategoryTheory.Limits.MonoCoprod.mono_inj
lemma mono_inj (c : Cofan X) (h : IsColimit c) (i : I)
    [HasCoproduct (fun (k : ((Set.range (fun _ : Unit ↦ i))ᶜ : Set I)) => X k.1)] :
    Mono (Cofan.inj c i) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2} (X : I → C) (c : CategoryTheory.Limits.Cofan X) (h : CategoryTheory.Limits.IsColimit c) (i : I) [CategoryTheory.Limits.HasCoproduct fun k => X ↑k]
Goal: CategoryTheory.Mono (c.inj i)
-- CategoryTheory.Limits.MonoCoprod.monoCoprod_of_preservesCoprod_of_reflectsMono
theorem monoCoprod_of_preservesCoprod_of_reflectsMono [MonoCoprod D]
    [PreservesColimitsOfShape (Discrete WalkingPair) F]
    [ReflectsMonomorphisms F] : MonoCoprod C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] (F : C ⥤ D) [CategoryTheory.Limits.MonoCoprod D] [CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] [F.ReflectsMonomorphisms]
Goal: CategoryTheory.Limits.MonoCoprod C
-- CategoryTheory.Abelian.subobjectIsoSubobjectOp_apply
@[simps!]
def subobjectIsoSubobjectOp [Abelian C] (X : C) : Subobject X ≃o (Subobject (op X))ᵒᵈ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] (X : C) (a : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Abelian.subobjectIsoSubobjectOp X) a =
  CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op) ⋯ a
-- CategoryTheory.Abelian.subobjectIsoSubobjectOp_symm_apply
@[simps!]
def subobjectIsoSubobjectOp [Abelian C] (X : C) : Subobject X ≃o (Subobject (op X))ᵒᵈ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] (X : C) (a : (CategoryTheory.Subobject (Opposite.op X))ᵒᵈ)
Goal: (RelIso.symm (CategoryTheory.Abelian.subobjectIsoSubobjectOp X)) a =
  CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.kernel.ι f.unop)) ⋯ a
-- CategoryTheory.Limits.limitOpIsoOpColimit_inv_comp_π
@[reassoc (attr := simp)]
lemma limitOpIsoOpColimit_inv_comp_π (F : I ⥤ C) [HasColimit F] (i : I) :
    (limitOpIsoOpColimit F).inv ≫ limit.π F.op ⟨i⟩ = (colimit.ι F i).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitOpIsoOpColimit F).inv
    (CategoryTheory.Limits.limit.π F.op (Opposite.op i)) =
  (CategoryTheory.Limits.colimit.ι F i).op
-- CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι
@[reassoc (attr := simp)]
lemma limitOpIsoOpColimit_hom_comp_ι (F : I ⥤ C) [HasColimit F] (i : I) :
    (limitOpIsoOpColimit F).hom ≫ (colimit.ι F i).op = limit.π F.op ⟨i⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitOpIsoOpColimit F).hom
    (CategoryTheory.Limits.colimit.ι F i).op =
  CategoryTheory.Limits.limit.π F.op (Opposite.op i)
-- CategoryTheory.Limits.limitRightOpIsoOpColimit_inv_comp_π
@[reassoc (attr := simp)]
lemma limitRightOpIsoOpColimit_inv_comp_π (F : Iᵒᵖ ⥤ C) [HasColimit F] (i : I) :
    (limitRightOpIsoOpColimit F).inv ≫ limit.π F.rightOp i = (colimit.ι F ⟨i⟩).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitRightOpIsoOpColimit F).inv
    (CategoryTheory.Limits.limit.π F.rightOp i) =
  (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op
-- CategoryTheory.Limits.limitRightOpIsoOpColimit_hom_comp_ι
@[reassoc (attr := simp)]
lemma limitRightOpIsoOpColimit_hom_comp_ι (F : Iᵒᵖ ⥤ C) [HasColimit F] (i : I) :
    (limitRightOpIsoOpColimit F).hom ≫ (colimit.ι F ⟨i⟩).op = limit.π F.rightOp i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitRightOpIsoOpColimit F).hom
    (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op =
  CategoryTheory.Limits.limit.π F.rightOp i
-- CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ limit.π (F.op.comp coyoneda) ⟨i⟩
      = coyoneda.map (colimit.ι F i).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda F).hom
    (CategoryTheory.Limits.limit.π (F.op.comp CategoryTheory.coyoneda) (Opposite.op i)) =
  CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F i).op
-- CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda_inv_comp_π
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_inv_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).inv ≫ coyoneda.map (colimit.ι F i).op
      = limit.π (F.op.comp coyoneda) ⟨i⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda F).inv
    (CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F i).op) =
  CategoryTheory.Limits.limit.π (F.op.comp CategoryTheory.coyoneda) (Opposite.op i)
-- CategoryTheory.Limits.colimitHomIsoLimitYoneda_hom_comp_π
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda_hom_comp_π [HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda F A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) ⟨i⟩
      = (coyoneda.map (colimit.ι F i).op).app A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] [CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitHomIsoLimitYoneda F A).hom
    (CategoryTheory.Limits.limit.π (F.op.comp (CategoryTheory.yoneda.obj A)) (Opposite.op i)) =
  (CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F i).op).app A
-- CategoryTheory.Limits.colimitHomIsoLimitYoneda_inv_comp_π
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda_inv_comp_π [HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda F A).inv ≫ (coyoneda.map (colimit.ι F i).op).app A
      = limit.π (F.op ⋙ yoneda.obj A) ⟨i⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F] [CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitHomIsoLimitYoneda F A).inv
    ((CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F i).op).app A) =
  CategoryTheory.Limits.limit.π (F.op.comp (CategoryTheory.yoneda.obj A)) (Opposite.op i)
-- CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda' F).hom ≫ limit.π (F.rightOp ⋙ coyoneda) i
      = coyoneda.map (colimit.ι F ⟨i⟩).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda' F).hom
    (CategoryTheory.Limits.limit.π (F.rightOp.comp CategoryTheory.coyoneda) i) =
  CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op
-- CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda' F).inv ≫ coyoneda.map (colimit.ι F ⟨i⟩).op
      = limit.π (F.rightOp ⋙ coyoneda) i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda' F).inv
    (CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op) =
  CategoryTheory.Limits.limit.π (F.rightOp.comp CategoryTheory.coyoneda) i
-- CategoryTheory.Limits.colimitHomIsoLimitYoneda'_hom_comp_π
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda'_hom_comp_π [HasLimitsOfShape I (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda' F A).hom ≫ limit.π (F.rightOp ⋙ yoneda.obj A) i
      = (coyoneda.map (colimit.ι F ⟨i⟩).op).app A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] [CategoryTheory.Limits.HasLimitsOfShape I (Type u₂)] (A : C) (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitHomIsoLimitYoneda' F A).hom
    (CategoryTheory.Limits.limit.π (F.rightOp.comp (CategoryTheory.yoneda.obj A)) i) =
  (CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op).app A
-- CategoryTheory.Limits.colimitHomIsoLimitYoneda'_inv_comp_π
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda'_inv_comp_π [HasLimitsOfShape I (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda' F A).inv ≫ (coyoneda.map (colimit.ι F ⟨i⟩).op).app A
      = limit.π (F.rightOp ⋙ yoneda.obj A) i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (F : CategoryTheory.Functor Iᵒᵖ C) [CategoryTheory.Limits.HasColimit F] [CategoryTheory.Limits.HasLimitsOfShape I (Type u₂)] (A : C) (i : I)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitHomIsoLimitYoneda' F A).inv
    ((CategoryTheory.coyoneda.map (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op).app A) =
  CategoryTheory.Limits.limit.π (F.rightOp.comp (CategoryTheory.yoneda.obj A)) i
-- CategoryTheory.Limits.colimitCoyonedaHomIsoLimit_π_apply
@[simp]
lemma colimitCoyonedaHomIsoLimit_π_apply (f : colimit (D.rightOp ⋙ coyoneda) ⟶ F) (i : I) :
    limit.π (D ⋙ F ⋙ uliftFunctor.{u₁}) (op i) ((colimitCoyonedaHomIsoLimit D F).hom f)
      = ⟨f.app (D.obj (op i)) ((colimit.ι (D.rightOp ⋙ coyoneda) i).app (D.obj (op i))
          (𝟙 (D.obj (op i))))⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (D : CategoryTheory.Functor Iᵒᵖ C) (F : CategoryTheory.Functor C (Type u₂)) [CategoryTheory.Limits.HasColimit (D.rightOp.comp CategoryTheory.coyoneda)] [CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type (max u₁ u₂))] (f : CategoryTheory.Limits.colimit (D.rightOp.comp CategoryTheory.coyoneda) ⟶ F) (i : I)
Goal: CategoryTheory.Limits.limit.π (D.comp (F.comp CategoryTheory.uliftFunctor.{u₁, u₂})) (Opposite.op i)
    ((CategoryTheory.Limits.colimitCoyonedaHomIsoLimit D F).hom f) =
  {
    down :=
      f.app (D.obj (Opposite.op i))
        ((CategoryTheory.Limits.colimit.ι (D.rightOp.comp CategoryTheory.coyoneda) i).app (D.obj (Opposite.op i))
          (CategoryTheory.CategoryStruct.id (D.obj (Opposite.op i)))) }