File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

full_name: CategoryTheory.Limits.instHasLimitOppositeOpOfHasColimit
code: instance (F : I ⥤ C) [HasColimit F] : HasLimit F.op 
goal: CategoryTheory.Limits.HasLimit F.op

full_name: CategoryTheory.Limits.limitOpIsoOpColimit
code: /-- The limit of `F.op` is the opposite of `colimit F`. -/
noncomputable def limitOpIsoOpColimit (F : I ⥤ C) [HasColimit F] :
    limit F.op ≅ op <| colimit F 
goal: CategoryTheory.Limits.limit F.op ≅ Opposite.op (CategoryTheory.Limits.colimit F)

full_name: CategoryTheory.Limits.limitOpIsoOpColimit_inv_comp_π
code: @[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 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitOpIsoOpColimit F).inv
    (CategoryTheory.Limits.limit.π F.op (Opposite.op i)) =
  (CategoryTheory.Limits.colimit.ι F i).op

full_name: CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι
code: @[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⟩ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitOpIsoOpColimit F).hom
    (CategoryTheory.Limits.colimit.ι F i).op =
  CategoryTheory.Limits.limit.π F.op (Opposite.op i)

full_name: CategoryTheory.Limits.instHasLimitOppositeRightOpOfHasColimit
code: instance (F : Iᵒᵖ ⥤ C) [HasColimit F] : HasLimit F.rightOp 
goal: CategoryTheory.Limits.HasLimit F.rightOp

full_name: CategoryTheory.Limits.limitRightOpIsoOpColimit
code: /-- `limitOpIsoOpColimit` for contravariant functor. -/
noncomputable def limitRightOpIsoOpColimit (F : Iᵒᵖ ⥤ C) [HasColimit F] :
    limit F.rightOp ≅ op <| colimit F 
goal: CategoryTheory.Limits.limit F.rightOp ≅ Opposite.op (CategoryTheory.Limits.colimit F)

full_name: CategoryTheory.Limits.limitRightOpIsoOpColimit_inv_comp_π
code: @[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 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitRightOpIsoOpColimit F).inv
    (CategoryTheory.Limits.limit.π F.rightOp i) =
  (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op

full_name: CategoryTheory.Limits.limitRightOpIsoOpColimit_hom_comp_ι
code: @[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 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitRightOpIsoOpColimit F).hom
    (CategoryTheory.Limits.colimit.ι F (Opposite.op i)).op =
  CategoryTheory.Limits.limit.π F.rightOp i

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda
code: /-- Hom is functorially cocontinuous: coyoneda of a colimit is the limit
over coyoneda of the diagram. -/
noncomputable def coyonedaOpColimitIsoLimitCoyoneda :
    coyoneda.obj (op <| colimit F) ≅ limit (F.op ⋙ coyoneda) 
goal: CategoryTheory.coyoneda.obj (Opposite.op (CategoryTheory.Limits.colimit F)) ≅
  CategoryTheory.Limits.limit (F.op.comp CategoryTheory.coyoneda)

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π
code: @[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ limit.π (F.op.comp coyoneda) ⟨i⟩
      = coyoneda.map (colimit.ι F i).op 
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

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda_inv_comp_π
code: @[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_inv_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).inv ≫ coyoneda.map (colimit.ι F i).op
      = limit.π (F.op.comp coyoneda) ⟨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)

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda
code: /-- Hom is cocontinuous: homomorphisms from a colimit is the limit over yoneda of the diagram. -/
noncomputable def colimitHomIsoLimitYoneda
    [HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) :
    (colimit F ⟶ A) ≅ limit (F.op ⋙ yoneda.obj A) 
goal: (CategoryTheory.Limits.colimit F ⟶ A) ≅ CategoryTheory.Limits.limit (F.op.comp (CategoryTheory.yoneda.obj A))

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda_hom_comp_π
code: @[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 
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

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda_inv_comp_π
code: @[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⟩ 
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)

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'
code: /-- Variant of `coyonedaOoColimitIsoLimitCoyoneda` for contravariant `F`. -/
noncomputable def coyonedaOpColimitIsoLimitCoyoneda' :
    coyoneda.obj (op <| colimit F) ≅ limit (F.rightOp ⋙ coyoneda) 
goal: CategoryTheory.coyoneda.obj (Opposite.op (CategoryTheory.Limits.colimit F)) ≅
  CategoryTheory.Limits.limit (F.rightOp.comp CategoryTheory.coyoneda)

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π
code: @[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda' F).hom ≫ limit.π (F.rightOp ⋙ coyoneda) i
      = coyoneda.map (colimit.ι F ⟨i⟩).op 
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

full_name: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π
code: @[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda' F).inv ≫ coyoneda.map (colimit.ι F ⟨i⟩).op
      = limit.π (F.rightOp ⋙ coyoneda) 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

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda'
code: /-- Variant of `colimitHomIsoLimitYoneda` for contravariant `F`. -/
noncomputable def colimitHomIsoLimitYoneda' [HasLimitsOfShape I (Type u₂)] (A : C) :
    (colimit F ⟶ A) ≅ limit (F.rightOp ⋙ yoneda.obj A) 
goal: (CategoryTheory.Limits.colimit F ⟶ A) ≅ CategoryTheory.Limits.limit (F.rightOp.comp (CategoryTheory.yoneda.obj A))

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda'_hom_comp_π
code: @[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 
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

full_name: CategoryTheory.Limits.colimitHomIsoLimitYoneda'_inv_comp_π
code: @[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 
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

full_name: CategoryTheory.Limits.colimitCoyonedaHomIsoLimit
code: /-- Pro-Coyoneda lemma: homorphisms from colimit of coyoneda of diagram `D` to `F` is limit
of `F` evaluated at `D`. -/
noncomputable def colimitCoyonedaHomIsoLimit :
    (colimit (D.rightOp ⋙ coyoneda) ⟶ F) ≅ limit (D ⋙ F ⋙ uliftFunctor.{u₁}) 
goal: (CategoryTheory.Limits.colimit (D.rightOp.comp CategoryTheory.coyoneda) ⟶ F) ≅
  CategoryTheory.Limits.limit (D.comp (F.comp CategoryTheory.uliftFunctor.{u₁, u₂}))

full_name: CategoryTheory.Limits.colimitCoyonedaHomIsoLimit_π_apply
code: @[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))))⟩ 
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)))) }

full_name: CategoryTheory.Limits.colimitCoyonedaHomIsoLimit'
code: /-- A variant of `colimitCoyonedaHomIsoLimit` for a contravariant diagram. -/
noncomputable def colimitCoyonedaHomIsoLimit' :
    (colimit (D.op ⋙ coyoneda) ⟶ F) ≅ limit (D ⋙ F ⋙ uliftFunctor.{u₁}) 
goal: (CategoryTheory.Limits.colimit (D.op.comp CategoryTheory.coyoneda) ⟶ F) ≅
  CategoryTheory.Limits.limit (D.comp (F.comp CategoryTheory.uliftFunctor.{u₁, u₂}))

full_name: CategoryTheory.Limits.colimitCoyonedaHomIsoLimit'_π_apply
code: @[simp]
lemma colimitCoyonedaHomIsoLimit'_π_apply (f : colimit (D.op ⋙ coyoneda) ⟶ F) (i : I) :
    limit.π (D ⋙ F ⋙ uliftFunctor.{u₁}) i ((colimitCoyonedaHomIsoLimit' D F).hom f)
      = ⟨f.app (D.obj i) ((colimit.ι (D.op ⋙ coyoneda) ⟨i⟩).app (D.obj i) (𝟙 (D.obj i)))⟩ 
goal: CategoryTheory.Limits.limit.π (D.comp (F.comp CategoryTheory.uliftFunctor.{u₁, u₂})) i
    ((CategoryTheory.Limits.colimitCoyonedaHomIsoLimit' D F).hom f) =
  {
    down :=
      f.app (D.obj i)
        ((CategoryTheory.Limits.colimit.ι (D.op.comp CategoryTheory.coyoneda) (Opposite.op i)).app (D.obj i)
          (CategoryTheory.CategoryStruct.id (D.obj i))) }